...
Pregătire interviuri

100 de întrebări de interviu pentru DevOps / Cloud Engineer, cu răspunsuri

Întrebările care apar des la interviurile de DevOps / Cloud Engineer, 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.

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

  • 100întrebări
  • 51junior
  • 35mid
  • 14senior
  • 143 minde citit
Întrebări de interviu DevOps / Cloud Engineer cu răspunsuri

Un proces de interviu pentru un rol de DevOps sau Cloud Engineer are de obicei câteva etape: o discuție inițială cu cineva din HR sau cu un recruiter, unul sau două interviuri tehnice și, des, un exercițiu practic. Exercițiul poate fi o temă de acasă (de exemplu, containerizează o aplicație și scrie un pipeline care o publică) sau o sesiune live în care depanezi un server, citești un Dockerfile ori explici ce face un fișier Terraform. La final apare aproape mereu o discuție despre cum lucrezi în echipă și cum reacționezi când ceva pică în producție.

La nivel de junior se verifică fundamentul: Linux din linia de comandă, rețelistică de bază (DNS, TCP, HTTP), Git, Docker și o primă înțelegere a cloud-ului și a CI/CD. Nu se așteaptă să fi administrat clustere mari, ci să înțelegi de ce există fiecare unealtă și să te descurci logic când ceva nu merge. La nivel de mid apar întrebări despre Kubernetes în producție, Terraform cu state partajat, strategii de deploy, monitorizare și costuri, iar la senior despre arhitectură, compromisuri, incidente și cum faci sistemele să fie operabile de o echipă întreagă.

Pagina are 100 de întrebări grupate pe teme, fiecare cu un răspuns scurt, o explicație detaliată și o notă despre ce urmărește intervievatorul. Citește întâi răspunsul scurt și încearcă să formulezi singur explicația, apoi compară. Comenzile și exemplele de cod merită rulate pe o mașină virtuală sau într-un container: la interviurile de DevOps diferența o face cine a încercat efectiv lucrurile, nu cine le-a memorat.

Linux și bash

1 Junior

Ce înseamnă permisiunile rwxr-xr-x și ce face chmod 755?

Răspuns scurt: Sunt permisiunile de citire, scriere și execuție pentru proprietar, grup și restul utilizatorilor. chmod 755 dă proprietarului toate drepturile, iar grupului și celorlalți doar citire și execuție.

În Linux fiecare fișier are un proprietar (user), un grup și trei seturi de permisiuni: pentru proprietar, pentru membrii grupului și pentru toți ceilalți. Fiecare set are trei biți: r (read, citire), w (write, scriere) și x (execute, execuție). Pentru un director, x înseamnă dreptul de a intra în el, iar r dreptul de a-i lista conținutul.

Forma octală pornește de la valorile r=4, w=2, x=1, adunate pe fiecare set. Așa, 7 = 4+2+1 (rwx), 5 = 4+1 (r-x), 4 = doar citire.

BASH
chmod 755 deploy.sh      # rwxr-xr-x: scriptul poate fi rulat de oricine
chmod 600 ~/.ssh/id_ed25519   # rw-------: cheia privată doar pentru tine
chown app:app /var/lib/app    # schimbă proprietarul și grupul
ls -l deploy.sh

Exemplul cu cheia SSH e important în practică: clientul OpenSSH refuză să folosească o cheie privată dacă e lizibilă de alții. Există și forma simbolică, chmod u+x,g-w fisier, utilă când vrei să modifici un singur bit fără să le rescrii pe toate.

Ca regulă, evită chmod 777. Rezolvă problema de acces dând proprietarul corect sau adăugând utilizatorul în grupul potrivit, nu deschizând fișierul pentru toată lumea.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi să citești ls -l și să calculezi octalul. Greșeala tipică este să propui chmod 777 ca soluție universală.

2 Junior

Care e diferența dintre un proces și un thread? Cum vezi procesele care rulează?

Răspuns scurt: Un proces are propriul spațiu de memorie, iar thread-urile unui proces împart aceeași memorie. Procesele le vezi cu ps aux, top sau htop.

Un proces este un program aflat în execuție: are un PID (process ID), propriul spațiu de adrese, descriptori de fișiere deschise, variabile de mediu și un proces părinte (PPID). Un thread (fir de execuție) rulează în interiorul unui proces și împarte memoria cu celelalte thread-uri ale acelui proces, dar are propria stivă și propriii regiștri.

Consecința practică: thread-urile comunică ușor prin memoria comună, dar o eroare de memorie într-un thread poate dărâma tot procesul. Procesele separate sunt izolate unele de altele, deci mai robuste, dar comunicarea dintre ele costă mai mult (pipe-uri, socket-uri, fișiere).

BASH
ps aux --sort=-%mem | head     # procesele care folosesc cea mai multă memorie
ps -ef --forest                # arborele părinte-copil
top -H -p 1234                 # thread-urile procesului cu PID 1234
pgrep -a nginx                 # PID-urile și comanda pentru nginx

În top, coloana RES arată memoria fizică folosită efectiv, iar VIRT memoria virtuală rezervată, care e de obicei mult mai mare și nu înseamnă consum real. Toate procesele pornesc din PID 1, care pe majoritatea distribuțiilor moderne este systemd. Într-un container, PID 1 este chiar aplicația ta, detaliu important pentru tratarea semnalelor.

Ce urmărește intervievatorul: Se verifică noțiunile de bază de sistem de operare. Candidații confundă des memoria virtuală cu cea folosită efectiv.

3 Junior

Cum afli ce proces ascultă pe portul 8080?

Răspuns scurt: Cu ss -tlnp | grep 8080 sau sudo lsof -i :8080. Ambele arată procesul și PID-ul care a deschis socket-ul în modul LISTEN.

Când o aplicație nu pornește cu eroarea „address already in use”, primul pas este să afli cine ocupă portul. Unealta modernă este ss, care a înlocuit netstat pe majoritatea distribuțiilor.

BASH
sudo ss -tlnp | grep ':8080'
# LISTEN 0 4096 0.0.0.0:8080 0.0.0.0:* users:(("java",pid=2312,fd=45))

sudo lsof -i :8080
sudo fuser 8080/tcp

Opțiunile pentru ss: -t TCP, -u UDP, -l doar socket-urile în ascultare, -n afișează porturile ca numere (fără rezoluție DNS, deci mai rapid), -p procesul. Fără sudo nu vezi procesele altor utilizatori, așa că e normal să lipsească coloana de proces.

Uită-te și la adresa pe care ascultă: 127.0.0.1:8080 înseamnă că serviciul acceptă doar conexiuni locale, iar 0.0.0.0:8080 sau [::]:8080 înseamnă toate interfețele. O greșeală frecventă în containere este o aplicație care ascultă pe 127.0.0.1 în interiorul containerului: portul publicat cu Docker nu va funcționa, pentru că traficul vine pe altă interfață.

După ce ai PID-ul, ps -fp 2312 sau systemctl status 2312 îți spune ce este procesul și ce serviciu l-a pornit.

Ce urmărește intervievatorul: Este o întrebare de depanare zilnică. Contează să menționezi și diferența dintre ascultarea pe 127.0.0.1 și pe 0.0.0.0.

4 Junior

Care e diferența dintre kill -15 și kill -9?

Răspuns scurt: kill -15 trimite SIGTERM, prin care procesul e rugat să se oprească și poate face curățenie. kill -9 trimite SIGKILL, pe care procesul nu îl poate prinde: kernel-ul îl oprește imediat.

Comanda kill nu omoară neapărat procese, ci trimite semnale. Cele mai folosite:

  • SIGTERM (15): cerere politicoasă de oprire, valoarea implicită pentru kill PID. Aplicația poate prinde semnalul, termina cererile în curs, închide conexiunile la baza de date și scrie datele pe disc.
  • SIGKILL (9): nu poate fi prins sau ignorat. Procesul dispare imediat, fără curățenie: fișiere temporare rămase, tranzacții întrerupte, lock-uri neeliberate.
  • SIGINT (2): echivalentul lui Ctrl+C.
  • SIGHUP (1): folosit de multe daemon-uri (de exemplu nginx) pentru reîncărcarea configurației.

Ordinea corectă este SIGTERM, o perioadă de așteptare, apoi SIGKILL doar dacă procesul nu răspunde. Exact așa face și Kubernetes la oprirea unui pod: trimite SIGTERM, așteaptă terminationGracePeriodSeconds (implicit 30 de secunde), apoi SIGKILL. Docker face la fel la docker stop, cu 10 secunde implicit.

BASH
kill 2312            # SIGTERM
sleep 10
kill -0 2312 && kill -9 2312   # -0 doar verifică dacă procesul mai există

Dacă aplicația din container nu reacționează la SIGTERM, cauza frecventă este că rulează sub un shell ca PID 1, care nu transmite semnalul mai departe.

Ce urmărește intervievatorul: Se verifică dacă înțelegi oprirea controlată (graceful shutdown). Candidații care sar direct la kill -9 ridică semne de întrebare.

5 Junior

Ce diferență este între un hard link și un symbolic link?

Răspuns scurt: Un hard link este încă un nume pentru același inode, deci același fișier. Un symlink este un fișier separat care conține calea către altul și se strică dacă ținta e mutată sau ștearsă.

Pentru a înțelege diferența trebuie să știi ce este un inode: structura din sistemul de fișiere care descrie un fișier (permisiuni, proprietar, dimensiune, unde sunt blocurile de date). Numele fișierului este doar o intrare de director care arată spre un inode.

Un hard link adaugă încă un nume către același inode. Ambele nume sunt egale; datele dispar abia când se șterge ultimul nume și niciun proces nu mai ține fișierul deschis. Limitări: nu funcționează între sisteme de fișiere diferite și, în mod normal, nu se poate face pentru directoare.

Un symlink are propriul inode și conține doar o cale. Poate arăta spre directoare și spre alte partiții, dar devine „dangling” (agățat în gol) dacă ținta dispare.

BASH
ln fisier.txt hard.txt          # hard link
ln -s /opt/app/releases/v42 /opt/app/current   # symlink
ls -li                          # coloana 1 este numărul inode-ului
readlink -f /opt/app/current

Exemplul cu current este un tipar real de deploy: păstrezi mai multe versiuni în releases/, iar comutarea sau rollback-ul înseamnă doar mutarea symlink-ului, o operație rapidă. Tot pe symlink-uri se bazează și /etc/nginx/sites-enabled pe Debian și Ubuntu.

Ce urmărește intervievatorul: Întrebarea verifică dacă știi ce este un inode. O aplicare practică (deploy prin symlink) arată experiență reală.

6 Junior

Cum pornești, oprești și citești logurile unui serviciu gestionat de systemd?

Răspuns scurt: Cu systemctl start|stop|restart|status nume controlezi serviciul, cu systemctl enable îl pornești la boot, iar logurile le citești cu journalctl -u nume.

Pe majoritatea distribuțiilor actuale (Ubuntu, Debian, RHEL, Amazon Linux) serviciile sunt gestionate de systemd. Un serviciu se descrie printr-un fișier unit:

# /etc/systemd/system/api.service
[Unit]
Description=API intern
After=network-online.target

[Service]
User=api
ExecStart=/opt/api/bin/api --port 8080
Restart=on-failure
EnvironmentFile=/etc/api/env

[Install]
WantedBy=multi-user.target

Comenzi uzuale:

BASH
sudo systemctl daemon-reload        # după ce ai modificat un unit
sudo systemctl enable --now api     # pornește acum și la fiecare boot
systemctl status api                # stare, PID, ultimele linii de log
journalctl -u api -f                # loguri în timp real
journalctl -u api --since "1 hour ago" -p err

Diferența dintre start și enable apare des la interviu: start pornește serviciul acum, enable creează legătura ca el să pornească la boot. Restart=on-failure repornește automat procesul dacă iese cu cod de eroare, ceea ce acoperă căderile accidentale fără intervenție manuală.

Dacă un serviciu nu pornește, systemctl status arată codul de ieșire, iar journalctl -xeu api dă contextul complet. Uitarea lui daemon-reload după editarea unit-ului este o greșeală foarte comună.

Ce urmărește intervievatorul: Se verifică familiaritatea cu administrarea zilnică a unui server. Confuzia dintre start și enable este greșeala clasică.

7 Junior

Discul este plin. Cum afli ce ocupă spațiul și de ce df și du arată valori diferite?

Răspuns scurt: Cu df -h vezi ocuparea pe partiții, cu du -sh găsești directoarele mari. Diferența apare de obicei din fișiere șterse, dar încă ținute deschise de un proces, pe care du nu le mai vede.

Pașii tipici:

BASH
df -h                                   # ce partiție e plină
df -i                                   # inode-uri epuizate (multe fișiere mici)
sudo du -xh --max-depth=1 / | sort -h   # directoarele mari, fără alte partiții
sudo lsof +L1                           # fișiere șterse, încă deschise

df întreabă sistemul de fișiere câte blocuri sunt ocupate, iar du parcurge directoarele și adună dimensiunile fișierelor vizibile. Dacă cineva a șters cu rm un log de 20 GB în timp ce aplicația îl avea deschis, numele a dispărut (deci du nu îl mai numără), dar inode-ul și datele rămân până când procesul închide fișierul. df vede în continuare spațiul ocupat.

Soluția este restartarea procesului sau, pentru loguri, golirea fișierului în loc de ștergere: truncate -s 0 /var/log/app.log. Pe termen lung, configurezi logrotate (cu copytruncate sau cu semnal de redeschidere a logului) și limite pentru jurnalul systemd (SystemMaxUse= în journald.conf).

Vinovații obișnuiți sunt logurile, imaginile Docker vechi (docker system df, docker image prune), dump-urile de baze de date și cache-urile de build. Nu uita nici de df -i: un disc poate fi „plin” cu spațiu liber, dacă s-au terminat inode-urile.

Ce urmărește intervievatorul: Este o problemă de producție foarte frecventă. Intervievatorul caută explicația cu fișierele șterse, dar deschise.

8 Junior

Explică >, >>, | și 2>&1 în bash.

Răspuns scurt: > scrie ieșirea standard într-un fișier (îl suprascrie), >> adaugă la final, | trimite ieșirea unei comenzi la intrarea alteia, iar 2>&1 redirecționează erorile acolo unde merge deja ieșirea standard.

Fiecare proces pornește cu trei descriptori: 0 pentru stdin (intrare), 1 pentru stdout (ieșire normală) și 2 pentru stderr (erori). Redirectările lucrează cu acești descriptori.

BASH
echo "salut" > out.txt        # suprascrie out.txt
echo "încă" >> out.txt        # adaugă la final
grep ERROR app.log | wc -l    # pipe: ieșirea lui grep devine intrarea lui wc
./backup.sh > backup.log 2>&1 # stdout și stderr în același fișier
./backup.sh 2>/dev/null       # aruncă doar erorile
cmd &> all.log                # prescurtare bash pentru > all.log 2>&1

Ordinea contează. cmd > fisier 2>&1 trimite ambele fluxuri în fișier: întâi stdout merge în fișier, apoi stderr este copiat spre locul unde arată acum stdout. În schimb, cmd 2>&1 > fisier trimite erorile pe ecran, pentru că în momentul în care s-a evaluat 2>&1, stdout încă era terminalul.

Un pipe conectează doar stdout. Dacă vrei să filtrezi și erorile, scrii cmd 2>&1 | grep timeout. De reținut și tee, care scrie simultan pe ecran și în fișier: ./deploy.sh 2>&1 | tee deploy.log. În cron sau CI e util să salvezi ambele fluxuri, altfel erorile se pierd exact când ai nevoie de ele.

Ce urmărește intervievatorul: Se verifică înțelegerea descriptorilor de fișiere, nu doar memorarea sintaxei. Ordinea în 2>&1 este capcana obișnuită.

9 Junior

Scrie un one-liner care afișează cele mai frecvente 10 adrese IP dintr-un access log de nginx.

Răspuns scurt: awk '{print $1}' access.log | sort | uniq -c | sort -rn | head -10. Extrage prima coloană, grupează valorile identice, le numără și le ordonează descrescător.

În formatul implicit de log al nginx (combined), prima coloană este adresa IP a clientului. Soluția clasică folosește o succesiune de unelte mici, fiecare cu un singur rol:

BASH
awk '{print $1}' /var/log/nginx/access.log \
  | sort \
  | uniq -c \
  | sort -rn \
  | head -10
  • awk '{print $1}' extrage primul câmp, câmpurile fiind separate implicit prin spații.
  • sort pune valorile identice una lângă alta, obligatoriu pentru că uniq compară doar liniile consecutive.
  • uniq -c comprimă duplicatele și pune numărul de apariții în față.
  • sort -rn sortează numeric (-n) și descrescător (-r).
  • head -10 păstrează primele 10 linii.

Variante cerute des ca urmare:

BASH
# doar cererile cu status 5xx (coloana 9 în formatul combined)
awk '$9 ~ /^5/ {print $1}' access.log | sort | uniq -c | sort -rn | head
# totul în awk, fără sort | uniq
awk '{c[$1]++} END {for (ip in c) print c[ip], ip}' access.log | sort -rn | head

Dacă nginx stă în spatele unui load balancer, prima coloană va fi IP-ul load balancer-ului. Adresa reală a clientului vine atunci din antetul X-Forwarded-For, care trebuie inclus explicit în log_format.

Ce urmărește intervievatorul: Se verifică fluența în linia de comandă. Un plus este să explici de ce e nevoie de sort înainte de uniq.

10 Mid

Ce face set -euo pipefail la începutul unui script bash?

Răspuns scurt: Face scriptul să se oprească la prima comandă eșuată (-e), la folosirea unei variabile nedefinite (-u) și la eșecul oricărei comenzi dintr-un pipe (pipefail). Previne continuarea tăcută după erori.

Implicit, bash continuă execuția chiar dacă o comandă eșuează, ceea ce într-un script de deploy poate fi periculos. Exemplul clasic:

BASH
cd /opt/app/releases/$VERSIUNE
rm -rf ./*

Dacă VERSIUNE e goală sau directorul nu există, cd eșuează, iar rm rulează în directorul curent. Cu opțiunile de siguranță:

  • -e (errexit): scriptul iese la prima comandă cu cod de ieșire diferit de 0.
  • -u (nounset): folosirea unei variabile nedefinite este eroare, nu șir gol.
  • -o pipefail: un pipe eșuează dacă oricare comandă din el eșuează, nu doar ultima. Fără el, curl url | tar xz pare reușit chiar dacă curl a dat eroare.
BASH
#!/usr/bin/env bash
set -euo pipefail
trap 'echo "Eroare la linia $LINENO" >&2' ERR

VERSIUNE="${1:?Folosire: deploy.sh <versiune>}"
cd "/opt/app/releases/${VERSIUNE}"

Limitările lui -e trebuie cunoscute: nu se aplică comenzilor din condiții (if cmd, cmd || true), iar în funcții apelate din condiții comportamentul surprinde. Când o comandă are voie să eșueze, o marchezi explicit cu || true. Pune variabilele între ghilimele ("$VAR") și verifică scripturile cu ShellCheck, care prinde majoritatea capcanelor.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă dacă scrii scripturi defensive. Un candidat bun știe și limitările lui set -e.

11 Mid

Ce înseamnă load average și cum îl interpretezi?

Răspuns scurt: Load average este numărul mediu de procese care rulează sau așteaptă CPU ori I/O neîntreruptibil, pe ultimele 1, 5 și 15 minute. Îl compari cu numărul de nuclee, nu îl citești ca procent.

Comenzile uptime și top afișează trei valori, de exemplu load average: 3.80, 2.10, 1.05. Ele reprezintă medii exponențiale pe 1, 5 și 15 minute. Ordinea îți spune tendința: aici load-ul crește.

Pe Linux, load-ul include procesele în starea R (rulează sau sunt gata de rulare) și pe cele în starea D (uninterruptible sleep, de obicei așteptând disc sau rețea de tip NFS). De aceea un load mare nu înseamnă neapărat CPU ocupat: poate fi un disc lent.

Interpretarea depinde de numărul de nuclee (nproc). Un load de 4 pe o mașină cu 8 nuclee înseamnă capacitate liberă; același load pe un singur nucleu înseamnă că în medie trei procese așteaptă.

BASH
nproc
uptime
vmstat 1 5     # r = coadă de rulare, b = blocate, wa = timp de așteptare I/O
top            # %wa mare indică probleme de I/O

Dacă load-ul e mare, dar CPU-ul e aproape liber și wa e ridicat, problema este I/O. Dacă us și sy sunt aproape de 100%, problema e CPU. Pe mașini virtuale în cloud urmărește și st (steal), timpul în care hypervisor-ul a dat CPU-ul altor mașini, frecvent pe instanțele burstable care și-au epuizat creditele.

Ce urmărește intervievatorul: Se verifică dacă știi că load-ul nu e procent de CPU. Mulți candidați nu știu că pe Linux include și așteptarea după I/O.

12 Mid

Ce se întâmplă când un server Linux rămâne fără memorie? Cum citești free -h?

Răspuns scurt: Kernel-ul încearcă să elibereze cache-ul și să folosească swap, iar dacă nu reușește, OOM killer-ul oprește forțat procesul cu cel mai mare scor. În free -h coloana relevantă este available, nu free.

Linux folosește memoria liberă pentru cache de fișiere (page cache), așa că o coloană free mică este normală. Valoarea care contează este available: cât poate primi o aplicație nouă fără swap, incluzând cache-ul care poate fi eliberat.

BASH
free -h
#        total  used  free  shared  buff/cache  available
# Mem:    15Gi  9.1Gi 410Mi  120Mi     6.0Gi       5.9Gi

Când memoria se termină cu adevărat, kernel-ul folosește întâi swap-ul (dacă există), ceea ce încetinește mult sistemul. Dacă nici asta nu ajunge, intră în acțiune OOM killer: alege un proces după oom_score (în principal memoria ocupată) și îl oprește cu SIGKILL.

BASH
dmesg -T | grep -i -E "killed process|out of memory"
journalctl -k | grep -i oom
cat /proc/1234/oom_score

În containere, limita vine din cgroups: dacă un container depășește limita de memorie, este oprit chiar dacă mașina are memorie liberă. În Kubernetes vezi asta ca OOMKilled cu codul de ieșire 137 (128 + 9, adică SIGKILL).

Pentru serviciile critice poți ajusta oom_score_adj sau, în systemd, OOMScoreAdjust=. Totuși, soluția reală este să afli de ce crește memoria: o scurgere de memorie, un heap JVM setat mai mare decât limita containerului sau prea multe procese worker.

Ce urmărește intervievatorul: Se verifică înțelegerea memoriei în Linux și legătura cu containerele. Greșeala tipică este panica la valoarea mică din coloana free.

13 Senior

Un server de producție a devenit lent. Cum îl investighezi, pas cu pas?

Răspuns scurt: Pornesc de la simptom, apoi verific sistematic CPU, memorie, disc și rețea, uitându-mă la utilizare, saturație și erori pentru fiecare resursă. Corelez cu schimbările recente și abia apoi intru în detaliile aplicației.

O abordare structurată evită ghicitul. Folosesc metoda USE (Utilization, Saturation, Errors) propusă de Brendan Gregg: pentru fiecare resursă mă întreb cât e de folosită, dacă există coadă de așteptare și dacă apar erori.

Primele 60 de secunde arată de obicei așa:

BASH
uptime                 # load și tendința lui
dmesg -T | tail        # OOM, erori de disc, probleme de rețea
vmstat 1 5             # coadă CPU, swap, I/O wait
mpstat -P ALL 1 3      # un singur nucleu la 100%?
iostat -xz 1 3         # %util și await pe discuri
free -h
sar -n DEV 1 3         # trafic pe interfețe
ss -s                  # număr de conexiuni, TIME-WAIT
top                    # cine consumă

Apoi întreb „ce s-a schimbat?”: un deploy, o modificare de configurație, o creștere de trafic, un job programat, un vecin zgomotos pe același host. Graficele din monitorizare arată momentul exact și ajută la corelare.

Dacă resursele sistemului sunt în regulă, problema e probabil în aplicație sau în dependențe: pool de conexiuni la baza de date epuizat, query-uri lente, pauze de garbage collection, apeluri externe care ajung în timeout. Aici ajută strace -p PID -c, profilerele specifice limbajului și tracing-ul distribuit.

În paralel cu investigația, dacă impactul asupra utilizatorilor e mare, prioritar este să atenuez problema (rollback, scalare, scoaterea nodului din load balancer) și abia apoi să găsesc cauza.

Ce urmărește intervievatorul: La senior contează metoda, nu lista de comenzi. Intervievatorul urmărește dacă ai un proces sistematic și dacă te gândești la impact înainte de cauză.

Rețelistică: DNS, TLS, load balancing

14 Junior

Ce se întâmplă, pe scurt, când scrii o adresă web în browser și apeși Enter?

Răspuns scurt: Browserul rezolvă numele prin DNS, deschide o conexiune TCP către IP, negociază TLS pentru HTTPS, trimite cererea HTTP și primește răspunsul, pe care îl afișează încărcând apoi resursele suplimentare.

Pașii principali, pentru https://exemplu.ro/cont:

  • Rezolvarea DNS: browserul caută IP-ul în cache-ul propriu, apoi în cel al sistemului de operare (inclusiv /etc/hosts), apoi întreabă resolver-ul configurat. Acesta, dacă nu are răspunsul, întreabă serverele root, apoi pe cele pentru .ro, apoi serverul autoritativ al domeniului.
  • Conexiunea TCP: handshake-ul în trei pași (SYN, SYN-ACK, ACK) către IP, pe portul 443.
  • TLS: clientul și serverul negociază versiunea și algoritmii, serverul își prezintă certificatul, iar browserul verifică dacă e valid pentru exemplu.ro și semnat de o autoritate de încredere. Rezultă chei de sesiune pentru criptare.
  • Cererea HTTP: GET /cont cu antete precum Host, cookie-uri și Accept.
  • Pe server: cererea trece de obicei printr-un CDN sau load balancer, apoi prin reverse proxy, până la aplicație, care poate interoga o bază de date.
  • Răspunsul: cod de status, antete, corp HTML. Browserul parsează HTML-ul și încarcă CSS, JavaScript și imagini, adesea reutilizând aceeași conexiune.

Pentru un rol DevOps, intervievatorul se bucură când legi fiecare pas de punctele unde poate apărea o problemă: TTL DNS, certificat expirat, security group care blochează portul 443, timeout la load balancer. Comenzi utile: dig, curl -v, openssl s_client.

Ce urmărește intervievatorul: Este o întrebare de încălzire care arată cât de adânc înțelegi rețeaua. Răspunsurile slabe sar peste DNS sau peste TLS.

15 Junior

Ce tipuri de înregistrări DNS cunoști și ce este TTL-ul?

Răspuns scurt: Cele mai folosite sunt A (nume spre IPv4), AAAA (spre IPv6), CNAME (alias spre alt nume), MX (servere de e-mail), TXT (text, de exemplu SPF) și NS (serverele autoritative). TTL-ul spune cât timp poate fi păstrat răspunsul în cache.

DNS traduce nume în informații, iar fiecare tip de înregistrare are alt rol:

  • A: api.exemplu.ro -> 203.0.113.10.
  • AAAA: același lucru pentru IPv6.
  • CNAME: www.exemplu.ro -> exemplu.ro. Un CNAME nu poate coexista cu alte înregistrări pe același nume, deci nu se poate pune la rădăcina domeniului (apex). Furnizori precum Route 53 oferă pentru asta înregistrări de tip alias.
  • MX: serverele de e-mail, cu prioritate.
  • TXT: verificări de domeniu, SPF, DKIM, DMARC.
  • NS: ce servere sunt autoritative pentru zonă.
  • PTR: rezoluție inversă, de la IP la nume, importantă pentru serverele de e-mail.
BASH
dig +short api.exemplu.ro A
dig exemplu.ro MX
dig +trace exemplu.ro        # tot lanțul, de la root
dig @1.1.1.1 exemplu.ro      # întreabă un resolver anume

TTL-ul (time to live), exprimat în secunde, spune resolver-elor cât timp pot păstra răspunsul. Un TTL mare (de exemplu 86400, o zi) reduce numărul de interogări, dar face schimbările lente. Un TTL mic permite schimbări rapide, cu mai multe interogări.

De aici vine expresia „propagarea DNS”: nu se propagă nimic activ, ci cache-urile expiră pe rând. Înainte de o migrare planificată, scazi TTL-ul cu cel puțin un TTL vechi înainte de schimbare.

Ce urmărește intervievatorul: Se verifică noțiunile DNS folosite zilnic. Un plus este să știi de ce CNAME nu merge pe apex.

16 Junior

Care e diferența dintre TCP și UDP? Dă exemple de protocoale care folosesc fiecare.

Răspuns scurt: TCP stabilește o conexiune și garantează livrarea în ordine, cu retransmisii. UDP trimite datagrame independente, fără garanții, dar cu întârziere mai mică. HTTP/1.1 și SSH folosesc TCP; DNS și HTTP/3 (QUIC) folosesc UDP.

TCP (Transmission Control Protocol) începe cu un handshake în trei pași, numerotează octeții, confirmă ce a primit și retransmite ce s-a pierdut. Are control al fluxului (nu copleșește receptorul) și control al congestiei (nu copleșește rețeaua). Primești un flux de octeți complet și în ordine, cu prețul unei latențe mai mari la pornire și al blocării când se pierde un pachet.

UDP (User Datagram Protocol) trimite fiecare mesaj separat, fără conexiune, fără confirmare și fără ordine garantată. Este potrivit când viteza contează mai mult decât livrarea fiecărui pachet sau când aplicația își implementează propria logică de fiabilitate.

Exemple:

  • TCP: HTTP/1.1 și HTTP/2, SSH, SMTP, conexiunile la PostgreSQL și MySQL.
  • UDP: DNS (pentru interogările obișnuite; răspunsurile mari și transferurile de zonă folosesc TCP), NTP, streaming video și jocuri, VPN-uri precum WireGuard, HTTP/3 peste QUIC.
BASH
nc -vz db.intern 5432          # test de port TCP
nc -vzu dns.intern 53          # test UDP, mai puțin concludent

Pentru DevOps, distincția contează la regulile de firewall și security groups (deschizi protocolul corect), la load balancere (în AWS, Network Load Balancer suportă UDP, Application Load Balancer nu) și la depanare: un test UDP „reușit” nu dovedește nimic, pentru că lipsa răspunsului nu înseamnă eroare.

Ce urmărește intervievatorul: Este o întrebare fundamentală. Detaliul cu DNS peste TCP și cel cu QUIC arată o înțelegere mai bună decât media.

17 Junior

Ce înseamnă notația 10.0.1.0/24 și câte adrese conține?

Răspuns scurt: Este notația CIDR: primii 24 de biți sunt partea de rețea, iar restul de 8 biți identifică gazdele, deci 256 de adrese. În AWS, 5 dintre ele sunt rezervate în fiecare subnet, rămânând 251 utilizabile.

O adresă IPv4 are 32 de biți. În CIDR (Classless Inter-Domain Routing), numărul de după bară spune câți biți de la început sunt fixați pentru rețea. Numărul de adrese este 2 la puterea (32 minus prefix):

  • /32: o singură adresă, folosit în reguli de firewall pentru un host anume.
  • /24: 256 de adrese (10.0.1.0 până la 10.0.1.255).
  • /16: 65.536 de adrese, mărime obișnuită pentru un VPC.
  • 0.0.0.0/0: toate adresele.

Într-o rețea clasică, prima adresă este adresa rețelei, iar ultima este broadcast. În AWS sunt rezervate 5 adrese pe subnet: rețeaua, .1 pentru router, .2 pentru DNS, .3 rezervată pentru viitor și ultima.

Intervalele private (RFC 1918), care nu sunt rutate pe internet:

10.0.0.0/8
172.16.0.0/12
192.168.0.0/16

Pentru proiectare: împarte VPC-ul în subneturi pe zone de disponibilitate și pe roluri (public, privat, baze de date) și lasă loc de creștere. Evită suprapunerea cu rețelele altor medii sau ale birourilor, pentru că un VPC peering sau un VPN între rețele suprapuse nu poate funcționa. Comanda ipcalc 10.0.1.0/24 sau modulul Python ipaddress te ajută să verifici calculele.

Ce urmărește intervievatorul: Se verifică dacă poți planifica rețele. Mulți candidați uită de adresele rezervate și de problema suprapunerilor.

18 Junior

Ce diferență este între codurile HTTP 502, 503 și 504?

Răspuns scurt: 502 Bad Gateway: proxy-ul a primit un răspuns invalid de la backend sau conexiunea a fost refuzată ori închisă. 503 Service Unavailable: serviciul nu poate răspunde momentan. 504 Gateway Timeout: proxy-ul nu a primit răspuns de la backend în timp util.

Toate trei apar de obicei într-o arhitectură cu un intermediar (load balancer, reverse proxy, API gateway) între client și aplicație, iar fiecare indică alt loc de căutat.

  • 502 Bad Gateway: intermediarul a încercat să vorbească cu backend-ul și nu a primit un răspuns valid. Cauze tipice: aplicația a căzut, ascultă pe alt port, a închis conexiunea brusc sau keep-alive-ul aplicației e mai scurt decât al load balancer-ului.
  • 503 Service Unavailable: nu există un backend capabil să servească cererea: toate țintele sunt marcate nesănătoase de health check-uri, serviciul e în mentenanță sau aplicația refuză intenționat cererile din cauza supraîncărcării. Antetul Retry-After poate indica după cât timp să revii.
  • 504 Gateway Timeout: backend-ul a acceptat conexiunea, dar nu a răspuns în timeout-ul proxy-ului (de exemplu proxy_read_timeout în nginx, implicit 60 de secunde). Cauza e de obicei un query lent sau o dependență blocată.

Depanare: compari logurile proxy-ului cu ale aplicației. Dacă cererea nu apare deloc în logurile aplicației, problema e între proxy și aplicație (rețea, port, health check). Dacă apare și durează mult, problema e în aplicație.

BASH
curl -sv -o /dev/null https://exemplu.ro/api/raport
tail -f /var/log/nginx/error.log   # "upstream timed out", "connect() failed"

Ce urmărește intervievatorul: Este o întrebare practică de producție. Intervievatorul vrea să vadă că știi unde să cauți pentru fiecare cod.

19 Mid

Cum funcționează un handshake TLS și cum verifici certificatul unui site din linia de comandă?

Răspuns scurt: Clientul și serverul negociază versiunea și algoritmii, serverul trimite lanțul de certificate, clientul îl validează și ambii derivă chei de sesiune. Certificatul îl verifici cu openssl s_client -connect host:443 -servername host.

În TLS 1.3, handshake-ul se face într-un singur dus-întors:

  • Clientul trimite ClientHello: versiunile și algoritmii suportați, o parte de schimb de chei și numele domeniului prin SNI (Server Name Indication), ca serverul să știe ce certificat să prezinte când găzduiește mai multe domenii.
  • Serverul răspunde cu ServerHello, partea lui de schimb de chei, certificatul și o semnătură care dovedește că deține cheia privată.
  • Clientul validează certificatul: numele din SAN (Subject Alternative Name) se potrivește cu domeniul, nu a expirat și lanțul duce la o autoritate de certificare (CA) din magazinul de încredere.
  • Ambii derivă aceleași chei simetrice, iar restul traficului este criptat simetric, pentru că e mult mai rapid.
BASH
openssl s_client -connect exemplu.ro:443 -servername exemplu.ro </dev/null \
  | openssl x509 -noout -subject -issuer -dates -ext subjectAltName
curl -vI https://exemplu.ro 2>&1 | grep -E "expire|subject|issuer"

Probleme frecvente în producție: certificat expirat (soluția este reînnoirea automată, de exemplu cu certbot și Let's Encrypt sau cu AWS Certificate Manager), lanț incomplet (serverul nu trimite certificatul intermediar: browserele uneori se descurcă, dar curl și clienții din aplicații eșuează) și nume greșit în certificat. Monitorizarea datei de expirare cu alertă cu câteva săptămâni înainte este standard.

Ce urmărește intervievatorul: Se verifică dacă înțelegi TLS dincolo de „e criptat”. Problema lanțului incomplet este un detaliu care diferențiază candidații cu experiență.

20 Mid

Care e diferența dintre un load balancer de nivel 4 și unul de nivel 7?

Răspuns scurt: Un load balancer L4 distribuie conexiuni TCP sau UDP pe baza IP-ului și portului, fără să înțeleagă conținutul. Unul L7 înțelege HTTP și poate ruta după cale, host sau antete, poate termina TLS și poate modifica cereri.

Nivelurile vin din modelul OSI: nivelul 4 este transportul (TCP, UDP), nivelul 7 este aplicația (HTTP, gRPC).

Load balancer L4 (de exemplu AWS Network Load Balancer, HAProxy în mod tcp): alege un backend pentru fiecare conexiune și transferă octeții. Avantaje: performanță foarte mare, latență mică, orice protocol peste TCP sau UDP, adrese IP statice (la NLB). Dezavantaj: nu poate lua decizii pe baza URL-ului sau a antetelor.

Load balancer L7 (AWS Application Load Balancer, nginx, Envoy, Traefik): termină conexiunea HTTP, citește cererea și deschide alta către backend. Poate:

  • ruta /api/* spre un serviciu și / spre altul, sau după domeniu;
  • termina TLS și gestiona certificatele centralizat;
  • adăuga antete precum X-Forwarded-For;
  • face health check-uri pe un endpoint HTTP, nu doar verifica dacă portul e deschis;
  • aplica rate limiting, redirect HTTP spre HTTPS, sau un WAF.

Algoritmi de distribuție comuni: round robin, least connections, hash pe IP-ul sursă (afinitate). Sesiunile „lipicioase” (sticky sessions) rezolvă aplicații care țin starea în memorie, dar strică distribuția uniformă; e mai bine ca starea să stea într-un loc comun, precum Redis.

Alegerea tipică: L7 pentru aplicații web și API-uri, L4 pentru baze de date, protocoale proprii, trafic foarte mare sau când ai nevoie de IP fix.

Ce urmărește intervievatorul: Se verifică dacă poți alege componenta potrivită. Răspunsul bun include exemple concrete de cazuri pentru fiecare.

21 Mid

Ce este un reverse proxy? Scrie o configurație nginx minimă care trimite traficul către o aplicație pe portul 3000.

Răspuns scurt: Un reverse proxy primește cererile clienților în numele serverelor din spate și le trimite mai departe. Oferă terminare TLS, cache, compresie, limitare și ascunde topologia internă.

Un proxy obișnuit (forward) lucrează pentru clienți, de exemplu proxy-ul unei firme prin care angajații ies pe internet. Un reverse proxy lucrează pentru servere: clientul vorbește doar cu el și nu știe câte aplicații sunt în spate.

server {
    listen 80;
    server_name app.exemplu.ro;
    return 301 https://$host$request_uri;
}

server {
    listen 443 ssl;
    server_name app.exemplu.ro;
    ssl_certificate     /etc/letsencrypt/live/app.exemplu.ro/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/app.exemplu.ro/privkey.pem;

    location / {
        proxy_pass http://127.0.0.1:3000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_read_timeout 60s;
    }
}

Antetele contează: fără X-Forwarded-For, aplicația vede doar IP-ul proxy-ului; fără X-Forwarded-Proto, aplicația crede că cererea a venit pe HTTP și poate genera redirect-uri greșite. Pentru WebSocket mai sunt necesare antetele Upgrade și Connection.

Înainte de reîncărcare, verifici sintaxa cu nginx -t, apoi systemctl reload nginx, care aplică noua configurație fără să întrerupă conexiunile existente. Pentru mai multe instanțe ale aplicației, definești un bloc upstream cu mai multe servere, iar nginx distribuie cererile între ele.

Ce urmărește intervievatorul: Se verifică experiența practică cu nginx. Antetele X-Forwarded-* și nginx -t sunt detaliile pe care le caută intervievatorul.

22 Mid

Aplicația nu se poate conecta la baza de date. Cum depanezi problema de rețea?

Răspuns scurt: Merg de jos în sus: rezolvă numele DNS? Ajung la IP și port? Blochează ceva pe drum (security group, firewall, rute)? Ascultă serverul pe interfața corectă? Abia apoi verific autentificarea și configurația aplicației.

Mesajul exact al erorii orientează căutarea: „name not resolved” indică DNS, „connection refused” înseamnă că ai ajuns la host, dar nimic nu ascultă pe port, iar „timeout” înseamnă de obicei că pachetele sunt aruncate pe drum de un firewall sau de o rută lipsă.

Pașii, rulați de pe mașina sau din containerul aplicației, nu de pe laptop:

BASH
dig +short db.intern.exemplu.ro          # 1. DNS
nc -vz -w 3 db.intern.exemplu.ro 5432    # 2. port TCP accesibil?
ip route get 10.0.20.15                  # 3. pe ce rută iese
traceroute -T -p 5432 10.0.20.15         # 4. unde se oprește

Dacă portul nu răspunde, verifici pe rând:

  • Security group-ul bazei de date permite intrarea pe 5432 de la security group-ul sau subnetul aplicației?
  • NACL-urile subnetului permit și traficul de întoarcere pe porturile efemere?
  • Există rută între rețele (peering, transit gateway, VPN)?
  • Pe server, baza de date ascultă pe toate interfețele? La PostgreSQL contează listen_addresses și pg_hba.conf.

Dacă portul răspunde, problema e mai sus: credențiale greșite, SSL cerut de server, limita maximă de conexiuni atinsă sau un pool de conexiuni configurat greșit în aplicație.

Într-un pod Kubernetes, rulezi aceleași verificări dintr-un container temporar: kubectl run -it --rm debug --image=nicolaka/netshoot -- bash.

Ce urmărește intervievatorul: Se verifică metoda de depanare stratificată. Diferența dintre „refused” și „timeout” este exact ce vrea să audă intervievatorul.

23 Senior

Trebuie să muți un domeniu cu trafic mare pe o infrastructură nouă fără întrerupere. Cum planifici schimbarea DNS?

Răspuns scurt: Scad TTL-ul cu suficient timp înainte, pregătesc și testez noua infrastructură în paralel, comut înregistrarea, păstrez vechea infrastructură activă cel puțin cât vechiul TTL și apoi urmăresc traficul până dispare din sistemul vechi.

Riscul principal este că, după schimbarea DNS, unii clienți continuă să folosească adresa veche din cache, uneori mai mult decât TTL-ul, pentru că unele resolver-e și aplicații îl ignoră (de exemplu JVM-uri care țin rezoluția în cache). Planul trebuie să tolereze perioada în care ambele sisteme primesc trafic.

Pași:

  • Cu zile înainte: scazi TTL-ul înregistrării (de exemplu de la 86400 la 60). Trebuie să aștepți cel puțin vechiul TTL ca noua valoare să ajungă peste tot.
  • Pregătirea: noua infrastructură rulează și e testată prin acces direct, cu curl --resolve exemplu.ro:443:IP_NOU https://exemplu.ro/. Certificatele TLS sunt emise și pentru noul mediu.
  • Datele: dacă există stare (bază de date, fișiere încărcate), stabilești replicarea sau o fereastră de scriere doar într-un singur loc. Două sisteme care acceptă scrieri independent produc date divergente.
  • Comutarea: schimbi înregistrarea, eventual treptat cu ponderi (weighted routing în Route 53: 10%, 50%, 100%).
  • Observarea: compari rata de erori și latența pe ambele părți. Vechiul sistem rămâne funcțional, eventual ca proxy spre cel nou, până când traficul spre el scade la zero.
  • Rollback: cât timp TTL-ul e mic, revenirea durează minute.
  • Final: readuci TTL-ul la o valoare normală și oprești infrastructura veche.

Ce urmărește intervievatorul: La senior se verifică gândirea despre riscuri și rollback. Candidații slabi uită de date și de clienții care ignoră TTL-ul.

Automatizare cu Python și Go

24 Junior

Când ai folosi un script bash și când ai trece la Python pentru automatizare?

Răspuns scurt: Bash e potrivit pentru scripturi scurte care leagă comenzi existente. Python e mai bun când apare logică (structuri de date, tratarea erorilor, JSON, apeluri API) sau când scriptul crește și trebuie testat și întreținut.

Bash este peste tot și e excelent pentru „lipit” comenzi: pornește un serviciu, copiază fișiere, rulează un pas din pipeline. Problemele apar când scriptul crește: tratarea erorilor e fragilă, lucrul cu liste și dicționare e incomod, iar spațiile din nume de fișiere și ghilimelele produc bug-uri subtile.

Semnale că e momentul pentru Python:

  • parsezi JSON sau YAML (în bash ai nevoie de jq, care e bun, dar limitat la transformări);
  • apelezi API-uri cu autentificare, paginare și reîncercări;
  • scriptul depășește câteva zeci de linii sau are funcții care se apelează între ele;
  • ai nevoie de teste unitare;
  • rulează pe mai multe sisteme de operare.
PYTHON
import json, subprocess

out = subprocess.run(["kubectl", "get", "pods", "-o", "json"],
                     capture_output=True, text=True, check=True)
pods = json.loads(out.stdout)["items"]
for p in pods:
    if p["status"]["phase"] != "Running":
        print(p["metadata"]["name"], p["status"]["phase"])

Python are și biblioteci consacrate pentru infrastructură: boto3 pentru AWS, clientul oficial pentru Kubernetes, requests, paramiko pentru SSH. Go devine alegerea când ai nevoie de un binar distribuit fără dependențe, de exemplu un CLI intern folosit de mai multe echipe.

Răspunsul matur nu este „Python e mereu mai bun”, ci alegerea uneltei după mărimea și durata de viață a problemei.

Ce urmărește intervievatorul: Se verifică judecata, nu preferința personală. Intervievatorul caută criterii concrete de alegere.

25 Junior

Scrie un script Python care verifică o listă de URL-uri și raportează care nu răspund cu status 200.

Răspuns scurt: Iterezi prin URL-uri, faci o cerere cu timeout pentru fiecare, prinzi erorile de rețea și HTTP separat, apoi afișezi problemele și ieși cu cod diferit de 0 dacă există vreuna, ca scriptul să poată fi folosit în cron sau CI.

O variantă care folosește doar biblioteca standard, deci rulează fără instalări:

PYTHON
import sys
import urllib.request
import urllib.error

URLS = [
    "https://exemplu.ro/",
    "https://exemplu.ro/health",
    "https://api.exemplu.ro/v1/status",
]

def verifica(url, timeout=5):
    try:
        with urllib.request.urlopen(url, timeout=timeout) as r:
            return r.status, None
    except urllib.error.HTTPError as e:
        return e.code, None
    except (urllib.error.URLError, TimeoutError) as e:
        return None, str(e)

def main():
    probleme = []
    for url in URLS:
        status, eroare = verifica(url)
        if status != 200:
            probleme.append((url, status, eroare))
    for url, status, eroare in probleme:
        print(f"FAIL {url} status={status} eroare={eroare}")
    return 1 if probleme else 0

if __name__ == "__main__":
    sys.exit(main())

Puncte pe care intervievatorul le urmărește: timeout explicit (fără el, o cerere poate aștepta foarte mult), tratarea separată a erorilor HTTP (serverul a răspuns, dar cu 500) și a erorilor de rețea (DNS, conexiune refuzată), plus codul de ieșire. Un script de verificare care întoarce mereu 0 nu poate opri un pipeline.

Extensii naturale: citirea listei dintr-un fișier, verificări în paralel cu concurrent.futures.ThreadPoolExecutor sau trimiterea rezultatului într-un canal de alertare.

Ce urmărește intervievatorul: Se verifică dacă scrii cod robust: timeout, erori, cod de ieșire. Lipsa timeout-ului este greșeala cea mai des întâlnită.

26 Junior

De ce folosești un mediu virtual (virtualenv) în Python și cum fixezi versiunile dependențelor?

Răspuns scurt: Un mediu virtual izolează pachetele unui proiect de cele ale sistemului și ale altor proiecte. Versiunile le fixezi într-un fișier precum requirements.txt cu versiuni exacte sau într-un lock file, ca instalarea să fie reproductibilă.

Fără mediu virtual, pip install scrie în Python-ul global. Două proiecte care cer versiuni diferite ale aceleiași biblioteci intră în conflict, iar pe unele distribuții poți strica unelte ale sistemului care depind de Python. De altfel, distribuțiile recente (Debian 12, Ubuntu 23.04 și mai noi) blochează implicit pip install global, conform PEP 668.

BASH
python3 -m venv .venv
source .venv/bin/activate
pip install requests boto3
pip freeze > requirements.txt
# pe altă mașină sau în CI
pip install -r requirements.txt

Fixarea versiunilor (requests==2.32.3, nu doar requests) contează pentru reproductibilitate: build-ul de azi și cel de peste o lună trebuie să instaleze același lucru. Altfel, o versiune nouă a unei dependențe poate strica pipeline-ul fără ca tu să fi schimbat ceva. pip freeze include și dependențele indirecte, ceea ce e bine pentru reproductibilitate, dar face fișierul greu de întreținut manual.

Unelte mai noi separă dependențele directe de lock file: pip-tools (cu requirements.in și pip-compile), Poetry sau uv, care generează un fișier de blocare cu versiuni exacte și hash-uri.

În Docker, mediul virtual e opțional, pentru că imaginea însăși oferă izolarea, dar fixarea versiunilor rămâne obligatorie. Directorul .venv nu se pune în Git, ci în .gitignore.

Ce urmărește intervievatorul: Se verifică bunele practici de bază în Python. Intervievatorul apreciază legătura cu reproductibilitatea în CI.

27 Mid

Scrie un script Python cu boto3 care listează toate instanțele EC2 oprite dintr-o regiune. La ce trebuie să fii atent?

Răspuns scurt: Folosești un paginator pe describe_instances cu filtru pe instance-state-name=stopped. Trebuie să ai grijă la paginare, la regiune, la credențiale (rol IAM, nu chei în cod) și la permisiunile minime necesare.

PYTHON
import boto3

def instante_oprite(regiune):
    ec2 = boto3.client("ec2", region_name=regiune)
    paginator = ec2.get_paginator("describe_instances")
    pagini = paginator.paginate(
        Filters=[{"Name": "instance-state-name", "Values": ["stopped"]}]
    )
    for pagina in pagini:
        for rezervare in pagina["Reservations"]:
            for inst in rezervare["Instances"]:
                tags = {t["Key"]: t["Value"] for t in inst.get("Tags", [])}
                yield inst["InstanceId"], inst["InstanceType"], tags.get("Name", "-")

if __name__ == "__main__":
    for iid, tip, nume in instante_oprite("eu-central-1"):
        print(iid, tip, nume)

Atenție la câteva lucruri:

  • Paginarea: API-urile AWS întorc rezultatele pe pagini. Un singur apel describe_instances poate rata instanțe în conturi mari. Paginatorul gestionează automat NextToken.
  • Structura răspunsului: instanțele sunt grupate în Reservations, o capcană frecventă.
  • Credențialele: boto3 le caută într-o ordine standard (variabile de mediu, fișierul ~/.aws/credentials, rolul instanței sau al pod-ului). Nu pui chei în cod.
  • Permisiuni: scriptul are nevoie doar de ec2:DescribeInstances.
  • Regiunile: EC2 este un serviciu regional. Pentru toate regiunile, le obții cu describe_regions și iterezi.
  • Filtrarea pe server: Filters reduce volumul transferat, față de filtrarea în Python.

Instanțele oprite nu plătesc compute, dar volumele EBS atașate și IP-urile Elastic se plătesc în continuare, de aceea un astfel de raport e util la controlul costurilor.

Ce urmărește intervievatorul: Se verifică experiența reală cu SDK-urile cloud. Paginarea și Reservations sunt detaliile care arată că ai rulat efectiv cod.

28 Mid

De ce este Go atât de folosit în zona DevOps și cloud native?

Răspuns scurt: Go produce binare statice, ușor de distribuit și de pus în imagini mici, se compilează rapid pentru orice platformă, are concurență simplă cu goroutine și o bibliotecă standard bună pentru rețea. Docker, Kubernetes, Terraform și Prometheus sunt scrise în Go.

Câteva motive tehnice:

  • Binare statice: cu CGO_ENABLED=0, un program Go se compilează într-un singur fișier fără dependențe de biblioteci de sistem. Îl copiezi pe server sau într-o imagine scratch sau distroless și rulează.
  • Cross-compilare simplă: același cod se compilează pentru Linux, macOS, Windows, x86 și ARM doar schimbând două variabile.
  • Concurență: goroutine-urile sunt fire de execuție ușoare gestionate de runtime, iar canalele (channels) simplifică comunicarea dintre ele. Ideal pentru unelte care fac multe apeluri de rețea în paralel.
  • Biblioteca standard: net/http, encoding/json, crypto/tls, context acoperă mare parte din nevoile unui serviciu sau ale unui CLI.
  • Ecosistemul: Docker, Kubernetes, Terraform, Prometheus, etcd, Consul, Helm sunt scrise în Go. Dacă vrei să scrii un operator Kubernetes, un provider Terraform sau să citești sursa unei unelte când te blochezi, Go e limbajul acelor proiecte.
BASH
GOOS=linux GOARCH=arm64 CGO_ENABLED=0 go build -o bin/agent ./cmd/agent
file bin/agent    # ELF 64-bit ARM aarch64, statically linked

Compromisuri: Go e mai verbos decât Python pentru scripturi rapide, iar tratarea explicită a erorilor (if err != nil) lungește codul. Pentru o automatizare de 30 de linii rulată o dată, Python rămâne mai rapid de scris. Pentru o unealtă distribuită multor oameni sau un agent care rulează pe fiecare server, Go e o alegere solidă.

Ce urmărește intervievatorul: Se verifică dacă înțelegi motivele, nu doar că „e la modă”. Menționarea binarelor statice și a ecosistemului este esențială.

29 Mid

Scrie în Go un program care verifică în paralel mai multe endpoint-uri de health check, cu timeout.

Răspuns scurt: Pornești câte o goroutine pentru fiecare URL, folosești un http.Client cu Timeout, aștepți terminarea cu sync.WaitGroup și colectezi rezultatele printr-un canal sau într-o structură protejată.

GO
package main

import (
	"fmt"
	"net/http"
	"os"
	"sync"
	"time"
)

type rezultat struct {
	url    string
	status int
	err    error
}

func main() {
	urls := []string{
		"https://exemplu.ro/health",
		"https://api.exemplu.ro/health",
	}
	client := &http.Client{Timeout: 5 * time.Second}
	rez := make(chan rezultat, len(urls))
	var wg sync.WaitGroup

	for _, u := range urls {
		wg.Add(1)
		go func(u string) {
			defer wg.Done()
			resp, err := client.Get(u)
			if err != nil {
				rez <- rezultat{url: u, err: err}
				return
			}
			resp.Body.Close()
			rez <- rezultat{url: u, status: resp.StatusCode}
		}(u)
	}
	wg.Wait()
	close(rez)

	esec := false
	for r := range rez {
		if r.err != nil || r.status != http.StatusOK {
			esec = true
			fmt.Printf("FAIL %s status=%d err=%v\n", r.url, r.status, r.err)
		} else {
			fmt.Printf("OK   %s\n", r.url)
		}
	}
	if esec {
		os.Exit(1)
	}
}

Detalii care contează: clientul implicit http.Get nu are timeout, deci o cerere poate atârna. Corpul răspunsului trebuie închis, altfel conexiunile nu se refolosesc. Canalul are buffer egal cu numărul de URL-uri, ca goroutine-urile să nu se blocheze. Variabila de buclă e trimisă ca parametru, necesar înainte de Go 1.22, care a schimbat semantica variabilelor din for. Pentru sute de URL-uri ai limita concurența cu un semafor.

Ce urmărește intervievatorul: Se verifică stăpânirea concurenței de bază în Go. Lipsa timeout-ului și uitarea lui Body.Close() sunt greșelile tipice.

30 Senior

Cum proiectezi o unealtă internă de automatizare care modifică infrastructura de producție astfel încât să fie sigură de folosit?

Răspuns scurt: O fac idempotentă, cu mod de simulare (dry-run) implicit, cu confirmare și limitare a numărului de resurse afectate, cu reîncercări cu backoff pentru erori temporare, cu loguri de audit și cu permisiuni minime.

O unealtă care șterge snapshot-uri vechi sau rotește chei poate produce un incident mai mare decât problema rezolvată. Principiile pe care le aplic:

  • Idempotență: rularea de două ori produce același rezultat ca rularea o dată. Unealta compară starea dorită cu cea existentă și acționează doar pe diferență, ca să poată fi reluată după o întrerupere.
  • Dry-run implicit: fără --apply, afișează doar ce ar face. Echivalentul lui terraform plan.
  • Limite de siguranță: dacă ar afecta mai mult de N resurse sau un procent mare dintr-un grup, se oprește și cere confirmare explicită. Multe incidente au pornit de la un filtru greșit care a selectat tot.
  • Reîncercări cu backoff exponențial și jitter doar pentru erorile temporare (throttling, timeout), nu pentru erorile de validare.
  • Audit: cine a rulat, când, cu ce argumente, ce s-a schimbat. Logurile merg într-un loc central.
  • Permisiuni minime: rolul uneltei poate face doar operațiile necesare, eventual doar pe resurse cu un anumit tag.
  • Rulare treptată: întâi pe staging, apoi pe un subset din producție.
PYTHON
import random, time

def cu_reincercari(fn, incercari=5, baza=0.5):
    for i in range(incercari):
        try:
            return fn()
        except TimeoutError:
            if i == incercari - 1:
                raise
            time.sleep(baza * 2 ** i + random.uniform(0, baza))

Jitter-ul (întârzierea aleatoare) contează când rulează multe instanțe simultan: fără el, toate reîncearcă exact în același moment și reproduc vârful de trafic.

Ce urmărește intervievatorul: La senior se verifică gândirea despre impact și eșec. Intervievatorul caută idempotență, dry-run și limitarea razei de impact.

Docker și containere

31 Junior

Care e diferența dintre un container și o mașină virtuală?

Răspuns scurt: O mașină virtuală emulează hardware și rulează propriul kernel. Un container este un proces izolat care folosește kernel-ul gazdei, prin namespaces și cgroups, deci pornește în secunde și ocupă mult mai puține resurse.

O mașină virtuală rulează peste un hypervisor (KVM, Xen, VMware, Hyper-V) și are propriul sistem de operare complet, cu kernel propriu. Izolarea este puternică, la nivel hardware virtualizat, dar fiecare mașină ocupă memorie pentru propriul kernel și pornește în zeci de secunde sau minute.

Un container este un proces obișnuit al gazdei, izolat cu mecanisme ale kernel-ului Linux:

  • namespaces: procesul vede propriul arbore de procese (PID), propria rețea, propriul sistem de fișiere (mount), propriul hostname;
  • cgroups: limitează CPU-ul, memoria și I/O-ul pe care le poate consuma;
  • un sistem de fișiere în straturi, construit din imagine.
BASH
docker run -d --name web nginx:1.27
ps aux | grep nginx     # pe gazdă, procesul nginx apare ca orice alt proces

Consecințe practice:

  • containerele pornesc în fracțiuni de secundă sau câteva secunde și poți rula zeci pe aceeași mașină;
  • toate împart kernel-ul gazdei, deci un container Linux nu rulează nativ pe Windows sau macOS; Docker Desktop folosește o mașină virtuală Linux în spate;
  • izolarea e mai slabă decât la VM: o vulnerabilitate de kernel poate afecta toate containerele.

În cloud se folosesc de obicei împreună: containerele rulează pe mașini virtuale (noduri EC2 într-un cluster). Pentru izolare mai puternică există soluții intermediare precum gVisor sau Firecracker.

Ce urmărește intervievatorul: Este întrebarea de bază despre containere. Candidații care pot numi namespaces și cgroups arată că înțeleg mecanismul.

32 Junior

Care e diferența dintre o imagine Docker și un container? Ce sunt straturile (layers)?

Răspuns scurt: Imaginea este un șablon read-only, format din straturi, care conține sistemul de fișiere și metadatele de pornire. Containerul este o instanță în rulare a imaginii, cu un strat propriu de scriere deasupra.

O imagine e asemenea unei clase, iar containerul unui obiect: din aceeași imagine poți porni oricâte containere.

Imaginea este alcătuită din straturi. Fiecare instrucțiune din Dockerfile care modifică sistemul de fișiere (RUN, COPY, ADD) creează un strat nou, care conține doar diferențele față de stratul anterior. Straturile sunt identificate prin hash și sunt partajate: dacă zece imagini pornesc de la python:3.12-slim, stratul de bază se descarcă și se stochează o singură dată.

Când pornești un container, Docker adaugă un strat subțire de scriere. Orice modificare făcută în container (fișiere create, loguri scrise local) ajunge acolo și dispare când containerul e șters. De aceea datele persistente trebuie puse în volume.

BASH
docker image history python:3.12-slim   # straturile și dimensiunea lor
docker run -d --name a nginx:1.27
docker run -d --name b nginx:1.27       # două containere, aceeași imagine
docker diff a                           # ce s-a modificat în stratul de scriere

O consecință importantă: ștergerea unui fișier într-un strat ulterior nu micșorează imaginea, pentru că fișierul rămâne în stratul anterior. Dacă descarci o arhivă și o ștergi abia în următorul RUN, arhiva face parte din imagine. Soluția e să faci descărcarea, folosirea și ștergerea în aceeași instrucțiune RUN sau să folosești un build multi-stage.

Ce urmărește intervievatorul: Se verifică modelul mental de bază. Un plus este să explici de ce ștergerea într-un strat ulterior nu reduce dimensiunea.

33 Junior

Scrie un Dockerfile pentru o aplicație web Python și explică fiecare instrucțiune.

Răspuns scurt: Pornești de la o imagine oficială slim, setezi directorul de lucru, copiezi și instalezi întâi dependențele, apoi codul, rulezi ca utilizator fără privilegii, expui portul și definești comanda de pornire.

FROM python:3.12-slim

ENV PYTHONDONTWRITEBYTECODE=1 \
    PYTHONUNBUFFERED=1

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY . .

RUN useradd --create-home appuser
USER appuser

EXPOSE 8000
CMD ["gunicorn", "--bind", "0.0.0.0:8000", "app:app"]

Explicații:

  • FROM: imaginea de bază, cu versiune fixă. Varianta slim e mult mai mică decât imaginea completă.
  • ENV: PYTHONUNBUFFERED=1 face ca output-ul să apară imediat în docker logs, fără buffering.
  • WORKDIR: directorul de lucru; îl creează dacă nu există.
  • COPY requirements.txt separat de restul codului: dacă schimbi doar codul, stratul cu dependențele se refolosește din cache și build-ul durează secunde.
  • --no-cache-dir: nu păstrează cache-ul pip în imagine.
  • USER: aplicația nu rulează ca root, ceea ce limitează impactul unei eventuale compromiteri.
  • EXPOSE: documentează portul; nu îl publică. Publicarea se face la rulare cu -p 8000:8000.
  • CMD în forma JSON (exec form): procesul primește direct semnalele, fără un shell intermediar.
  • --bind 0.0.0.0: aplicația ascultă pe toate interfețele, altfel nu ar fi accesibilă din afara containerului.
BASH
docker build -t app:1.0.0 .
docker run --rm -p 8000:8000 app:1.0.0

Un fișier .dockerignore (cu .git, .venv, __pycache__) completează Dockerfile-ul.

Ce urmărește intervievatorul: Se verifică experiența practică cu Docker. Ordinea COPY pentru cache și rularea fără root sunt detaliile urmărite.

34 Junior

Care e diferența dintre CMD și ENTRYPOINT într-un Dockerfile?

Răspuns scurt: ENTRYPOINT definește executabilul care rulează mereu, iar CMD oferă argumentele implicite, ușor de suprascris la docker run. Dacă există doar CMD, acesta e comanda completă și se înlocuiește integral cu ce scrii după numele imaginii.

Ambele definesc ce rulează la pornirea containerului, dar se comportă diferit când utilizatorul adaugă argumente.

  • Doar CMD ["python", "app.py"]: docker run img rulează python app.py, iar docker run img bash rulează bash în locul lor.
  • ENTRYPOINT ["python", "app.py"] plus CMD ["--port", "8000"]: implicit rulează python app.py --port 8000, iar docker run img --port 9000 rulează python app.py --port 9000. Argumentele înlocuiesc doar CMD.
  • ENTRYPOINT se suprascrie doar explicit, cu docker run --entrypoint sh img.

Tipar uzual pentru imagini care se comportă ca o unealtă:

FROM alpine:3.20
RUN apk add --no-cache curl
ENTRYPOINT ["curl"]
CMD ["--help"]

docker run img -sI https://exemplu.ro rulează curl -sI https://exemplu.ro.

Alt tipar comun este un script entrypoint.sh care pregătește mediul (de exemplu așteaptă baza de date sau rulează migrații) și termină cu exec "$@", ca să lanseze comanda din CMD. exec înlocuiește procesul shell cu aplicația, care devine PID 1 și primește SIGTERM.

Forma JSON (exec form) este de preferat formei shell (CMD python app.py). Forma shell rulează sub /bin/sh -c, care nu transmite semnalele mai departe, astfel că oprirea containerului ajunge să aștepte timeout-ul și apoi SIGKILL.

Ce urmărește intervievatorul: Întrebarea apare foarte des. Detaliul despre forma exec și semnale diferențiază un răspuns bun de unul memorat.

35 Junior

Care e diferența dintre COPY și ADD și la ce folosește .dockerignore?

Răspuns scurt: COPY copiază fișiere din contextul de build în imagine. ADD face același lucru, dar dezarhivează automat arhivele tar locale și poate descărca URL-uri. Recomandarea e să folosești COPY implicit. .dockerignore exclude fișiere din contextul de build.

COPY este explicit și previzibil: ia fișiere din context și le pune în imagine. ADD are comportamente suplimentare care pot surprinde: o arhivă .tar.gz locală e despachetată automat, iar un URL e descărcat. Pentru descărcări e preferabil RUN curl cu verificarea sumei de control, iar pentru restul COPY. ADD rămâne justificat când chiar vrei dezarhivarea automată.

COPY --chown=appuser:appuser src/ /app/src/
ADD rootfs.tar.gz /

Contextul de build este directorul trimis către daemon-ul Docker la docker build .. Fără .dockerignore, trimiți tot: istoricul .git, node_modules, mediul virtual, fișierele .env cu secrete. Consecințele:

  • build-uri lente, pentru că se transferă sute de MB;
  • cache invalidat inutil: COPY . . vede orice modificare în .git ca schimbare;
  • risc de securitate: un .env sau o cheie ajunge în imagine și apoi în registry.
# .dockerignore
.git
.venv
node_modules
__pycache__
*.log
.env
Dockerfile
docker-compose*.yml

Pentru proiecte cu multe fișiere generate, unii preferă abordarea inversă: excluzi tot cu * și permiți explicit doar ce e necesar, de exemplu !src/ și !requirements.txt. E mai sigur, dar trebuie actualizat când adaugi directoare noi.

Ce urmărește intervievatorul: Se verifică atenția la detalii și la securitate. Scăparea secretelor în imagine prin lipsa .dockerignore este o greșeală reală și frecventă.

36 Junior

Cum păstrezi datele unui container după ce acesta este șters? Ce diferență este între volume și bind mounts?

Răspuns scurt: Montezi un volum sau un director al gazdei în container. Volumele sunt gestionate de Docker și sunt recomandate pentru date, iar bind mount-urile leagă un director concret al gazdei, utile mai ales în dezvoltare.

Stratul de scriere al containerului dispare la docker rm, deci o bază de date fără volum își pierde datele la recrearea containerului.

Volume: Docker le creează și le gestionează (pe Linux, sub /var/lib/docker/volumes/). Sunt independente de structura directoarelor de pe gazdă, funcționează la fel pe orice mașină și pot folosi drivere pentru stocare externă.

BASH
docker volume create pgdata
docker run -d --name db -e POSTGRES_PASSWORD=dev \
  -v pgdata:/var/lib/postgresql/data postgres:16
docker rm -f db
docker run -d --name db -e POSTGRES_PASSWORD=dev \
  -v pgdata:/var/lib/postgresql/data postgres:16   # datele sunt încă acolo

Bind mounts: montezi un director anume de pe gazdă. Sunt ideale în dezvoltare, pentru că modificările din editor apar imediat în container.

BASH
docker run --rm -v "$(pwd)/src:/app/src" -p 8000:8000 app:dev

Dezavantaje ale bind mount-urilor: depind de căile gazdei, apar probleme de permisiuni (UID-ul din container trebuie să poată scrie în director) și pot expune accidental fișiere sensibile ale gazdei.

Există și tmpfs, o montare în memorie, pentru date temporare care nu trebuie scrise pe disc.

Atenție: docker compose down -v și docker volume prune șterg volumele. Un volum nu înlocuiește un backup, pentru că nu protejează împotriva ștergerilor accidentale sau a coruperii datelor.

Ce urmărește intervievatorul: Se verifică înțelegerea persistenței. Intervievatorul apreciază când menționezi că volumul nu este backup.

37 Junior

Cum comunică două containere între ele și ce face -p 8080:80?

Răspuns scurt: Containerele dintr-o rețea Docker definită de utilizator se găsesc după nume prin DNS-ul intern Docker. -p 8080:80 publică portul 80 din container pe portul 8080 al gazdei, ca să fie accesibil din exterior.

Docker creează implicit rețeaua bridge. Pe ea containerele au IP-uri private, dar nu se pot găsi după nume. Într-o rețea creată de tine, Docker oferă un server DNS intern și fiecare container e accesibil după numele lui:

BASH
docker network create app-net
docker run -d --name db --network app-net -e POSTGRES_PASSWORD=dev postgres:16
docker run -d --name api --network app-net \
  -e DATABASE_URL=postgresql://postgres:dev@db:5432/postgres \
  -p 8080:8000 api:1.0.0

Aici api se conectează la db:5432. Portul bazei de date nu este publicat pe gazdă, deci nu e accesibil din afara rețelei Docker, ceea ce este exact ce îți dorești.

-p 8080:8000 înseamnă gazdă:container. Docker configurează reguli de NAT (prin iptables sau nftables), astfel încât traficul spre portul 8080 al gazdei ajunge la portul 8000 din container. Implicit portul se deschide pe toate interfețele gazdei; -p 127.0.0.1:8080:8000 îl limitează la acces local.

Capcane frecvente:

  • în container, localhost înseamnă containerul însuși, nu gazda și nici alt container;
  • regulile de NAT ale Docker pot ocoli un firewall precum ufw, deci un port publicat poate fi accesibil din internet chiar dacă ai crezut că l-ai blocat;
  • --network host elimină izolarea de rețea: containerul folosește direct interfețele gazdei.

Docker Compose creează automat o rețea pentru fiecare proiect, de aceea serviciile se găsesc acolo după numele din fișier.

Ce urmărește intervievatorul: Se verifică modelul de rețea Docker. Capcana cu localhost în container și cea cu firewall-ul ocolit sunt exact ce caută intervievatorul.

38 Mid

Ce este un build multi-stage și cum micșorezi o imagine Docker?

Răspuns scurt: Un build multi-stage folosește o etapă cu toate uneltele de compilare și copiază în imaginea finală doar artefactul rezultat. Imaginea finală nu conține compilatorul, sursele sau cache-urile, deci e mai mică și are mai puține vulnerabilități.

Exemplu pentru o aplicație Go:

FROM golang:1.23 AS build
WORKDIR /src
COPY go.mod go.sum ./
RUN go mod download
COPY . .
RUN CGO_ENABLED=0 go build -ldflags="-s -w" -o /out/api ./cmd/api

FROM gcr.io/distroless/static-debian12:nonroot
COPY --from=build /out/api /api
USER nonroot
ENTRYPOINT ["/api"]

Imaginea golang are câteva sute de MB, dar imaginea finală conține doar binarul și un minim de fișiere (certificate CA, date de fus orar, utilizatorul nonroot), ajungând de obicei la câțiva MB sau zeci de MB.

Alte tehnici pentru imagini mici:

  • imagini de bază slim, alpine sau distroless. Alpine folosește musl în loc de glibc, ceea ce poate crea probleme cu unele pachete Python sau binare precompilate;
  • comenzi combinate într-un singur RUN, cu curățarea cache-ului în același strat: apt-get install -y --no-install-recommends ... && rm -rf /var/lib/apt/lists/*;
  • .dockerignore strict;
  • doar dependențele de producție (npm ci --omit=dev, fără pachetele de test).

De ce contează: imaginile mici se descarcă mai repede pe noduri, deci scalarea și recuperarea sunt mai rapide, iar o suprafață mai mică înseamnă mai puține pachete vulnerabile. Imaginile distroless nu au shell, ceea ce complică depanarea; în Kubernetes compensezi cu kubectl debug și containere efemere.

Ce urmărește intervievatorul: Se verifică optimizarea imaginilor în practică. Candidații buni menționează și compromisul de depanare la distroless.

39 Mid

Cum funcționează cache-ul de build în Docker și cum ordonezi instrucțiunile ca build-ul să fie rapid?

Răspuns scurt: Fiecare instrucțiune produce un strat refolosit dacă instrucțiunea și fișierele de intrare nu s-au schimbat. Odată ce un strat e invalidat, toate cele de după se reconstruiesc, deci pui lucrurile care se schimbă rar la început și codul la final.

Docker verifică pentru fiecare instrucțiune dacă are deja un strat identic. Pentru RUN compară textul comenzii; pentru COPY și ADD compară și conținutul fișierelor copiate. La prima diferență, cache-ul se rupe și toate instrucțiunile următoare rulează din nou.

Ordine greșită:

COPY . .
RUN npm ci

Orice modificare într-un fișier sursă invalidează COPY . ., deci npm ci reinstalează toate dependențele la fiecare build.

Ordine corectă:

COPY package.json package-lock.json ./
RUN npm ci
COPY . .
RUN npm run build

Acum dependențele se reinstalează doar când se schimbă fișierele de dependențe.

Capcane:

  • RUN apt-get update singur într-un strat rămâne în cache la nesfârșit cu liste vechi de pachete; se combină cu apt-get install în același RUN;
  • comenzile care descarcă „ultima versiune” nu sunt reevaluate cât timp textul lor nu se schimbă;
  • în CI, fiecare job pornește adesea pe o mașină curată, fără cache local.

Cu BuildKit (implicit în versiunile actuale de Docker) ai și cache mounts, care păstrează cache-ul managerului de pachete între build-uri fără să-l pună în imagine, plus cache exportat în registry pentru CI:

RUN --mount=type=cache,target=/root/.cache/pip pip install -r requirements.txt
BASH
docker buildx build --cache-from type=registry,ref=reg/app:cache \
  --cache-to type=registry,ref=reg/app:cache,mode=max -t reg/app:1.4.0 --push .

Ce urmărește intervievatorul: Se verifică dacă știi să faci pipeline-urile rapide. Problema cache-ului lipsă în CI este un detaliu de experiență reală.

40 Mid

Scrie un fișier Docker Compose pentru o aplicație cu o bază de date PostgreSQL. Cum te asiguri că aplicația pornește după ce baza de date e gata?

Răspuns scurt: Definești două servicii, un volum pentru date și folosești depends_on cu condition: service_healthy plus un healthcheck pe baza de date. Simpla ordine de pornire nu garantează că PostgreSQL acceptă deja conexiuni.

YAML
services:
  db:
    image: postgres:16
    environment:
      POSTGRES_USER: app
      POSTGRES_PASSWORD: ${DB_PASSWORD}
      POSTGRES_DB: app
    volumes:
      - pgdata:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U app -d app"]
      interval: 5s
      timeout: 3s
      retries: 10

  api:
    build: .
    environment:
      DATABASE_URL: postgresql://app:${DB_PASSWORD}@db:5432/app
    ports:
      - "8000:8000"
    depends_on:
      db:
        condition: service_healthy
    restart: unless-stopped

volumes:
  pgdata:

depends_on simplu garantează doar ordinea de pornire a containerelor. PostgreSQL are nevoie de câteva secunde ca să inițializeze, iar aplicația pornită imediat ar eșua la conectare. Cu condition: service_healthy, Compose așteaptă ca healthcheck-ul să treacă.

Variabila ${DB_PASSWORD} se citește din mediu sau dintr-un fișier .env aflat lângă docker-compose.yml, care nu se pune în Git.

Chiar și așa, aplicația trebuie să reîncerce conectarea: în producție baza de date poate deveni indisponibilă temporar oricând, iar o aplicație care moare la prima eroare de conexiune e fragilă.

Compose este potrivit pentru dezvoltare locală, teste de integrare în CI și aplicații mici pe un singur server. Pentru mai multe noduri, autoscalare și deploy fără întrerupere se folosește un orchestrator precum Kubernetes sau ECS. Comenzile uzuale sunt docker compose up -d, logs -f api și down.

Ce urmărește intervievatorul: Se verifică experiența practică și înțelegerea diferenței dintre „pornit” și „gata”. Răspunsul complet menționează și reîncercarea din aplicație.

41 Senior

Ce practici aplici pentru securitatea imaginilor și a containerelor în producție?

Răspuns scurt: Imagini de bază minime și fixate, rulare fără root, scanarea vulnerabilităților în CI, fără secrete în imagini, sistem de fișiere read-only, capabilități Linux reduse, imagini semnate și limite de resurse.

Securitatea containerelor se tratează pe trei niveluri: ce intră în imagine, cum rulează containerul și cum ajunge imaginea în producție.

Imaginea:

  • imagini de bază minime (distroless, slim) dintr-o sursă de încredere, fixate prin versiune sau chiar prin digest (python:3.12-slim@sha256:...), ca build-ul să nu se schimbe pe ascuns;
  • scanare în CI cu Trivy, Grype sau scanerul registry-ului, cu blocarea build-ului la vulnerabilități critice care au remediere disponibilă;
  • reconstruire periodică, nu doar la schimbări de cod, ca să preia patch-urile de securitate;
  • niciun secret în imagine: nici în ENV, nici în fișiere șterse ulterior (rămân în straturi). La build folosești RUN --mount=type=secret.

Rularea:

YAML
securityContext:
  runAsNonRoot: true
  runAsUser: 10001
  readOnlyRootFilesystem: true
  allowPrivilegeEscalation: false
  capabilities:
    drop: ["ALL"]
  • fără --privileged și fără montarea socket-ului Docker în containere, care echivalează cu acces root pe gazdă;
  • limite de CPU și memorie, ca un container compromis sau defect să nu afecteze vecinii;
  • politici de rețea care permit doar traficul necesar.

Lanțul de livrare: imaginile se semnează (de exemplu cu cosign din proiectul Sigstore) și se generează un SBOM (lista componentelor), iar clusterul acceptă doar imagini semnate din registry-ul propriu, aplicat printr-un admission controller precum Kyverno sau OPA Gatekeeper.

Regula de fond este defense in depth: niciun strat nu e perfect, dar împreună reduc mult raza de impact a unei compromiteri.

Ce urmărește intervievatorul: La senior se verifică o viziune completă, nu o listă de sfaturi izolate. Montarea socket-ului Docker și secretele din straturi sunt capcanele clasice.

Kubernetes

42 Junior

Ce este Kubernetes și ce problemă rezolvă?

Răspuns scurt: Kubernetes este un orchestrator de containere: rulează aplicații containerizate pe un cluster de mașini și menține automat starea dorită, cu replicare, repornire la eșec, distribuire pe noduri, descoperire de servicii și actualizări treptate.

Pe un singur server, Docker sau Docker Compose sunt suficiente. Când ai zeci de servicii pe zeci de mașini apar întrebări noi: pe ce mașină rulează fiecare container, ce se întâmplă când pică un nod, cum scalezi la trafic mare, cum faci deploy fără întrerupere, cum se găsesc serviciile între ele.

Kubernetes răspunde prin modelul declarativ: descrii starea dorită într-un manifest YAML (de exemplu „vreau 3 replici ale imaginii api:1.4.0, fiecare cu 256 MiB memorie”), iar controllerele din cluster compară continuu starea dorită cu cea reală și acționează ca să le aducă la egalitate. Dacă un pod moare, apare altul; dacă un nod dispare, pod-urile lui sunt recreate pe alte noduri.

BASH
kubectl apply -f deployment.yaml
kubectl get pods -o wide
kubectl scale deployment api --replicas=5

Ce oferă, pe scurt:

  • planificarea pod-urilor pe noduri în funcție de resursele cerute;
  • auto-vindecare (self-healing) și health checks;
  • servicii cu IP stabil și DNS intern;
  • rolling updates și rollback;
  • configurație și secrete separate de imagine;
  • autoscalare.

Costul este complexitatea: Kubernetes are o curbă de învățare abruptă și cere efort de operare. De aceea multe echipe folosesc servicii gestionate (EKS, GKE, AKS) sau, pentru aplicații mici, alternative mai simple precum ECS, Cloud Run sau o mașină virtuală cu Compose. A recunoaște când nu e nevoie de Kubernetes este și asta un semn de maturitate.

Ce urmărește intervievatorul: Se verifică dacă înțelegi modelul declarativ și reconcilierea. Intervievatorul apreciază și conștientizarea costului de complexitate.

43 Junior

Care e diferența dintre un Pod, un ReplicaSet și un Deployment?

Răspuns scurt: Pod-ul este cea mai mică unitate rulabilă: unul sau mai multe containere care împart rețeaua și volumele. ReplicaSet-ul menține un număr de pod-uri identice, iar Deployment-ul gestionează ReplicaSet-uri ca să ofere actualizări treptate și rollback.

Pod: grup de unul sau mai multe containere care rulează împreună pe același nod, împart același IP și pot partaja volume. De obicei un pod are un singur container de aplicație, eventual cu containere ajutătoare (sidecar, de exemplu un agent de loguri sau un proxy). Pod-urile sunt efemere: dacă un pod creat direct moare, nimeni nu îl recreează.

ReplicaSet: asigură că există mereu N pod-uri care se potrivesc unui selector de etichete (labels). Rar îl creezi direct.

Deployment: obiectul pe care îl folosești în practică pentru aplicații fără stare. Când schimbi imaginea, Deployment-ul creează un ReplicaSet nou și mută treptat pod-urile din cel vechi în cel nou. ReplicaSet-urile vechi rămân (cu 0 replici), ceea ce face posibil rollback-ul.

YAML
apiVersion: apps/v1
kind: Deployment
metadata:
  name: api
spec:
  replicas: 3
  selector:
    matchLabels:
      app: api
  template:
    metadata:
      labels:
        app: api
    spec:
      containers:
        - name: api
          image: registry.exemplu.ro/api:1.4.0
          ports:
            - containerPort: 8000
BASH
kubectl get deploy,rs,pods -l app=api

Eticheta din template trebuie să se potrivească cu selector, altfel API-ul respinge manifestul. Etichetele sunt mecanismul prin care obiectele Kubernetes se găsesc între ele: și Service-urile folosesc același selector ca să știe spre ce pod-uri trimit traficul.

Ce urmărește intervievatorul: Se verifică ierarhia obiectelor de bază. Candidații buni explică de ce nu creezi pod-uri direct în producție.

44 Junior

Ce tipuri de Service există în Kubernetes și când îl folosești pe fiecare?

Răspuns scurt: ClusterIP oferă un IP intern stabil, accesibil doar din cluster. NodePort deschide același port pe toate nodurile. LoadBalancer cere furnizorului de cloud un load balancer extern. ExternalName este un alias DNS către un nume din afara clusterului.

Pod-urile au IP-uri care se schimbă la fiecare recreare, deci aplicațiile nu se pot baza pe ele. Un Service oferă un IP virtual și un nume DNS stabile și distribuie traficul spre pod-urile selectate prin etichete.

YAML
apiVersion: v1
kind: Service
metadata:
  name: api
spec:
  type: ClusterIP
  selector:
    app: api
  ports:
    - port: 80
      targetPort: 8000

Tipuri:

  • ClusterIP (implicit): accesibil doar din interiorul clusterului, la api.<namespace>.svc.cluster.local sau simplu api din același namespace. Pentru comunicarea internă dintre servicii.
  • NodePort: deschide un port (implicit din intervalul 30000–32767) pe fiecare nod. Util pentru teste sau când ai un load balancer extern propriu, rar expus direct.
  • LoadBalancer: pe EKS, GKE sau AKS creează automat un load balancer de cloud cu adresă publică sau internă. Simplu, dar fiecare serviciu primește un load balancer separat, ceea ce costă.
  • ExternalName: întoarce un CNAME spre un nume extern, de exemplu o bază de date gestionată.
  • Headless (clusterIP: None): fără IP virtual, DNS-ul întoarce direct IP-urile pod-urilor; folosit la StatefulSet-uri.

Pentru expunerea mai multor aplicații HTTP sub același punct de intrare se folosește de obicei un Ingress sau Gateway API în spatele unui singur LoadBalancer.

BASH
kubectl get endpointslices -l kubernetes.io/service-name=api

Dacă lista de endpoint-uri e goală, selectorul nu se potrivește cu etichetele pod-urilor sau pod-urile nu sunt Ready.

Ce urmărește intervievatorul: Se verifică noțiunile de rețea din Kubernetes. Verificarea endpoint-urilor goale este un truc de depanare apreciat.

45 Junior

Care e diferența dintre un ConfigMap și un Secret? Este un Secret criptat?

Răspuns scurt: Ambele furnizează configurație pod-urilor ca variabile de mediu sau fișiere. ConfigMap e pentru date nesensibile, Secret pentru parole și chei. Implicit, un Secret este doar codificat base64, nu criptat; criptarea în etcd și controlul accesului trebuie configurate separat.

Separarea configurației de imagine permite aceeași imagine în dev, staging și producție, cu valori diferite.

YAML
apiVersion: v1
kind: ConfigMap
metadata:
  name: api-config
data:
  LOG_LEVEL: info
  FEATURE_X: "true"
---
apiVersion: v1
kind: Secret
metadata:
  name: api-secret
type: Opaque
stringData:
  DB_PASSWORD: schimba-ma

În pod:

YAML
envFrom:
  - configMapRef:
      name: api-config
  - secretRef:
      name: api-secret

base64 nu este criptare: oricine are drept de citire pe Secret-uri în namespace poate obține valoarea cu kubectl get secret api-secret -o jsonpath='{.data.DB_PASSWORD}' | base64 -d. Pentru protecție reală:

  • RBAC strict: doar cine are nevoie poate citi Secret-uri;
  • criptare la nivel de etcd (encryption at rest), pe care serviciile gestionate o oferă, de exemplu cu chei KMS pe EKS;
  • secretele nu se pun în Git în clar. Variante: Sealed Secrets, SOPS, sau External Secrets Operator care le sincronizează din AWS Secrets Manager ori HashiCorp Vault.

O diferență practică: variabilele de mediu se citesc doar la pornirea containerului, deci o modificare a ConfigMap-ului nu ajunge în aplicație până la repornirea pod-urilor. Fișierele montate din ConfigMap se actualizează după un timp, dar aplicația trebuie să le recitească.

Ce urmărește intervievatorul: Întrebarea verifică în special mitul „Secret = criptat”. Candidații care știu de External Secrets sau SOPS arată experiență de producție.

46 Junior

Un pod este în starea CrashLoopBackOff. Cum afli ce se întâmplă?

Răspuns scurt: Containerul pornește și se oprește repetat, iar Kubernetes așteaptă tot mai mult între reporniri. Verifici kubectl describe pod pentru evenimente și codul de ieșire, apoi kubectl logs --previous pentru logurile instanței care a căzut.

CrashLoopBackOff nu este o cauză, ci un simptom: procesul principal iese, kubelet-ul îl repornește, iar intervalul dintre reporniri crește exponențial până la cinci minute.

Pași:

BASH
kubectl get pod api-7c9d -o wide
kubectl describe pod api-7c9d        # Events, Last State, Exit Code, Reason
kubectl logs api-7c9d --previous     # logurile containerului care a murit
kubectl logs api-7c9d -c migrate     # alt container sau un init container
kubectl get events --sort-by=.lastTimestamp

Ce îți spune codul de ieșire:

  • 1 sau alt cod al aplicației: eroare la pornire (configurație lipsă, nu se poate conecta la baza de date, variabilă de mediu greșită). Logurile spun de obicei motivul.
  • 137 cu Reason: OOMKilled: containerul a depășit limita de memorie.
  • 137 fără OOM: a fost oprit cu SIGKILL, de exemplu pentru că liveness probe-ul a eșuat repetat.
  • 0: procesul s-a terminat normal, dar un Deployment se așteaptă la un proces care rulează continuu. Frecvent la imagini al căror CMD e un script care se termină.

Alte cauze: un Secret sau ConfigMap referit care nu există (de obicei apare însă ca CreateContainerConfigError), permisiuni pe fișiere, o liveness probe prea agresivă pentru o aplicație care pornește lent.

Dacă logurile sunt goale, pornești imaginea cu altă comandă ca s-o inspectezi: kubectl debug creează o copie a pod-ului sau atașează un container efemer cu unelte de depanare.

Ce urmărește intervievatorul: Este probabil cea mai frecventă întrebare practică de Kubernetes. --previous și interpretarea codului 137 sunt ce așteaptă intervievatorul.

47 Mid

Care e diferența dintre liveness, readiness și startup probes?

Răspuns scurt: Liveness verifică dacă containerul mai funcționează și îl repornește dacă nu. Readiness verifică dacă poate primi trafic și îl scoate temporar din Service dacă nu. Startup protejează aplicațiile lente la pornire, amânând celelalte verificări.

Toate trei sunt verificări rulate de kubelet periodic (HTTP, TCP, comandă sau gRPC), dar consecințele unui eșec diferă:

  • readinessProbe: dacă eșuează, pod-ul este scos din endpoint-urile Service-ului, deci nu mai primește cereri, dar nu e repornit. Folosită pentru încălzire, dependențe temporar indisponibile sau supraîncărcare.
  • livenessProbe: dacă eșuează de failureThreshold ori la rând, containerul e repornit. Folosită pentru situații din care aplicația nu își revine singură, de exemplu un deadlock.
  • startupProbe: până trece, celelalte două sunt dezactivate. Permite o pornire lungă fără o liveness permisivă pentru tot restul vieții containerului.
YAML
startupProbe:
  httpGet: {path: /healthz, port: 8000}
  periodSeconds: 5
  failureThreshold: 30     # până la 150 de secunde pentru pornire
readinessProbe:
  httpGet: {path: /ready, port: 8000}
  periodSeconds: 5
livenessProbe:
  httpGet: {path: /healthz, port: 8000}
  periodSeconds: 10
  failureThreshold: 3

Greșeli frecvente:

  • liveness probe care verifică baza de date: când baza de date are o problemă, toate pod-urile sunt repornite simultan, ceea ce agravează incidentul. Dependențele se verifică, cel mult, în readiness;
  • liveness fără startup probe pentru o aplicație Java care pornește în 60 de secunde, rezultând o buclă de reporniri;
  • același endpoint pentru ambele verificări, deci se pierde diferența de semnificație;
  • lipsa readiness probe, astfel încât pod-ul primește trafic înainte să fie gata, apărând erori la fiecare deploy.

Ce urmărește intervievatorul: Se verifică înțelegerea consecințelor fiecărei verificări. Greșeala cu liveness dependentă de baza de date este exact ce caută intervievatorul.

48 Mid

Ce sunt requests și limits pentru resurse și ce se întâmplă când un container le depășește?

Răspuns scurt: requests este rezerva pe baza căreia scheduler-ul alege nodul. limits este plafonul impus la rulare. Peste limita de CPU, containerul este încetinit (throttled); peste limita de memorie, este oprit cu OOMKilled.

YAML
resources:
  requests:
    cpu: 250m        # un sfert de nucleu
    memory: 256Mi
  limits:
    memory: 512Mi

Requests influențează planificarea: scheduler-ul pune pod-ul doar pe un nod care mai are suficientă capacitate necerută de alte pod-uri. Nu contează consumul real, ci suma cererilor. De aceea cereri prea mari risipesc noduri, iar cereri prea mici înghesuie prea multe pod-uri pe un nod.

Limits sunt aplicate prin cgroups:

  • CPU este o resursă compresibilă: un container care vrea mai mult decât limita este limitat (throttling). Aplicația nu moare, dar latența crește. Multe echipe aleg să nu seteze limită de CPU, doar requests, ca să permită folosirea capacității libere a nodului.
  • Memoria nu este compresibilă: la depășire, kernel-ul oprește procesul și pod-ul apare cu OOMKilled, cod 137.

Clasele de calitate a serviciului (QoS) rezultă din aceste valori:

  • Guaranteed: requests egale cu limits pentru CPU și memorie la toate containerele;
  • Burstable: există requests, dar diferite de limits;
  • BestEffort: nimic setat; primele pod-uri evacuate când nodul rămâne fără memorie.

Pentru aplicații JVM sau Node.js, setările interne trebuie aliniate cu limita: Java modern respectă limitele containerului și permite -XX:MaxRAMPercentage, iar în Node.js se ajustează --max-old-space-size. Valorile corecte vin din măsurarea consumului real în monitorizare, nu din estimări.

Ce urmărește intervievatorul: Se verifică înțelegerea unei surse frecvente de incidente. Diferența de comportament între CPU și memorie este punctul central.

49 Mid

Ce este un Ingress și de ce ai nevoie de un ingress controller?

Răspuns scurt: Un Ingress este un obiect care descrie reguli de rutare HTTP (după domeniu și cale) spre Service-uri. Singur nu face nimic: un ingress controller, precum ingress-nginx, Traefik sau AWS Load Balancer Controller, citește regulile și configurează efectiv proxy-ul sau load balancer-ul.

Fără Ingress, fiecare aplicație expusă ar avea nevoie de propriul Service de tip LoadBalancer, adică un load balancer de cloud separat, cu cost și certificat propriu. Un Ingress permite un singur punct de intrare pentru multe aplicații.

YAML
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: web
spec:
  ingressClassName: nginx
  tls:
    - hosts: [app.exemplu.ro]
      secretName: app-tls
  rules:
    - host: app.exemplu.ro
      http:
        paths:
          - path: /api
            pathType: Prefix
            backend:
              service: {name: api, port: {number: 80}}
          - path: /
            pathType: Prefix
            backend:
              service: {name: frontend, port: {number: 80}}

Obiectul Ingress este doar o specificație. Ingress controller-ul rulează în cluster, urmărește aceste obiecte și se reconfigurează automat. Variante uzuale:

  • ingress-nginx sau Traefik: un proxy în cluster, expus printr-un singur Service LoadBalancer;
  • AWS Load Balancer Controller: creează și configurează un Application Load Balancer pentru Ingress-uri.

Certificatele TLS se gestionează de obicei cu cert-manager, care obține și reînnoiește automat certificate Let's Encrypt și le pune în Secret-ul referit.

Anotările specifice controller-ului (timeout-uri, dimensiune maximă a cererii, rescriere de căi) diferă de la unul la altul, ceea ce face migrarea dificilă. De aceea există Gateway API, succesorul mai expresiv și portabil al Ingress-ului, cu obiecte precum Gateway și HTTPRoute, ajuns la versiunea stabilă în 2023.

Ce urmărește intervievatorul: Se verifică diferența dintre obiectul declarativ și componenta care îl implementează. Menționarea Gateway API arată că ești la curent.

50 Mid

Cum funcționează un rolling update al unui Deployment și cum faci rollback?

Răspuns scurt: Deployment-ul creează pod-uri noi și le oprește pe cele vechi treptat, în limitele maxSurge și maxUnavailable, așteptând ca pod-urile noi să fie Ready. Rollback-ul îl faci cu kubectl rollout undo, care revine la ReplicaSet-ul anterior.

YAML
spec:
  replicas: 4
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1          # cel mult un pod peste numărul dorit
      maxUnavailable: 0    # niciun pod lipsă față de numărul dorit
  minReadySeconds: 10

Cu aceste valori, Kubernetes pornește un pod nou, așteaptă să treacă readiness probe-ul și să rămână Ready 10 secunde, apoi oprește unul vechi și repetă. Capacitatea nu scade niciodată sub 4 pod-uri.

BASH
kubectl set image deployment/api api=registry.exemplu.ro/api:1.5.0
kubectl rollout status deployment/api --timeout=5m
kubectl rollout history deployment/api
kubectl rollout undo deployment/api                 # la versiunea anterioară
kubectl rollout undo deployment/api --to-revision=7

Dacă pod-urile noi nu devin Ready, rollout-ul se oprește singur, iar cele vechi continuă să servească trafic. progressDeadlineSeconds marchează rollout-ul ca eșuat după un timp, iar kubectl rollout status întoarce cod de eroare, util în CI ca pipeline-ul să eșueze.

Ca update-ul să fie cu adevărat fără erori pentru utilizatori:

  • readiness probe corectă, altfel pod-urile primesc trafic prea devreme;
  • tratarea SIGTERM: aplicația termină cererile în curs. Adesea se adaugă un preStop cu o pauză scurtă, pentru că scoaterea pod-ului din endpoint-uri se propagă cu întârziere;
  • compatibilitate între versiuni: o perioadă rulează ambele simultan.

kubectl rollout undo modifică clusterul direct. Dacă folosești GitOps, rollback-ul corect este revenirea în Git, altfel următoarea sincronizare reaplică versiunea defectă.

Ce urmărește intervievatorul: Se verifică înțelegerea deploy-ului fără întrerupere. Candidații buni menționează tratarea SIGTERM și conflictul cu GitOps.

51 Mid

Când folosești un StatefulSet în loc de un Deployment și cum funcționează stocarea persistentă în Kubernetes?

Răspuns scurt: StatefulSet-ul e pentru aplicații cu stare care au nevoie de identitate stabilă: nume previzibile, ordine la pornire și câte un volum propriu pentru fiecare replică. Stocarea vine prin PersistentVolumeClaim-uri, satisfăcute de PersistentVolume-uri create de obicei dinamic printr-un StorageClass.

Pod-urile unui Deployment sunt interschimbabile: au nume aleatoare și, dacă au un volum, îl împart toate sau nu au deloc. Pentru baze de date, brokeri de mesaje sau sisteme distribuite precum Kafka, Elasticsearch ori etcd, fiecare instanță are propriile date și un rol (de exemplu primar și replici).

StatefulSet oferă:

  • nume stabile: db-0, db-1, db-2, păstrate la recreare;
  • DNS stabil pentru fiecare pod, printr-un Service headless: db-0.db.prod.svc.cluster.local;
  • pornire și oprire ordonată (implicit);
  • volumeClaimTemplates: fiecare pod primește propriul PVC, care rămâne legat de el chiar dacă pod-ul e mutat pe alt nod.
YAML
volumeClaimTemplates:
  - metadata:
      name: data
    spec:
      accessModes: ["ReadWriteOnce"]
      storageClassName: gp3
      resources:
        requests:
          storage: 50Gi

Lanțul stocării: pod-ul cere un PersistentVolumeClaim (PVC), iar StorageClass-ul, printr-un driver CSI (de exemplu EBS CSI pe AWS), creează automat un PersistentVolume (PV), adică un disc real. ReadWriteOnce înseamnă că discul se montează pe un singur nod, deci un pod nu se poate muta în altă zonă de disponibilitate decât cea a discului EBS.

La ștergerea unui StatefulSet, PVC-urile rămân intenționat, ca să nu pierzi date. În practică, multe echipe aleg servicii gestionate (RDS, ElastiCache) în locul bazelor de date în Kubernetes, pentru că backup-ul, upgrade-urile și failover-ul sunt mai simple acolo. Când rulezi totuși o bază de date în cluster, se folosește de obicei un operator dedicat.

Ce urmărește intervievatorul: Se verifică înțelegerea aplicațiilor cu stare în Kubernetes. Un răspuns matur discută și varianta serviciilor gestionate.

52 Senior

Cum funcționează autoscalarea în Kubernetes, la nivel de pod-uri și la nivel de noduri?

Răspuns scurt: Horizontal Pod Autoscaler-ul modifică numărul de replici pe baza metricilor (CPU, memorie sau metrici personalizate). Când pod-urile noi nu mai încap, Cluster Autoscaler sau Karpenter adaugă noduri, iar nodurile subutilizate sunt eliminate după mutarea pod-urilor.

Sunt două bucle care lucrează împreună.

Horizontal Pod Autoscaler (HPA) citește metrici prin metrics-server sau un adaptor de metrici personalizate și calculează aproximativ replici_dorite = ceil(replici_curente * valoare_curentă / valoare_țintă).

YAML
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: api
spec:
  scaleTargetRef: {apiVersion: apps/v1, kind: Deployment, name: api}
  minReplicas: 3
  maxReplicas: 30
  metrics:
    - type: Resource
      resource:
        name: cpu
        target: {type: Utilization, averageUtilization: 65}
  behavior:
    scaleDown:
      stabilizationWindowSeconds: 300

Utilizarea CPU se calculează raportat la requests, deci fără requests HPA nu funcționează pe CPU. Pentru workeri care procesează o coadă, metrica potrivită este lungimea cozii, nu CPU-ul; KEDA simplifică acest caz și permite chiar scalarea la zero.

Autoscalarea nodurilor: când pod-uri rămân Pending din lipsă de resurse, Cluster Autoscaler mărește un grup de noduri, iar Karpenter (pe AWS) creează direct instanțe potrivite cererii. La scădere, nodurile goale sau subutilizate sunt golite și eliminate.

Aspecte de producție:

  • timpul de reacție se adună: metrica, decizia HPA, pornirea nodului, descărcarea imaginii, pornirea aplicației. Pentru vârfuri bruște ai nevoie de rezervă, adică minReplicas mai mare sau capacitate pregătită;
  • PodDisruptionBudget împiedică eliminarea simultană a prea multor replici la consolidarea nodurilor;
  • fereastra de stabilizare previne oscilațiile;
  • maxReplicas și limitele grupurilor de noduri protejează bugetul în cazul unei bucle greșite.

Ce urmărește intervievatorul: La senior se verifică înțelegerea interacțiunii dintre cele două niveluri. Dependența HPA de requests și timpul de reacție cumulat sunt punctele cheie.

53 Senior

Descrie componentele control plane-ului Kubernetes. Ce se întâmplă de la kubectl apply până când pod-ul rulează?

Răspuns scurt: Control plane-ul are kube-apiserver, etcd, kube-scheduler și kube-controller-manager; pe fiecare nod rulează kubelet, un container runtime și kube-proxy. La apply, API server-ul validează și salvează obiectul în etcd, controllerele creează pod-urile, scheduler-ul le alege nodul, iar kubelet-ul le pornește.

Componente:

  • kube-apiserver: singura poartă de acces. Autentifică, autorizează (RBAC), rulează admission controllerele și scrie în etcd. Toate celelalte componente comunică prin el.
  • etcd: baza de date cheie-valoare, distribuită și consistentă (algoritmul Raft), unde stă toată starea clusterului. Backup-ul etcd înseamnă backup-ul clusterului.
  • kube-scheduler: alege nodul pentru pod-urile neplanificate, ținând cont de requests, taints și tolerations, afinități și constrângeri de distribuire pe zone.
  • kube-controller-manager: rulează buclele de control (Deployment, ReplicaSet, Node, Job etc.).
  • Pe noduri: kubelet (pornește și supraveghează containerele), container runtime (containerd, CRI-O) și kube-proxy sau un CNI care implementează Service-urile.

Fluxul pentru un Deployment nou:

  • kubectl apply trimite manifestul la API server; acesta autentifică, autorizează, aplică admission (valori implicite, politici) și salvează obiectul în etcd.
  • Controllerul de Deployment observă obiectul nou și creează un ReplicaSet.
  • Controllerul de ReplicaSet creează obiectele Pod, încă fără nod.
  • Scheduler-ul observă pod-urile neplanificate, alege nodurile și scrie nodeName.
  • Kubelet-ul de pe nodul ales vede pod-ul, descarcă imaginea prin runtime, creează rețeaua prin pluginul CNI, montează volumele și pornește containerele, apoi raportează starea.
  • Când readiness probe-ul trece, controllerul de EndpointSlice adaugă pod-ul la Service.

Niciun component nu dă ordine altuia direct: fiecare urmărește (watch) obiecte prin API server și reconciliază. De aceea sistemul tolerează căderi temporare ale componentelor.

Ce urmărește intervievatorul: La senior se verifică modelul de arhitectură. Intervievatorul caută ideea că totul trece prin API server și că buclele de reconciliere sunt independente.

Git și CI/CD

54 Junior

Care e diferența dintre git merge și git rebase?

Răspuns scurt: merge unește două ramuri păstrând istoricul așa cum s-a petrecut, eventual cu un commit de merge. rebase mută commit-urile tale peste vârful altei ramuri, rescriindu-le, ca să obții un istoric liniar. Nu faci rebase pe commit-uri pe care alții le folosesc deja.

Să presupunem că ai lucrat pe feature, iar între timp main a primit commit-uri noi.

BASH
git switch feature
git merge main        # creează un commit de merge care are doi părinți
# sau
git rebase main       # reaplică fiecare commit din feature peste main

Merge: nu modifică commit-urile existente, deci e sigur pe ramuri partajate. Istoricul arată exact când s-au integrat ramurile, dar poate deveni greu de citit, cu multe commit-uri de merge.

Rebase: fiecare commit al tău este recreat cu alt hash, ca și cum ai fi pornit lucrul de la vârful actual al lui main. Rezultatul este un istoric liniar, ușor de urmărit cu git log și de investigat cu git bisect. Conflictele se rezolvă commit cu commit.

Regula de aur: nu face rebase pe commit-uri deja publicate pe care alții și-au bazat munca, pentru că le rescrii istoria. Pe propria ramură de feature, înainte de pull request, rebase-ul este o practică normală; după el ai nevoie de git push --force-with-lease, care refuză suprascrierea dacă între timp altcineva a împins ceva pe ramură, spre deosebire de --force.

BASH
git rebase -i main     # interactiv: combini (squash) sau reformulezi commit-uri
git rebase --abort     # renunți dacă ceva merge prost

Multe echipe aleg la nivel de platformă (GitHub, GitLab) între „merge commit”, „squash and merge” și „rebase and merge”, pentru un istoric consecvent.

Ce urmărește intervievatorul: Se verifică înțelegerea istoricului Git. Intervievatorul caută regula despre ramurile partajate și --force-with-lease.

55 Junior

Ai împins pe main un commit greșit. Îl anulezi cu git revert sau cu git reset?

Răspuns scurt: Pe o ramură partajată folosești git revert, care creează un commit nou ce anulează modificările, fără să rescrie istoria. git reset mută ramura înapoi și rescrie istoria, potrivit doar pentru commit-uri locale, nepublicate.

Diferența ține de cine mai are deja commit-ul.

git revert adaugă un commit care face inversul modificărilor. Istoria rămâne intactă și oricine face git pull primește corecția normal.

BASH
git revert a1b2c3d            # anulează un commit
git revert -m 1 f00ba42       # anulează un commit de merge, păstrând părintele 1
git push

git reset mută pointerul ramurii la alt commit:

  • --soft: modificările rămân pregătite pentru commit (staged);
  • --mixed (implicit): modificările rămân în fișiere, dar nu sunt staged;
  • --hard: modificările se pierd din directorul de lucru.
BASH
git reset --soft HEAD~1       # refaci ultimul commit local

Dacă dai reset pe main după ce commit-ul a fost împins, ai nevoie de push --force, ceea ce strică istoricul colegilor și este de obicei blocat prin protecția ramurii.

Chiar și reset --hard se poate recupera de multe ori: git reflog arată unde a fost HEAD recent, iar git reset --hard HEAD@{2} te întoarce acolo, cât timp commit-urile nu au fost eliminate de garbage collection.

În context DevOps, un commit greșit pe main înseamnă adesea un deploy greșit. Revert-ul este calea standard de rollback în GitOps: commit-ul de revert declanșează pipeline-ul și readuce versiunea bună, cu urmă clară în istoric. Dacă commit-ul conținea un secret, revert-ul nu ajunge: secretul rămâne în istoric și trebuie revocat imediat.

Ce urmărește intervievatorul: Se verifică siguranța în lucrul cu Git în echipă. Mențiunea despre secretul care rămâne în istoric este un plus important.

56 Junior

Ce strategii de branching cunoști? Ce înseamnă trunk-based development?

Răspuns scurt: În GitFlow există ramuri lungi (develop, release, hotfix) pe lângă main. În trunk-based development toată lumea integrează des, cel puțin zilnic, în main, prin ramuri scurte, iar funcționalitățile neterminate se ascund cu feature flags.

GitFlow are main (ce e în producție), develop (integrarea curentă), ramuri feature/* care pleacă din develop, ramuri release/* pentru stabilizare și hotfix/* pentru corecții urgente. Se potrivește produselor cu lansări rare, versionate, de exemplu software instalat la clienți sau aplicații mobile. Dezavantajul principal: ramurile lungi duc la conflicte mari la integrare și întârzie feedback-ul.

GitHub Flow este mai simplu: main este mereu gata de deploy, fiecare schimbare are o ramură scurtă, un pull request cu review și teste, apoi merge și deploy.

Trunk-based development împinge ideea mai departe: ramurile trăiesc ore sau o zi sau două, integrarea în main e continuă, iar codul neterminat ajunge în producție dezactivat prin feature flags. Cerințe:

  • teste automate rapide și de încredere, rulate la fiecare pull request;
  • protecția ramurii main (review obligatoriu, CI verde);
  • pipeline care poate face deploy des și rollback rapid.
BASH
git switch -c fix/timeout-raport
# ... modificări mici
git push -u origin fix/timeout-raport   # PR, review, CI, merge în aceeași zi

Pentru DevOps alegerea contează pentru că determină forma pipeline-ului: în trunk-based, fiecare merge în main produce un artefact care poate ajunge în producție. Pentru servicii web cu deploy continuu, trunk-based sau GitHub Flow sunt variantele obișnuite; GitFlow se justifică atunci când există mai multe versiuni suportate în paralel.

Ce urmărește intervievatorul: Se verifică dacă înțelegi legătura dintre branching și livrare continuă. Candidații slabi prezintă GitFlow ca singura variantă corectă.

57 Junior

Ce înseamnă CI, continuous delivery și continuous deployment?

Răspuns scurt: CI înseamnă integrarea frecventă a codului cu build și teste automate la fiecare schimbare. Continuous delivery înseamnă că fiecare versiune care trece de pipeline e gata de producție, cu lansare la decizia unui om. Continuous deployment înseamnă că lansarea în producție se face automat.

Continuous Integration (CI): la fiecare push sau pull request, un sistem automat (GitHub Actions, GitLab CI, Jenkins etc.) descarcă codul, îl compilează, rulează linting, teste unitare și de integrare, eventual scanări de securitate. Scopul e ca erorile de integrare să apară în minute, nu la sfârșitul unui sprint.

Continuous Delivery (CD): pipeline-ul continuă după CI. Construiește artefactul (de exemplu o imagine Docker), îl publică într-un registry, îl instalează automat într-un mediu de test sau staging, rulează teste suplimentare. Fiecare versiune este pregătită pentru producție; deploy-ul în producție este un buton apăsat de un om.

Continuous Deployment: nu mai există pasul manual. Tot ce trece de verificări ajunge în producție automat. Cere teste foarte bune, monitorizare care detectează rapid regresiile, deploy-uri treptate (canary) și rollback automat.

commit -> build -> teste -> imagine -> registry -> staging -> [aprobare] -> producție
          \______ CI ______/ \__________ continuous delivery ___________/

Beneficiile nu vin din unealtă, ci din schimbări mici și dese: fiecare deploy are risc mic, problemele se găsesc ușor pentru că știi ce s-a schimbat, iar rollback-ul e simplu. Un pipeline care rulează o dată pe săptămână nu este, practic, CI.

Practici asociate: build-ul se face o singură dată și același artefact merge prin toate mediile, iar configurația diferă prin variabile, nu prin build-uri separate.

Ce urmărește intervievatorul: Se verifică terminologia de bază. Confuzia dintre continuous delivery și continuous deployment este greșeala tipică.

58 Junior

Scrie un workflow GitHub Actions care rulează testele și, pe main, construiește și publică o imagine Docker.

Răspuns scurt: Un workflow declanșat la push și pull request, cu un job de teste și un job de build care depinde de el și rulează doar pe main. Se autentifică la registry, construiește imaginea și o etichetează cu SHA-ul commit-ului.

YAML
name: ci
on:
  push:
    branches: [main]
  pull_request:

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v5
        with:
          python-version: "3.12"
          cache: pip
      - run: pip install -r requirements.txt
      - run: pytest -q

  build:
    needs: test
    if: github.ref == 'refs/heads/main'
    runs-on: ubuntu-latest
    permissions:
      contents: read
      packages: write
    steps:
      - uses: actions/checkout@v4
      - uses: docker/login-action@v3
        with:
          registry: ghcr.io
          username: ${{ github.actor }}
          password: ${{ secrets.GITHUB_TOKEN }}
      - uses: docker/build-push-action@v6
        with:
          push: true
          tags: ghcr.io/${{ github.repository }}:${{ github.sha }}

Ce merită explicat:

  • needs: test face ca imaginea să fie construită doar dacă testele trec;
  • if restricționează publicarea la main; pull request-urile rulează doar testele;
  • permissions acordă token-ului doar drepturile necesare, conform principiului privilegiului minim;
  • GITHUB_TOKEN este generat automat pentru fiecare rulare, deci nu ții o parolă permanentă;
  • tag-ul cu SHA-ul commit-ului face imaginea trasabilă: știi exact ce cod conține;
  • cache: pip refolosește pachetele între rulări.

Pentru repository-uri cu nume ce conțin majuscule, numele imaginii pentru GHCR trebuie transformat în litere mici. Pe proiecte reale, acțiunile terțe se fixează adesea pe SHA complet, nu pe tag, ca să nu se schimbe pe ascuns.

Ce urmărește intervievatorul: Se verifică experiența practică cu un sistem de CI. Intervievatorul urmărește dependența dintre job-uri și permisiunile minime.

59 Junior

Ce înseamnă „build once, deploy many” și de ce e important?

Răspuns scurt: Construiești artefactul o singură dată, îl versionezi și îl promovezi neschimbat prin toate mediile (test, staging, producție). Diferențele dintre medii vin doar din configurație, astfel încât ce ai testat este exact ce ajunge în producție.

Un artefact este rezultatul build-ului: o imagine Docker, un fișier JAR, un pachet npm, un binar Go. Se stochează într-un registry sau într-un depozit de artefacte (ECR, GHCR, Nexus, Artifactory) cu o versiune unică.

Anti-modelul este reconstruirea pentru fiecare mediu: build pentru staging, testare, apoi alt build pentru producție. Chiar din același commit, al doilea build poate diferi: o dependență fără versiune fixă s-a actualizat, imaginea de bază latest s-a schimbat, compilatorul de pe runner e altul. Ai testat un lucru și ai lansat altul.

Cu „build once, deploy many”:

build  -> api:1.8.0 (sha256:9f2c...) -> dev -> staging -> producție
config:                                 dev.env  staging.env  prod.env

Avantaje:

  • încredere: imaginea din producție are același digest cu cea testată;
  • rollback rapid: versiunea anterioară există deja în registry, nu trebuie reconstruită;
  • trasabilitate: din versiune sau din tag-ul cu SHA ajungi la commit și la rularea pipeline-ului;
  • pipeline mai rapid, pentru că promovarea nu mai implică un build.

Condiția este ca artefactul să nu conțină nimic specific mediului: nici URL-uri, nici credențiale, nici flag-uri de mediu compilate în cod. Configurația vine la rulare din variabile de mediu, ConfigMap-uri sau un serviciu de configurare, conform principiilor Twelve-Factor App.

Pentru frontend-uri care includ configurația la build, soluțiile uzuale sunt un fișier de configurare încărcat la rulare sau înlocuirea valorilor la pornirea containerului.

Ce urmărește intervievatorul: Se verifică înțelegerea reproductibilității. Intervievatorul caută legătura cu configurația externalizată.

60 Junior

Cum gestionezi parolele și cheile de care are nevoie un pipeline CI/CD?

Răspuns scurt: Nu le pui niciodată în cod sau în fișierele de configurare din Git. Le ții în managerul de secrete al platformei de CI sau într-un seif dedicat, le restrângi pe medii și ramuri, iar pentru cloud folosești identități federate prin OIDC în locul cheilor statice.

Secretele scăpate în Git sunt una dintre cele mai frecvente cauze de compromitere: repository-urile publice sunt scanate automat de boți, iar istoricul Git păstrează secretul chiar după ștergerea fișierului.

Practici de bază:

  • secretele stau în managerul platformei (GitHub Actions secrets, GitLab CI variables marcate masked și protected) sau într-un seif (HashiCorp Vault, AWS Secrets Manager);
  • restricții: secretele de producție sunt disponibile doar job-urilor de pe main sau unui mediu protejat cu aprobare;
  • pull request-urile din fork-uri nu primesc secrete;
  • scanare automată: GitHub secret scanning, gitleaks sau trufflehog în pre-commit și în CI;
  • dacă un secret a scăpat, îl revoci și îl rotești imediat; ștergerea din istoric vine după.

Pentru acces la cloud, varianta recomandată este OIDC: platforma de CI emite un token semnat pentru fiecare rulare, iar AWS îl schimbă pe credențiale temporare pentru un rol IAM, fără nicio cheie permanentă salvată.

YAML
permissions:
  id-token: write
  contents: read
steps:
  - uses: aws-actions/configure-aws-credentials@v4
    with:
      role-to-assume: arn:aws:iam::123456789012:role/gha-deploy
      aws-region: eu-central-1

Politica de încredere a rolului poate limita accesul la un anumit repository și o anumită ramură. Credențialele expiră după o oră implicit, iar o eventuală scurgere are impact limitat. Ai grijă și la loguri: nu afișa secrete cu echo și nu rula scripturi în modul set -x peste comenzi care le conțin.

Ce urmărește intervievatorul: Se verifică igiena de securitate în pipeline-uri. Menționarea OIDC și a revocării imediate arată nivel peste junior.

61 Mid

Compară strategiile de deploy: rolling, blue-green și canary.

Răspuns scurt: Rolling înlocuiește instanțele treptat. Blue-green rulează în paralel noul mediu complet și comută tot traficul odată, cu rollback instant. Canary trimite întâi un procent mic din trafic spre versiunea nouă și îl crește doar dacă metricile rămân bune.

Rolling update: instanțele vechi sunt înlocuite câte una sau câte un grup. Nu cere capacitate dublă și este implicit în Kubernetes. Dezavantaje: o perioadă rulează ambele versiuni amestecat, iar rollback-ul înseamnă un nou rolling update, deci durează.

Blue-green: ai două medii identice. „Blue” servește producția, „green” primește versiunea nouă și e testat. Comutarea se face la load balancer sau DNS, iar rollback-ul înseamnă comutarea înapoi, în câteva secunde. Costă capacitate dublă în timpul lansării și cere atenție la baza de date, comună de obicei celor două medii.

Canary: versiunea nouă primește, de exemplu, 5% din trafic. Compari automat rata de erori și latența cu versiunea stabilă; dacă sunt bune, crești la 25%, 50%, 100%; dacă nu, revii. Impactul unei regresii este limitat la o parte mică dintre utilizatori. Cere rutare ponderată (service mesh, ingress cu ponderi, ALB weighted target groups) și metrici bune pe versiune. Unelte: Argo Rollouts, Flagger.

canary:  v2 5% -> analiză 10 min -> 25% -> analiză -> 100%
                    \-- erori > prag --> rollback automat

Alegerea depinde de risc și de infrastructură: rolling pentru majoritatea serviciilor interne, blue-green când vrei comutare și rollback instant, canary pentru servicii cu trafic mare unde o regresie costă mult.

Toate presupun compatibilitate: schema bazei de date și contractele API trebuie să funcționeze pentru ambele versiuni simultan. Feature flags completează aceste strategii, separând lansarea codului de activarea funcționalității.

Ce urmărește intervievatorul: Se verifică dacă știi compromisurile, nu doar definițiile. Un răspuns bun menționează problema bazei de date comune.

62 Mid

Pipeline-ul de CI durează 40 de minute. Cum îl accelerezi?

Răspuns scurt: Măsor întâi unde se pierde timpul, apoi aplic cache pentru dependențe și straturi Docker, rulez joburile independente în paralel, împart testele pe mai mulți runneri, rulez doar ce e afectat de schimbare și mut verificările lente după merge.

Fără măsurare optimizezi pe ghicite. Majoritatea platformelor arată durata fiecărui job și pas; de acolo identifici cele câteva etape care consumă cel mai mult.

Tehnici, în ordinea câștigului obișnuit:

  • Cache pentru dependențe: actions/cache, cache: pip sau cache: npm în acțiunile de setup, cache Gradle sau Maven. Reinstalarea dependențelor la fiecare rulare este cea mai frecventă risipă.
  • Cache Docker: ordinea corectă a instrucțiunilor și cache exportat în registry sau în cache-ul platformei (cache-from, cache-to cu type=gha).
  • Paralelizare: lint, teste unitare, build și scanare de securitate nu depind unele de altele; job-urile separate rulează simultan.
  • Împărțirea testelor (sharding) pe mai mulți runneri, cu strategy.matrix sau cu opțiunile de sharding ale framework-ului de testare.
  • Rulare selectivă: într-un monorepo, filtre pe căi (paths:) sau unelte precum Nx, Turborepo, Bazel care rulează doar ce e afectat.
  • Runneri mai puternici sau self-hosted cu cache local, când CPU-ul e limita reală.
  • Testele lente (end-to-end, de performanță) pot rula după merge sau periodic, cu condiția să existe un proces clar pentru eșecurile lor.
YAML
strategy:
  matrix:
    shard: [1, 2, 3, 4]
steps:
  - run: npx jest --shard=${{ matrix.shard }}/4

Merită verificate și testele instabile (flaky): reluările automate ascund probleme și lungesc pipeline-ul. Scopul declarat este feedback-ul rapid: dacă un pipeline de pull request durează mult, oamenii grupează schimbările, ceea ce strică exact beneficiile CI.

Ce urmărește intervievatorul: Se verifică abordarea pragmatică: întâi măsurare, apoi optimizare. Menționarea testelor flaky e un semn de experiență.

63 Mid

Ce este GitOps și cum diferă de un pipeline care face deploy cu kubectl apply?

Răspuns scurt: În GitOps, Git este sursa de adevăr pentru starea dorită a infrastructurii, iar un agent din cluster (Argo CD, Flux) trage modificările și reconciliază continuu. Într-un pipeline clasic de tip push, CI-ul are credențiale spre cluster și aplică modificările o singură dată.

Push (clasic): după build, pipeline-ul rulează kubectl apply sau helm upgrade asupra clusterului. Simplu, dar:

  • sistemul de CI are credențiale cu drepturi largi spre fiecare cluster, deci o compromitere a CI-ului afectează producția;
  • dacă cineva modifică manual ceva în cluster, nimic nu observă diferența;
  • starea reală poate devia de la cea din Git.

Pull, adică GitOps: un repository conține manifestele (sau valorile Helm, sau overlay-urile Kustomize) pentru fiecare mediu. Un controller din cluster le citește periodic și aplică diferențele.

YAML
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: api-prod
  namespace: argocd
spec:
  project: default
  source:
    repoURL: https://github.com/firma/deploy.git
    path: apps/api/overlays/prod
    targetRevision: main
  destination:
    server: https://kubernetes.default.svc
    namespace: api
  syncPolicy:
    automated: {prune: true, selfHeal: true}

Fluxul devine: CI construiește imaginea și deschide un pull request care schimbă tag-ul imaginii în repository-ul de deploy; după merge, Argo CD sincronizează.

Beneficii: istoricul Git este jurnalul de audit al deploy-urilor, rollback-ul este un git revert, modificările manuale sunt detectate și anulate (selfHeal), iar clusterul nu trebuie expus către CI.

Dezavantaje: încă un sistem de operat, secretele cer o soluție separată (nu se pun în Git în clar), iar ordinea operațiilor, cum ar fi migrațiile de bază de date, se exprimă mai greu. În practică se separă adesea repository-ul de cod de cel de deploy.

Ce urmărește intervievatorul: Se verifică înțelegerea modelului pull și a avantajelor de securitate. Detaliul cu modificările manuale anulate este punctul care convinge.

64 Mid

De ce nu e bine să folosești tag-ul latest pentru imagini în producție? Cum versionezi artefactele?

Răspuns scurt: latest este doar o etichetă mutabilă, nu înseamnă „cea mai nouă”: nu știi ce rulează efectiv, noduri diferite pot avea versiuni diferite, iar rollback-ul e imposibil. Folosești versiuni imuabile, ca SemVer și SHA-ul commit-ului, eventual chiar digest-ul imaginii.

Probleme cu latest:

  • nu există legătură între tag și cod: nu poți spune ce commit rulează în producție;
  • un nod care descarcă imaginea mai târziu poate primi altă versiune decât un nod care o avea deja în cache, deci în același Deployment rulează versiuni diferite;
  • Kubernetes nu vede nicio schimbare în manifest când împingi un nou latest, așa că nu face rollout;
  • rollback-ul la „versiunea de ieri” nu are o țintă clară.

Scheme de versionare:

  • Semantic Versioning (MAJOR.MINOR.PATCH): major pentru schimbări incompatibile, minor pentru funcționalitate nouă compatibilă, patch pentru corecturi. Util pentru biblioteci și API-uri publice.
  • SHA-ul commit-ului (api:3f9c2e1): trasabilitate directă, potrivit pentru servicii cu deploy continuu.
  • combinații: api:1.8.0, api:1.8.0-3f9c2e1.
BASH
docker build -t reg.exemplu.ro/api:1.8.0 -t reg.exemplu.ro/api:3f9c2e1 .
docker push --all-tags reg.exemplu.ro/api
docker buildx imagetools inspect reg.exemplu.ro/api:1.8.0   # afișează digest-ul

Și tag-urile versionate pot fi suprascrise. Garanția completă vine din digest (api@sha256:...), care identifică exact conținutul. Multe registry-uri, inclusiv ECR, permit marcarea tag-urilor ca imuabile, ceea ce împiedică suprascrierea.

Etichete precum latest sau stable pot exista pentru comoditate în dezvoltare, dar manifestele de producție referă versiuni sau digest-uri explicite. Adaugă și metadate în imagine, de exemplu etichetele OCI org.opencontainers.image.revision cu SHA-ul commit-ului.

Ce urmărește intervievatorul: Se verifică disciplina în versionare. Intervievatorul caută menționarea imuabilității și a digest-ului.

65 Senior

Cum faci deploy fără întrerupere când versiunea nouă cere o modificare a schemei bazei de date?

Răspuns scurt: Folosesc tiparul expand and contract: întâi adaug elementele noi în schemă în mod compatibil cu versiunea veche, apoi lansez codul care le folosește, migrez datele, și abia după ce versiunea veche a dispărut elimin coloanele sau tabelele vechi, într-un deploy separat.

În timpul unui rolling update sau canary, ambele versiuni ale aplicației rulează simultan pe aceeași bază de date. O migrare care redenumește o coloană strică imediat versiunea veche, iar rollback-ul codului nu mai funcționează, pentru că schema s-a schimbat.

Exemplu: redenumirea coloanei nume în nume_complet.

  • Pasul 1, expand: adaugi coloana nouă, care acceptă NULL. Versiunea veche o ignoră.
  • Pasul 2: lansezi codul care scrie în ambele coloane și citește din cea nouă, cu fallback la cea veche.
  • Pasul 3: migrezi datele existente în loturi mici, ca să nu blochezi tabela.
  • Pasul 4: lansezi codul care folosește doar coloana nouă.
  • Pasul 5, contract: după ce nu mai rulează nicio instanță veche și rollback-ul nu mai e necesar, ștergi coloana veche.
SQL
ALTER TABLE clienti ADD COLUMN nume_complet text;
UPDATE clienti SET nume_complet = nume
 WHERE id BETWEEN 1 AND 10000 AND nume_complet IS NULL;

Alte reguli:

  • migrațiile rulează ca pas separat, înainte de deploy-ul codului (un Job Kubernetes sau o etapă de pipeline), nu la pornirea fiecărei replici, unde ar rula concurent;
  • operațiile care blochează tabele mari se evită sau se fac cu variante non-blocante: în PostgreSQL, CREATE INDEX CONCURRENTLY și un lock_timeout scurt;
  • fiecare migrare se testează pe o copie realistă a datelor, pentru că pe tabele mari durata poate surprinde;
  • migrațiile distructive nu au rollback simplu, de aceea backup-ul și separarea în pași sunt esențiale.

Procesul e mai lent, dar fiecare pas este sigur și reversibil.

Ce urmărește intervievatorul: La senior se verifică înțelegerea compatibilității între versiuni. Candidații slabi propun migrarea și deploy-ul codului în același pas.

66 Senior

Cum protejezi lanțul de livrare software (supply chain) într-un sistem CI/CD?

Răspuns scurt: Fixez dependențele și acțiunile terțe pe versiuni exacte sau SHA, rulez build-urile în medii izolate cu permisiuni minime, generez SBOM și atestări de proveniență, semnez imaginile și permit în producție doar artefacte semnate, provenite din pipeline-ul oficial.

Atacurile asupra lanțului de livrare nu țintesc aplicația direct, ci ceea ce intră în ea: o dependență compromisă, o acțiune de CI modificată, un runner infectat sau un registry în care cineva împinge o imagine falsă.

Măsuri pe etape:

  • Sursa: protecția ramurilor, review obligatoriu, commit-uri semnate unde e cerut, CODEOWNERS pentru fișierele de pipeline și infrastructură.
  • Dependențele: lock files cu hash-uri, un proxy sau registry intern pentru pachete, Dependabot sau Renovate pentru actualizări controlate, scanare SCA pentru vulnerabilități cunoscute.
  • Pipeline-ul: acțiunile terțe fixate pe SHA complet, nu pe tag mutabil; permissions minime pentru token; runneri efemeri, care nu păstrează starea între rulări; OIDC în locul cheilor statice.
  • Artefactul: SBOM generat la build (Syft, formatul SPDX sau CycloneDX), atestare de proveniență care spune ce pipeline, din ce commit, a produs artefactul, semnătură cu cosign.
  • Deploy-ul: admission controller în cluster (Kyverno, OPA Gatekeeper, Sigstore policy-controller) care respinge imaginile nesemnate sau care nu provin din registry-ul aprobat.
YAML
- uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  # v4.2.2
BASH
cosign sign --yes reg.exemplu.ro/api@sha256:9f2c...
cosign verify reg.exemplu.ro/api@sha256:9f2c... \
  --certificate-identity-regexp 'https://github.com/firma/.*' \
  --certificate-oidc-issuer https://token.actions.githubusercontent.com

Cadrul SLSA (Supply-chain Levels for Software Artifacts) organizează aceste practici pe niveluri și e util pentru a prioritiza. Nu toate se implementează din prima; încep de obicei cu permisiunile pipeline-ului și fixarea dependențelor, care au cel mai bun raport între efort și beneficiu.

Ce urmărește intervievatorul: La senior se verifică viziunea asupra securității de la sursă la producție. Fixarea acțiunilor pe SHA și verificarea semnăturii la deploy sunt detaliile care contează.

Infrastructure as Code (Terraform)

67 Junior

Ce este Infrastructure as Code și ce avantaje are? Ce înseamnă declarativ față de imperativ?

Răspuns scurt: IaC înseamnă descrierea infrastructurii în fișiere de cod versionate, aplicate de unelte automate, în loc de configurare manuală din consolă. Declarativ descrii starea finală dorită, iar unealta calculează pașii; imperativ scrii tu pașii, în ordine.

Fără IaC, infrastructura se creează din consola web sau cu comenzi rulate manual. Rezultatul e greu de reprodus: nimeni nu știe exact ce setări are serverul de producție, mediul de staging diferă subtil de producție, iar recrearea după un incident durează zile.

Cu IaC:

  • reproductibilitate: același cod creează medii identice;
  • versionare și review: schimbările trec prin pull request, ca orice cod, și au istoric;
  • automatizare: infrastructura se poate aplica din pipeline;
  • documentație vie: codul descrie ce există;
  • recuperare: un mediu șters accidental poate fi recreat.

Declarativ (Terraform, CloudFormation, manifestele Kubernetes): spui „vreau un bucket S3 cu versionare activată”. Unealta compară cu ce există și face doar diferența; dacă bucket-ul există deja, nu face nimic.

resource "aws_s3_bucket" "loguri" {
  bucket = "firma-loguri-prod"
}

Imperativ (scripturi cu AWS CLI): „creează bucket-ul, apoi activează versionarea”. Rulat a doua oară, primul pas eșuează pentru că bucket-ul există deja; trebuie să tratezi singur fiecare caz.

BASH
aws s3api create-bucket --bucket firma-loguri-prod \
  --create-bucket-configuration LocationConstraint=eu-central-1

Ansible este la mijloc: descrii sarcini, dar majoritatea modulelor sunt idempotente. Pulumi și AWS CDK folosesc limbaje de programare generale, dar rezultatul este tot un model declarativ, aplicat de un motor.

Regula practică după adoptarea IaC: modificările manuale în consolă se evită, pentru că desincronizează codul de realitate.

Ce urmărește intervievatorul: Se verifică motivația din spatele IaC. Intervievatorul apreciază exemplul concret de idempotență.

68 Junior

Ce fac comenzile terraform init, plan și apply?

Răspuns scurt: init descarcă providerii și modulele și configurează backend-ul de state. plan compară codul cu starea reală și arată ce s-ar crea, modifica sau distruge. apply execută modificările, de preferat pe baza unui plan salvat și revizuit.

Fluxul de lucru standard:

BASH
terraform init                 # o dată pe director sau după schimbarea providerilor
terraform fmt -check           # formatare
terraform validate             # sintaxă și referințe
terraform plan -out=tfplan     # ce se va schimba, salvat în fișier
terraform apply tfplan         # aplică exact planul revizuit

init: citește blocurile terraform și provider, descarcă providerii (de exemplu hashicorp/aws) în .terraform/, descarcă modulele și conectează backend-ul de state. Creează și fișierul .terraform.lock.hcl, care fixează versiunile exacte ale providerilor și trebuie pus în Git.

plan: reîmprospătează starea resurselor reale prin API-urile furnizorului, o compară cu codul și afișează diferențele cu simboluri: + creare, ~ modificare pe loc, - distrugere, -/+ înlocuire (distrugere și recreare). Ultima merită atenție maximă: unele atribute nu pot fi schimbate pe loc, de exemplu identificatorul unei baze de date RDS, iar înlocuirea înseamnă pierderea datelor.

apply: execută modificările în ordinea dedusă din dependențele dintre resurse, în paralel unde se poate, și actualizează state-ul.

În echipă, plan rulează automat la fiecare pull request, iar rezultatul este pus ca un comentariu pentru review; apply rulează după aprobare, din pipeline, nu de pe laptopul cuiva. Aplicarea unui plan salvat garantează că se execută exact ce s-a revizuit, nu un plan recalculat între timp.

terraform destroy șterge toate resursele gestionate de configurație și nu se rulează niciodată în producție fără protecții suplimentare.

Ce urmărește intervievatorul: Se verifică fluxul de bază Terraform. Atenția la înlocuirile -/+ arată experiență practică.

69 Junior

Ce este state-ul Terraform și de ce se ține într-un backend remote cu locking?

Răspuns scurt: State-ul este fișierul în care Terraform reține legătura dintre resursele din cod și cele reale, cu atributele lor. Îl ții remote (de exemplu în S3) ca echipa să lucreze pe aceeași versiune, iar locking-ul împiedică două apply simultane care l-ar corupe.

Terraform nu poate deduce singur care instanță EC2 din cont corespunde blocului aws_instance.web. State-ul (terraform.tfstate, un fișier JSON) păstrează această corespondență, plus ID-urile și atributele resurselor și dependențele dintre ele.

Problemele unui state local:

  • fiecare membru al echipei ar avea propria copie, deci planuri contradictorii;
  • se pierde odată cu laptopul;
  • conține adesea date sensibile în clar (parole generate, chei), deci nu se pune în Git.

Backend remote pe S3:

terraform {
  backend "s3" {
    bucket       = "firma-terraform-state"
    key          = "prod/retea/terraform.tfstate"
    region       = "eu-central-1"
    encrypt      = true
    use_lockfile = true
  }
}

Locking-ul previne situația în care doi oameni sau două pipeline-uri rulează apply simultan: al doilea așteaptă sau eșuează cu un mesaj clar. Istoric, cu S3 se folosea un tabel DynamoDB (dynamodb_table); din Terraform 1.10, backend-ul S3 suportă locking nativ prin use_lockfile, iar în versiunile următoare varianta cu DynamoDB a fost marcată ca depreciată. Alte backend-uri (Terraform Cloud, GCS, azurerm) au locking integrat.

Bucket-ul de state trebuie protejat: versionare activată, ca să poți reveni la o versiune anterioară, criptare, acces restricționat prin IAM și blocarea accesului public.

Modificarea manuală a state-ului se face doar cu comenzile dedicate (terraform state mv, state rm, import), niciodată prin editarea fișierului JSON. Dacă un proces a murit și a lăsat lock-ul agățat, terraform force-unlock îl eliberează, dar numai după ce te asiguri că nu mai rulează nimic.

Ce urmărește intervievatorul: Se verifică înțelegerea rolului state-ului. Intervievatorul caută menționarea datelor sensibile și a locking-ului.

70 Mid

Cum structurezi codul Terraform cu module, variabile și outputs? Dă un exemplu.

Răspuns scurt: Un modul este un director cu resurse reutilizabile, parametrizat prin variabile și care expune valori prin outputs. Configurația rădăcină a fiecărui mediu apelează modulele cu valorile proprii, evitând copierea codului între medii.

Structură tipică:

modules/
  serviciu-web/
    main.tf  variables.tf  outputs.tf
envs/
  staging/main.tf
  prod/main.tf

Modulul:

# modules/serviciu-web/variables.tf
variable "nume" {
  type = string
}
variable "nr_instante" {
  type    = number
  default = 2
  validation {
    condition     = var.nr_instante >= 1
    error_message = "Este necesară cel puțin o instanță."
  }
}
variable "subnet_ids" {
  type = list(string)
}

# modules/serviciu-web/outputs.tf
output "security_group_id" {
  value = aws_security_group.web.id
}

Folosirea lui:

# envs/prod/main.tf
module "api" {
  source      = "../../modules/serviciu-web"
  nume        = "api-prod"
  nr_instante = 4
  subnet_ids  = module.retea.subneturi_private
}

Reguli bune:

  • un modul încapsulează un concept cu sens („serviciu web”, „rețea”), nu o singură resursă înfășurată fără valoare adăugată;
  • variabilele au tipuri, descrieri și validări; valorile implicite sunt sigure;
  • outputs expun doar ce au nevoie alții să consume;
  • modulele partajate între echipe se versionează (tag-uri Git sau un registry de module), iar mediile referă o versiune fixă: source = "git::https://...//serviciu-web?ref=v1.3.0";
  • valorile sensibile se marchează cu sensitive = true, ca să nu apară în output-ul planului.

Modulele publice din Terraform Registry (de exemplu terraform-aws-modules/vpc/aws) economisesc mult timp, dar trebuie citite și fixate pe versiune, ca orice dependență.

Ce urmărește intervievatorul: Se verifică organizarea codului IaC. Fixarea versiunilor modulelor și validările sunt semnele unui cod matur.

71 Mid

Ce este drift-ul de infrastructură și cum îl gestionezi? Cum aduci în Terraform o resursă creată manual?

Răspuns scurt: Drift-ul este diferența dintre starea reală și cea descrisă în cod, apărută de obicei din modificări manuale. Îl detectezi cu terraform plan rulat periodic. O resursă existentă o aduci sub gestionare cu un bloc import (Terraform 1.5+) sau cu terraform import.

Drift-ul apare când cineva modifică o regulă de security group din consolă în timpul unui incident, când un alt instrument atinge aceleași resurse sau când un serviciu AWS schimbă singur ceva. Pericolul: următorul apply anulează modificarea manuală fără ca autorul ei să știe, sau planul devine plin de diferențe pe care nimeni nu le înțelege.

Detectare:

BASH
terraform plan -detailed-exitcode
# 0 = nicio diferență, 1 = eroare, 2 = există diferențe

Un job programat rulează zilnic planul pe fiecare mediu și trimite o alertă la codul 2. Ca prevenție, accesul de scriere în consolă pentru producție se restrânge, iar schimbările trec prin pipeline.

Când găsești drift, decizi: dacă schimbarea manuală era corectă, o treci în cod; dacă nu, apply readuce starea din cod.

Importul unei resurse existente, cu sintaxa declarativă din Terraform 1.5:

import {
  to = aws_s3_bucket.rapoarte
  id = "firma-rapoarte-vechi"
}

resource "aws_s3_bucket" "rapoarte" {
  bucket = "firma-rapoarte-vechi"
}
BASH
terraform plan -generate-config-out=generat.tf   # generează un schelet de configurație

Importul apare în plan, deci poate fi revizuit, spre deosebire de comanda veche terraform import, care modifică state-ul imediat. După import, ajustezi codul până când plan nu mai arată diferențe. Pentru conturi cu multe resurse create manual, importul se face treptat, începând cu resursele cele mai critice.

Ce urmărește intervievatorul: Se verifică experiența cu infrastructură reală, unde codul și realitatea diverg. Blocul import arată cunoașterea versiunilor recente.

72 Mid

Care e diferența dintre count și for_each în Terraform?

Răspuns scurt: Ambele creează mai multe instanțe ale unei resurse. count le indexează numeric, deci eliminarea unui element din mijlocul listei mută indecșii și poate recrea resurse. for_each le indexează după chei stabile, așa că fiecare instanță rămâne legată de cheia ei.

Cu count:

variable "utilizatori" {
  default = ["ana", "bogdan", "carmen"]
}

resource "aws_iam_user" "u" {
  count = length(var.utilizatori)
  name  = var.utilizatori[count.index]
}

În state apar aws_iam_user.u[0] (ana), u[1] (bogdan), u[2] (carmen). Dacă elimini bogdan din listă, carmen ajunge pe indexul 1. Planul va propune redenumirea lui u[1] din bogdan în carmen și distrugerea lui u[2]. Pentru utilizatori IAM e neplăcut; pentru baze de date sau discuri poate însemna pierdere de date.

Cu for_each:

resource "aws_iam_user" "u" {
  for_each = toset(var.utilizatori)
  name     = each.key
}

Acum instanțele sunt u["ana"], u["bogdan"], u["carmen"]. Eliminarea lui bogdan distruge doar u["bogdan"].

for_each acceptă un map sau un set de șiruri, deci poți trece și configurații diferite:

variable "buckets" {
  default = {
    loguri  = { versionare = false }
    backups = { versionare = true }
  }
}
resource "aws_s3_bucket" "b" {
  for_each = var.buckets
  bucket   = "firma-${each.key}"
}

Când rămâne count potrivit: pentru o resursă opțională, count = var.activ ? 1 : 0, sau pentru N copii cu adevărat identice. Cheile din for_each trebuie cunoscute la planificare; nu pot depinde de atribute generate abia după crearea altor resurse. Trecerea de la count la for_each pe resurse existente se face cu blocuri moved, ca să nu se recreeze.

Ce urmărește intervievatorul: Se verifică o capcană reală din Terraform. Candidații care au pățit-o explică imediat problema indecșilor.

73 Mid

Care e diferența dintre Terraform și Ansible? Le-ai folosi împreună?

Răspuns scurt: Terraform e o unealtă de provisioning: creează și gestionează resurse de infrastructură (rețele, mașini, baze de date) prin API-uri, cu state. Ansible e configuration management: configurează sistemele existente prin SSH, fără state. Se pot folosi împreună, fiecare pentru rolul lui.

Terraform:

  • declarativ, cu un graf de dependențe și state;
  • vorbește cu API-urile furnizorilor (AWS, Azure, GCP, Cloudflare, GitHub, Datadog etc.) prin provideri;
  • puternic la crearea, modificarea și ștergerea resurselor și la detectarea diferențelor;
  • nu e făcut să instaleze pachete sau să editeze fișiere pe servere.

Ansible:

  • playbook-uri YAML cu sarcini executate în ordine, prin SSH, fără agent pe servere;
  • majoritatea modulelor sunt idempotente (apt, template, service, user);
  • nu ține state: la fiecare rulare verifică starea curentă a sistemului;
  • bun la configurarea sistemului de operare, a aplicațiilor, la operații pe flote de servere (patch-uri, rotiri de certificate).
YAML
- hosts: web
  become: true
  tasks:
    - name: Instalează nginx
      ansible.builtin.apt:
        name: nginx
        state: present
        update_cache: true
    - name: Pornește nginx
      ansible.builtin.service:
        name: nginx
        state: started
        enabled: true

Combinația clasică: Terraform creează VPC-ul, instanțele și load balancer-ul, apoi Ansible configurează instanțele, cu un inventar dinamic generat din tag-urile AWS.

Tendința actuală reduce nevoia de configuration management pe servere: imagini preconstruite (cu Packer sau Docker) și servere tratate ca imuabile, înlocuite la fiecare schimbare, nu modificate pe loc. Ansible rămâne foarte util pentru medii on-premise, echipamente de rețea și sarcini operaționale.

Ce urmărește intervievatorul: Se verifică dacă înțelegi rolul fiecărei unelte. Răspunsul bun menționează și tendința spre infrastructura imuabilă.

74 Senior

Cum organizezi codul Terraform pentru mai multe medii și echipe astfel încât o greșeală să nu afecteze tot?

Răspuns scurt: Separ state-ul pe medii și pe componente, cu configurații rădăcină separate care folosesc module versionate. Producția e într-un cont AWS separat, aplicarea se face doar din pipeline cu roluri distincte, iar fiecare state are o rază de impact mică.

Problema centrală este blast radius, adică raza de impact. Un singur state cu toată infrastructura înseamnă planuri lente, lock-uri care blochează toată echipa și riscul ca o modificare minoră să atingă baza de date de producție.

Principii:

  • State separat pe mediu și pe strat: rețea, date, aplicații, monitorizare. Straturile care se schimbă rar (VPC-ul) sunt separate de cele care se schimbă des.
  • Conturi AWS separate pentru dev, staging și producție (AWS Organizations), cu roluri distincte. Chiar și cu un cod greșit, pipeline-ul de staging nu are drepturi în contul de producție.
  • Directoare pe medii, nu workspaces, pentru diferențe reale: workspaces partajează același cod și backend, iar diferențele dintre medii ajung în condiții greu de urmărit. Workspaces se potrivesc mai bine pentru medii identice și efemere.
  • Module versionate: staging folosește v1.4.0 înaintea producției, deci schimbarea unui modul nu ajunge peste tot simultan.
  • Legături între straturi prin outputs citite cu terraform_remote_state sau, mai decuplat, prin data sources ori parametri în SSM Parameter Store.
  • Protecții: prevent_destroy în blocul lifecycle pentru resursele critice, deletion protection pe RDS, politici automate (OPA/Conftest, Sentinel, Checkov) în pipeline.
live/
  prod/
    retea/       -> state: prod/retea
    date/        -> state: prod/date
    api/         -> state: prod/api
  staging/
    ...

Unelte precum Terragrunt sau Terraform Stacks reduc repetarea configurației backend-ului. Compromisul este un număr mai mare de state-uri și dependențe între ele de gestionat, dar o eroare afectează o felie mică, nu tot.

Ce urmărește intervievatorul: La senior se verifică gândirea despre izolare și risc. Intervievatorul vrea argumente pentru separare, nu doar o structură de directoare.

AWS și cloud

75 Junior

Ce sunt regiunile și zonele de disponibilitate (Availability Zones) în AWS?

Răspuns scurt: O regiune este o zonă geografică (de exemplu eu-central-1, Frankfurt), independentă de celelalte. Fiecare regiune are mai multe zone de disponibilitate, adică centre de date izolate fizic, conectate prin rețea cu latență mică. Pentru disponibilitate ridicată distribui resursele pe mai multe AZ-uri.

Regiunile sunt complet separate: datele nu pleacă dintr-o regiune decât dacă le copiezi explicit, iar majoritatea serviciilor sunt regionale (EC2, RDS, VPC, majoritatea resurselor). Alegerea regiunii ține cont de:

  • latența față de utilizatori;
  • cerințele legale privind localizarea datelor (de exemplu GDPR și politicile interne de păstrare a datelor în UE);
  • disponibilitatea serviciilor, pentru că nu toate există în toate regiunile;
  • prețurile, care diferă între regiuni.

Zonele de disponibilitate (eu-central-1a, eu-central-1b, eu-central-1c) sunt unul sau mai multe centre de date cu alimentare, răcire și rețea independente. O problemă într-o zonă (pană de curent, inundație) nu ar trebui să le afecteze pe celelalte.

Consecințe practice:

  • un subnet aparține unei singure AZ;
  • un volum EBS există într-o singură AZ și se atașează doar instanțelor din aceeași zonă;
  • un Auto Scaling Group configurat pe subneturi din trei AZ-uri distribuie instanțele și le recreează în altă zonă dacă una pică;
  • RDS Multi-AZ păstrează o replică sincronă în altă zonă, cu failover automat;
  • traficul între AZ-uri se plătește, deci arhitecturile foarte vorbărețe între zone pot costa.

Există și servicii globale, precum IAM, Route 53 și CloudFront. Numele AZ-urilor (1a, 1b) pot corespunde unor locații fizice diferite în conturi diferite; identificatorul stabil între conturi este AZ ID-ul, de exemplu euc1-az1.

Ce urmărește intervievatorul: Se verifică noțiunile de bază ale cloud-ului. Candidații buni leagă AZ-urile de proiectarea pentru disponibilitate.

76 Junior

Explică IAM în AWS: utilizatori, grupuri, roluri și politici. Ce înseamnă least privilege?

Răspuns scurt: Utilizatorii sunt identități permanente, grupurile adună utilizatori, rolurile sunt identități preluate temporar de oameni sau servicii, iar politicile sunt documente JSON care permit sau interzic acțiuni pe resurse. Least privilege înseamnă să acorzi doar permisiunile strict necesare.

IAM (Identity and Access Management) decide cine poate face ce în contul AWS.

  • User: o identitate cu credențiale permanente (parolă pentru consolă, chei de acces pentru API). Recomandarea actuală este să eviți utilizatorii IAM pentru oameni și să folosești IAM Identity Center (SSO), cu credențiale temporare.
  • Group: o colecție de utilizatori care primesc aceleași politici.
  • Role: nu are credențiale permanente; este „asumat” de cineva care primește credențiale temporare. Îl folosesc instanțele EC2, funcțiile Lambda, pod-urile din EKS, pipeline-urile CI prin OIDC și utilizatorii din alte conturi.
  • Policy: document JSON cu reguli.
{
  "Version": "2012-10-17",
  "Statement": [{
    "Effect": "Allow",
    "Action": ["s3:GetObject"],
    "Resource": "arn:aws:s3:::firma-rapoarte/*"
  }]
}

Reguli de evaluare: implicit totul este interzis; un Allow explicit acordă accesul; un Deny explicit câștigă întotdeauna, indiferent de câte Allow există.

Least privilege: în loc de "Action": "s3:*" și "Resource": "*", dai exact acțiunile și resursele necesare. Dacă o cheie e compromisă, atacatorul are acces doar la acel lucru. În practică pornești de la politicile gestionate de AWS pentru a avansa repede, apoi restrângi folosind IAM Access Analyzer și informațiile despre ultima utilizare a permisiunilor.

Contul root se folosește doar pentru câteva operații speciale, are MFA activat și nu are chei de acces.

Ce urmărește intervievatorul: Se verifică fundamentul securității în AWS. Greșeala tipică este folosirea cheilor de utilizator acolo unde trebuia un rol.

77 Junior

Ce este un security group și prin ce diferă de un Network ACL?

Răspuns scurt: Un security group este un firewall atașat unei resurse, cu reguli doar de tip allow, și este stateful: răspunsurile sunt permise automat. Un NACL se aplică la nivel de subnet, are reguli allow și deny evaluate în ordine și este stateless.

Security group (SG):

  • se atașează unei instanțe EC2, unei baze RDS, unui load balancer, unui pod (în anumite configurații EKS);
  • conține doar reguli allow; ce nu e permis este blocat;
  • este stateful: dacă permiți intrarea pe portul 443, răspunsul pleacă automat, fără o regulă de ieșire;
  • poate referi alt security group ca sursă, nu doar intervale IP.

Exemplu tipic de arhitectură pe trei niveluri:

sg-alb: intrare 443 de la 0.0.0.0/0
sg-app: intrare 8000 doar de la sg-alb
sg-db:  intrare 5432 doar de la sg-app

Referirea prin SG e mai robustă decât prin IP: dacă instanțele aplicației se schimbă la scalare, regula rămâne corectă.

Network ACL:

  • se aplică întregului subnet;
  • are reguli numerotate, evaluate în ordine crescătoare, cu allow și deny;
  • este stateless: trebuie să permiți explicit și traficul de întoarcere, care vine pe porturi efemere (de obicei 1024–65535);
  • NACL-ul implicit permite tot.

De obicei securitatea se face în principal cu security groups, iar NACL-urile rămân permisive sau se folosesc pentru blocări grosiere, de exemplu un interval IP abuziv, pentru că doar ele au reguli deny.

O greșeală frecventă de depanare: cineva restrânge un NACL și uită de porturile efemere, iar conexiunile pleacă, dar răspunsurile nu se mai întorc. Simptomul este timeout, nu conexiune refuzată.

Ce urmărește intervievatorul: Se verifică diferența stateful/stateless, întrebată aproape la orice interviu AWS. Exemplul cu SG referit prin SG arată experiență.

78 Junior

Ce este Amazon S3 și cum previi expunerea accidentală a unui bucket?

Răspuns scurt: S3 este stocare de obiecte: fișiere de orice tip, păstrate în bucket-uri și accesate prin API după cheie. Previi expunerea cu Block Public Access activat, politici de bucket restrictive, criptare și acces doar prin roluri IAM sau URL-uri presemnate.

S3 nu este un sistem de fișiere: nu are directoare reale (prefixele din cheie doar le imită), nu permite modificarea parțială a unui obiect și se accesează prin HTTP API. În schimb, este foarte durabil, practic nelimitat ca spațiu și ieftin pentru volume mari. Utilizări: backup-uri, loguri, fișiere statice ale site-urilor, date pentru analiză, artefacte de build.

Clase de stocare: Standard pentru acces frecvent, Standard-IA și One Zone-IA pentru acces rar, Glacier (Instant Retrieval, Flexible Retrieval, Deep Archive) pentru arhivare, Intelligent-Tiering care mută automat obiectele. Lifecycle rules mută sau șterg obiectele după vârstă.

Bucket-urile expuse public au fost cauza multor scurgeri de date. Protecții:

  • S3 Block Public Access la nivel de cont și de bucket. Pentru bucket-urile noi este activat implicit;
  • Object Ownership cu „bucket owner enforced”, adică ACL-urile dezactivate (implicit pentru bucket-urile noi din aprilie 2023), astfel încât accesul se controlează doar prin politici;
  • criptare la repaus (SSE-S3 este implicită) sau SSE-KMS pentru control asupra cheilor;
  • versionare, ca protecție la ștergeri și suprascrieri accidentale;
  • pentru partajare temporară, URL-uri presemnate:
BASH
aws s3 presign s3://firma-rapoarte/2026/raport.pdf --expires-in 3600

Pentru un site static public, varianta recomandată este CloudFront în fața bucket-ului, cu Origin Access Control, astfel încât bucket-ul rămâne privat și doar CDN-ul îl poate citi.

Ce urmărește intervievatorul: Se verifică familiaritatea cu cel mai folosit serviciu AWS și conștiința riscurilor. Intervievatorul caută Block Public Access și URL-urile presemnate.

79 Junior

Care e diferența dintre un subnet public și unul privat într-un VPC? La ce folosește un NAT Gateway?

Răspuns scurt: Un subnet public are în tabela de rute o rută spre un Internet Gateway, deci resursele cu IP public sunt accesibile din internet. Un subnet privat nu are această rută; pentru ieșirea spre internet folosește un NAT Gateway, care permite conexiuni doar inițiate din interior.

Un VPC (Virtual Private Cloud) este rețeaua ta privată în AWS, cu un interval CIDR (de exemplu 10.0.0.0/16) împărțit în subneturi, fiecare într-o singură zonă de disponibilitate.

Ce face un subnet „public” nu este o setare a subnetului, ci tabela lui de rute:

Subnet public:  10.0.0.0/16 -> local,  0.0.0.0/0 -> igw-...
Subnet privat:  10.0.0.0/16 -> local,  0.0.0.0/0 -> nat-...
  • Internet Gateway (IGW): legătura VPC-ului cu internetul, în ambele direcții, pentru resursele care au IP public.
  • NAT Gateway: stă într-un subnet public. Instanțele din subneturile private trimit traficul spre internet prin el (de exemplu pentru actualizări de pachete sau apeluri API externe), iar NAT-ul înlocuiește adresa sursă cu IP-ul lui public. Conexiunile inițiate din internet spre instanțele private nu sunt posibile.

Arhitectura tipică:

  • subneturi publice: load balancere, NAT Gateway-uri, eventual un bastion;
  • subneturi private: servere de aplicație, noduri Kubernetes;
  • subneturi private izolate, fără ruta NAT: baze de date.

Detalii practice: un NAT Gateway este legat de o singură zonă, deci pentru disponibilitate ridicată se pune câte unul în fiecare AZ. NAT-ul se plătește pe oră și pe GB procesat, și poate deveni un cost surprinzător. Traficul spre S3 și DynamoDB poate ocoli NAT-ul prin VPC gateway endpoints, care sunt gratuite, iar pentru alte servicii AWS există interface endpoints (PrivateLink). Pentru acces administrativ la instanțele private, Systems Manager Session Manager elimină nevoia unui bastion cu SSH deschis.

Ce urmărește intervievatorul: Se verifică înțelegerea rețelei în cloud. Faptul că „public” vine din tabela de rute și costul NAT-ului sunt detaliile apreciate.

80 Junior

Ce este modelul de responsabilitate partajată (shared responsibility model)?

Răspuns scurt: AWS răspunde de securitatea cloud-ului: centrele de date, hardware-ul, rețeaua fizică și software-ul de virtualizare. Clientul răspunde de securitatea în cloud: datele, identitățile și permisiunile, configurația rețelei, sistemul de operare al instanțelor și aplicațiile.

Modelul clarifică cine trebuie să facă ce. O greșeală frecventă este presupunerea că „fiind în cloud, AWS se ocupă de securitate”.

AWS (security of the cloud):

  • securitatea fizică a centrelor de date;
  • hardware-ul, rețeaua globală, hypervisor-ul;
  • infrastructura serviciilor gestionate.

Clientul (security in the cloud):

  • configurarea IAM: cine are acces, cu ce permisiuni, MFA;
  • datele: clasificare, criptare, backup;
  • configurația rețelei: security groups, NACL-uri, ce e expus public;
  • pe EC2: actualizarea sistemului de operare, configurarea firewall-ului, aplicațiile instalate;
  • logarea și monitorizarea activității (CloudTrail, GuardDuty).

Linia de separare se mută în funcție de tipul serviciului:

  • EC2 (IaaS): tu gestionezi sistemul de operare și tot ce rulează pe el.
  • RDS: AWS aplică patch-urile motorului de baze de date în ferestrele de mentenanță; tu gestionezi utilizatorii bazei de date, accesul de rețea, backup-ul configurat și datele.
  • Lambda, S3, DynamoDB: AWS gestionează aproape toată infrastructura; tu răspunzi de cod, de permisiuni și de date.

Concluzia practică: cu cât folosești mai multe servicii gestionate, cu atât preiei mai puține responsabilități operaționale, dar configurarea greșită a accesului rămâne mereu responsabilitatea ta. Majoritatea incidentelor de securitate din cloud vin din configurări greșite făcute de client (bucket-uri publice, chei scăpate, permisiuni prea largi), nu din compromiterea infrastructurii furnizorului. Același model există, cu mici diferențe, la Azure și Google Cloud.

Ce urmărește intervievatorul: Se verifică înțelegerea limitelor responsabilității. Intervievatorul caută exemple concrete despre cum se mută linia între servicii.

81 Mid

Cum dai unei aplicații care rulează pe EC2 sau în EKS acces la un bucket S3 fără să pui chei de acces în configurație?

Răspuns scurt: Pe EC2 atașezi instanței un rol IAM printr-un instance profile; SDK-ul obține automat credențiale temporare de la serviciul de metadate. În EKS folosești IRSA sau EKS Pod Identity, care leagă un service account Kubernetes de un rol IAM.

Cheile statice puse în fișiere de configurare sau în variabile de mediu ajung ușor în Git, în imagini Docker sau în loguri și nu expiră. Rolurile oferă credențiale temporare, rotite automat.

Pe EC2:

  • creezi un rol cu o politică de încredere care permite serviciului ec2.amazonaws.com să îl asume;
  • atașezi politica de permisiuni (de exemplu s3:GetObject și s3:PutObject pe arn:aws:s3:::firma-rapoarte/*);
  • legi rolul de instanță printr-un instance profile.

SDK-urile AWS caută credențiale într-o ordine standard; când nu găsesc altele, le cer de la Instance Metadata Service. Codul nu conține nimic special:

PYTHON
import boto3
s3 = boto3.client("s3")
s3.upload_file("raport.pdf", "firma-rapoarte", "2026/raport.pdf")

Activează IMDSv2 (bazat pe token de sesiune) și dezactivează IMDSv1: o vulnerabilitate de tip SSRF în aplicație ar putea altfel citi credențialele rolului din metadate.

În EKS, dacă ai folosi rolul nodului, toate pod-urile de pe nod ar avea aceleași permisiuni. Soluții:

  • IRSA (IAM Roles for Service Accounts): clusterul are un furnizor OIDC, iar service account-ul are adnotarea eks.amazonaws.com/role-arn;
  • EKS Pod Identity (din 2023): o asociere configurată prin API-ul EKS, mai simplu de gestionat la scară.
YAML
apiVersion: v1
kind: ServiceAccount
metadata:
  name: rapoarte
  annotations:
    eks.amazonaws.com/role-arn: arn:aws:iam::123456789012:role/rapoarte-s3

Rezultatul: fiecare aplicație are propriul rol, cu permisiuni minime, și credențiale care expiră singure.

Ce urmărește intervievatorul: Se verifică practica de securitate în cloud. Menționarea IMDSv2 și a izolării per pod în EKS arată nivel de mid.

82 Mid

Cum construiești o aplicație web scalabilă pe EC2 cu Auto Scaling Group și Application Load Balancer?

Răspuns scurt: Creezi un launch template, un Auto Scaling Group pe subneturi private din mai multe AZ-uri și un ALB public care trimite traficul spre target group-ul grupului. Health check-urile scot instanțele defecte, iar politicile de scalare ajustează numărul de instanțe după metrici.

Componente:

  • Launch template: AMI, tipul instanței, rolul IAM, security group, user data pentru pornire. Ideal, AMI-ul conține deja aplicația (construit cu Packer), ca instanțele noi să pornească repede.
  • Auto Scaling Group (ASG): menține între min și max instanțe, distribuite pe subneturile din mai multe zone de disponibilitate.
  • Application Load Balancer (ALB): în subneturile publice, cu listener HTTPS și certificat din ACM; trimite traficul către un target group în care ASG-ul înregistrează automat instanțele.

Health checks:

  • target group-ul verifică periodic un endpoint, de exemplu /health, și nu trimite trafic către instanțele nesănătoase;
  • dacă ASG-ul folosește tipul de health check ELB, înlocuiește automat instanțele pe care ALB-ul le consideră nesănătoase. Cu tipul implicit EC2, ar înlocui doar instanțele căzute la nivel de hardware sau sistem;
  • health_check_grace_period oferă timp aplicației să pornească înainte de evaluare.

Scalare:

  • target tracking, de exemplu CPU mediu 60% sau ALBRequestCountPerTarget, varianta cea mai simplă și de obicei suficientă;
  • scalare programată pentru vârfuri previzibile;
  • scalare predictivă, bazată pe istoric.

Pentru actualizări, instance refresh înlocuiește treptat instanțele după schimbarea launch template-ului, cu un procent minim de instanțe sănătoase. Aplicația trebuie să fie fără stare: sesiunile în Redis sau DynamoDB, fișierele încărcate în S3. Altfel, orice instanță eliminată la scalare duce cu ea date ale utilizatorilor. Connection draining (deregistration delay) permite cererilor în curs să se termine.

Ce urmărește intervievatorul: Se verifică proiectarea unei arhitecturi clasice. Diferența între health check de tip EC2 și ELB este un detaliu pe care puțini îl știu.

83 Mid

Care e diferența dintre RDS Multi-AZ și read replicas? Când alegi RDS în loc de o bază de date instalată pe EC2?

Răspuns scurt: Multi-AZ ține o copie sincronă în altă zonă, pentru failover automat: e pentru disponibilitate, nu pentru performanță. Read replicas sunt copii asincrone care preiau citiri, pentru scalare. RDS e potrivit când vrei backup, patch-uri și failover gestionate.

Multi-AZ (în varianta clasică, cu o instanță standby):

  • fiecare scriere este replicată sincron într-o instanță standby din altă zonă;
  • standby-ul nu primește trafic;
  • la căderea instanței primare, a zonei sau la mentenanță, RDS mută automat endpoint-ul DNS spre standby, de obicei în una sau două minute;
  • aplicația trebuie să se reconecteze și să nu țină rezoluția DNS în cache la nesfârșit.

Există și varianta Multi-AZ cu două standby-uri care pot servi citiri, pentru anumite motoare.

Read replicas:

  • replicare asincronă, deci pot rămâne în urmă (replica lag);
  • au endpoint propriu; aplicația trimite explicit acolo citirile, de exemplu rapoartele;
  • pot fi în altă regiune și pot fi promovate ca bază primară, util pentru recuperare după dezastre;
  • o citire imediat după scriere poate să nu vadă încă datele noi, ceea ce aplicația trebuie să tolereze.

RDS față de EC2:

RDS oferă backup automat cu restaurare la un moment anume (point-in-time recovery), patch-uri, failover, monitorizare și scalarea stocării. În schimb, nu ai acces root la server, unele extensii sau setări nu sunt disponibile și costă mai mult decât o instanță EC2 echivalentă.

O bază de date pe EC2 se justifică pentru un motor sau o versiune pe care RDS nu le suportă, pentru acces la nivel de sistem de operare sau pentru configurații foarte speciale. În majoritatea cazurilor, timpul pe care l-ar cere operarea manuală (backup testat, replicare, upgrade-uri) costă mai mult decât diferența de preț. Aurora este o alternativă compatibilă MySQL și PostgreSQL, cu stocare distribuită.

Ce urmărește intervievatorul: Se verifică distincția disponibilitate versus scalare, o confuzie foarte frecventă. Intervievatorul apreciază mențiunea despre replica lag.

84 Senior

Factura AWS a crescut mult în ultimele luni. Cum abordezi optimizarea costurilor?

Răspuns scurt: Încep cu vizibilitatea: Cost Explorer pe servicii, conturi și tag-uri, ca să găsesc sursele creșterii. Apoi elimin resursele nefolosite, ajustez dimensiunile după utilizarea reală, folosesc Savings Plans pentru consumul stabil și Spot pentru sarcinile tolerante, și reduc transferul de date.

Fără date clare, optimizarea devine ghicit. Pașii pe care îi urmez:

Vizibilitate:

  • Cost Explorer grupat pe serviciu, cont, regiune și tip de utilizare; ce s-a schimbat și când;
  • tag-uri obligatorii (echipa, mediu, proiect) activate ca tag-uri de alocare a costurilor, ca să poți atribui costurile;
  • bugete și alerte (AWS Budgets, Cost Anomaly Detection) pentru a prinde creșterile din timp.

Resurse nefolosite (de obicei câștiguri rapide):

  • volume EBS neatașate, snapshot-uri vechi, IP-uri Elastic nefolosite, load balancere fără ținte;
  • medii de test care rulează noaptea și în weekend; programarea opririi lor;
  • loguri CloudWatch cu retenție nelimitată.

Dimensionare corectă: Compute Optimizer și metricile de utilizare arată instanțe și baze de date supradimensionate. Trecerea la generații noi sau la procesoare Graviton (ARM) oferă de obicei un raport preț-performanță mai bun, dacă aplicațiile rulează pe ARM.

Modelul de cumpărare:

  • Savings Plans sau Reserved Instances pentru consumul de bază, stabil, cu angajament pe unul sau trei ani;
  • instanțe Spot pentru workeri, CI și procesări în loturi, care tolerează întreruperi.

Transferul de date, adesea ignorat: trafic între AZ-uri, NAT Gateway pe volume mari (înlocuit parțial prin VPC endpoints pentru S3), ieșirea spre internet (CloudFront poate reduce costul).

Stocare: lifecycle rules în S3, volume gp3 în loc de gp2.

La nivel de organizație, cel mai mult contează cultura: echipele își văd costurile, iar costul devine o metrică de proiectare, nu o surpriză lunară. Practica se numește FinOps.

Ce urmărește intervievatorul: La senior se verifică abordarea sistematică și viziunea asupra organizației. Candidații slabi sar direct la „cumpărăm instanțe rezervate”.

85 Senior

Cum proiectezi recuperarea după dezastre pentru o aplicație critică? Ce înseamnă RTO și RPO?

Răspuns scurt: RTO este timpul maxim acceptat până la restabilirea serviciului, iar RPO este cantitatea maximă de date, exprimată în timp, pe care îți permiți să o pierzi. Din ele alegi strategia: backup și restaurare, pilot light, warm standby sau activ-activ, tot mai rapide și mai scumpe.

RPO (Recovery Point Objective): dacă e 15 minute, backup-urile sau replicarea trebuie să fie cel mult cu 15 minute în urmă. RTO (Recovery Time Objective): dacă e o oră, în maximum o oră serviciul trebuie să funcționeze din nou. Ambele sunt decizii de business, nu tehnice: prețul pentru valori mici crește rapid.

Strategii, în ordinea costului:

  • Backup și restaurare: backup-uri copiate în altă regiune (AWS Backup, snapshot-uri RDS și EBS copiate, replicare S3). La dezastru, recreezi infrastructura cu Terraform și restaurezi datele. RTO de ore, RPO egal cu frecvența backup-urilor. Cel mai ieftin.
  • Pilot light: în regiunea de rezervă există doar componentele critice, de exemplu baza de date replicată, iar restul se pornește la nevoie. RTO de zeci de minute.
  • Warm standby: o versiune redusă, dar funcțională a întregului sistem rulează permanent în regiunea secundară și se scalează la dezastru.
  • Activ-activ multi-regiune: ambele regiuni servesc trafic. RTO și RPO aproape de zero, dar complexitatea e mare, mai ales pentru datele scrise în ambele regiuni (conflicte, consistență).

Elemente comune:

  • infrastructura definită integral ca cod, altfel recrearea rapidă e imposibilă;
  • backup-uri protejate împotriva ștergerii (cont separat, AWS Backup Vault Lock), pentru că un atacator cu acces la cont le poate șterge;
  • DNS cu health checks și failover (Route 53);
  • teste regulate: un plan de recuperare netestat este doar o presupunere. Exerciții programate de restaurare, cu măsurarea timpului real.

Nu orice componentă are nevoie de același nivel: clasifici serviciile după impact și aplici strategia potrivită fiecăruia.

Ce urmărește intervievatorul: La senior se verifică legătura dintre cerințele de business și arhitectură. Testarea efectivă a restaurării este punctul pe care îl caută intervievatorul.

Monitorizare, logging și incidente (SRE)

86 Junior

Care e diferența dintre metrici, loguri și trace-uri? Ce înseamnă observabilitate?

Răspuns scurt: Metricile sunt valori numerice agregate în timp, bune pentru grafice și alerte. Logurile sunt evenimente detaliate, cu context. Trace-urile urmăresc o singură cerere prin mai multe servicii. Observabilitatea este capacitatea de a înțelege ce se întâmplă într-un sistem pe baza acestor date.

Cele trei tipuri de date răspund la întrebări diferite.

Metrici: numere cu etichete, măsurate periodic, de exemplu http_requests_total{status="500"} sau utilizarea CPU. Sunt ieftine de stocat, rapide de interogat și potrivite pentru dashboard-uri și alerte. Răspund la întrebarea „este ceva în neregulă și cât de grav?”. Nu spun de ce.

Loguri: evenimente individuale cu detalii: mesaj de eroare, ID-ul utilizatorului, parametri, stack trace. Răspund la „ce s-a întâmplat exact?”. Sunt scumpe la volume mari și greu de agregat dacă nu sunt structurate.

Trace-uri: o cerere primește un identificator, iar fiecare serviciu prin care trece înregistrează un span cu durata și detaliile lui. Rezultatul arată unde s-a pierdut timpul: de exemplu, din 2 secunde, 1,8 au fost într-un query la baza de date apelat din al treilea serviciu. Indispensabile în arhitecturile cu microservicii.

GET /comanda  1980 ms
 ├─ api-gateway        20 ms
 ├─ serviciu-comenzi 1950 ms
 │   ├─ SELECT produse 1800 ms
 │   └─ serviciu-plati  120 ms

Observabilitatea înseamnă că poți răspunde la întrebări despre sistem pe care nu le-ai anticipat, fără să adaugi cod nou. Monitorizarea clasică verifică probleme cunoscute; observabilitatea ajută la investigarea celor necunoscute.

Unelte uzuale: Prometheus și Grafana pentru metrici, Loki sau stiva Elastic pentru loguri, Jaeger sau Tempo pentru trace-uri, iar OpenTelemetry ca standard deschis pentru colectarea tuturor celor trei. În AWS, CloudWatch și X-Ray acoperă aceleași nevoi.

Ce urmărește intervievatorul: Se verifică noțiunile de bază ale monitorizării. Răspunsul bun spune la ce întrebare răspunde fiecare tip de date.

87 Junior

Ce metrici ai urmări pentru un serviciu web sau un API?

Răspuns scurt: Cele patru semnale de aur din cartea Google SRE: latența, traficul, erorile și saturația. Pentru serviciile bazate pe cereri, metoda RED (Rate, Errors, Duration) este o variantă simplă și echivalentă, completată de metrici de resurse.

Cele patru semnale de aur (golden signals):

  • Latența: cât durează cererile. Se urmăresc percentile (p50, p95, p99), nu doar media, care ascunde coada lentă: o medie de 100 ms poate coexista cu 5% din cereri peste 3 secunde. Latența cererilor eșuate se măsoară separat, pentru că o eroare rapidă poate scădea artificial media.
  • Traficul: cereri pe secundă, eventual pe endpoint.
  • Erorile: rata răspunsurilor 5xx, timeout-uri, dar și răspunsuri 200 cu conținut greșit, dacă le poți detecta.
  • Saturația: cât de „plin” e serviciul: CPU, memorie, conexiuni din pool folosite, lungimea cozilor, threaduri ocupate.

Exemple în PromQL, pentru o aplicație care expune histograme:

sum(rate(http_requests_total{job="api"}[5m]))
sum(rate(http_requests_total{job="api",status=~"5.."}[5m]))
  / sum(rate(http_requests_total{job="api"}[5m]))
histogram_quantile(0.99,
  sum by (le) (rate(http_request_duration_seconds_bucket{job="api"}[5m])))

Metoda RED (Rate, Errors, Duration) se aplică serviciilor, iar metoda USE (Utilization, Saturation, Errors) resurselor: discuri, rețea, CPU.

În plus, merită urmărite dependențele (latența și erorile bazei de date, ale API-urilor externe), metricile de business (comenzi plasate, plăți reușite), care detectează probleme invizibile tehnic, și evenimentele de deploy afișate pe grafice, ca să corelezi regresiile cu lansările.

Contează ca metricile să reflecte experiența utilizatorului. Un server cu CPU la 20% care răspunde cu erori nu este sănătos.

Ce urmărește intervievatorul: Se verifică dacă știi ce contează pentru utilizator. Folosirea percentilelor în loc de medie este punctul pe care îl urmăresc mulți intervievatori.

88 Mid

Cum funcționează Prometheus? Care e diferența dintre un counter și un gauge?

Răspuns scurt: Prometheus colectează metrici prin pull: interoghează periodic endpoint-uri HTTP /metrics ale aplicațiilor și exporterelor și le salvează ca serii de timp. Un counter doar crește și se interpretează prin rata de creștere; un gauge urcă și coboară, arătând o valoare curentă.

Arhitectura:

  • aplicațiile expun metrici în format text la /metrics, folosind o bibliotecă client; pentru sisteme care nu știu asta există exporteri (node_exporter pentru Linux, postgres_exporter, blackbox_exporter pentru verificări HTTP din exterior);
  • Prometheus află țintele prin service discovery (Kubernetes, EC2, fișiere) și le interoghează la un interval, de exemplu 30 de secunde;
  • datele se stochează local ca serii de timp, identificate prin nume și etichete;
  • regulile de alertare se evaluează în Prometheus, iar Alertmanager grupează, deduplică și trimite notificările.

Tipuri de metrici:

  • Counter: crește monoton și se resetează la repornirea procesului. Exemple: cereri totale, erori totale. Valoarea brută nu spune mare lucru; folosești rate(), care tratează corect resetările.
  • Gauge: valoare care urcă și coboară: memorie folosită, conexiuni active, lungimea cozii.
  • Histogram: distribuie observațiile în intervale (buckets), permițând calculul percentilelor cu histogram_quantile.
  • Summary: percentile calculate în client, care nu se pot agrega corect între instanțe.
rate(http_requests_total[5m])         # cereri pe secundă, medie pe 5 minute
increase(errors_total[1h])            # câte erori într-o oră
avg_over_time(queue_depth[10m])       # pentru un gauge

O capcană importantă este cardinalitatea: fiecare combinație unică de etichete creează o serie nouă. O etichetă cu ID-ul utilizatorului sau cu URL-ul complet poate genera milioane de serii și poate bloca Prometheus. Etichetele trebuie să aibă un număr mic de valori posibile.

Pentru retenție lungă și mai multe clustere se adaugă Thanos, Mimir sau un serviciu gestionat.

Ce urmărește intervievatorul: Se verifică experiența practică cu monitorizarea. Folosirea rate() pe counter și problema cardinalității sunt detaliile cheie.

89 Mid

Ce sunt SLI, SLO, SLA și error budget?

Răspuns scurt: SLI este o măsură a calității serviciului, de exemplu procentul de cereri reușite. SLO este ținta internă pentru acel indicator, de exemplu 99,9% pe 30 de zile. SLA este angajamentul contractual față de clienți. Error budget-ul este diferența până la 100%.

SLI (Service Level Indicator): un raport între evenimente bune și totalul evenimentelor, măsurat cât mai aproape de utilizator. Exemple: cereri cu status non-5xx și răspuns sub 300 ms, împărțite la toate cererile.

SLO (Service Level Objective): ținta pe o fereastră de timp. Un SLO de 99,9% pe 30 de zile permite aproximativ 43 de minute de indisponibilitate totală pe lună (0,1% din 43.200 de minute).

SLA (Service Level Agreement): promisiunea contractuală, cu penalități sau credite dacă nu e respectată. Se setează mai relaxat decât SLO-ul intern, ca să ai marjă.

Error budget: dacă SLO-ul e 99,9%, bugetul este 0,1% din cereri. Ideea centrală din practica SRE: bugetul este o resursă de folosit, nu doar de protejat.

  • cât timp mai ai buget, echipa lansează rapid și își asumă riscuri;
  • dacă bugetul s-a consumat, prioritatea trece pe stabilitate: se încetinesc lansările riscante și se lucrează la fiabilitate.

Astfel conflictul dintre „vrem funcționalități” și „vrem stabilitate” devine o decizie bazată pe date, convenită dinainte.

Alertarea pe SLO se face pe burn rate, viteza cu care se consumă bugetul:

(
  sum(rate(http_requests_total{status=~"5.."}[1h]))
  / sum(rate(http_requests_total[1h]))
) > (14.4 * 0.001)

Un burn rate de 14,4 menținut o oră consumă aproximativ 2% din bugetul lunar, prag recomandat în cartea Google SRE pentru alertele urgente.

100% nu este o țintă realistă: fiecare „nouă” în plus costă mult, iar utilizatorii nu observă diferența dincolo de fiabilitatea propriei conexiuni la internet.

Ce urmărește intervievatorul: Se verifică înțelegerea practicii SRE dincolo de definiții. Intervievatorul caută ideea de buget care se poate cheltui.

90 Mid

Cum organizezi logging-ul centralizat pentru zeci de servicii?

Răspuns scurt: Aplicațiile scriu loguri structurate (JSON) la stdout, un agent pe fiecare nod le colectează și le trimite într-un sistem central (Loki, Elasticsearch/OpenSearch, CloudWatch), unde poți căuta după câmpuri. Fiecare cerere poartă un ID de corelare, iar retenția și volumul sunt controlate.

Fără centralizare, depanarea înseamnă SSH pe zece servere și grep în fișiere diferite, iar în Kubernetes logurile unui pod dispar odată cu el.

Format structurat: în loc de text liber, fiecare linie este un obiect JSON cu câmpuri constante.

{"ts":"2026-10-31T10:15:02Z","level":"error","service":"comenzi",
 "request_id":"7f3a9c","user_id":"u-1842","msg":"plata respinsă","provider_ms":2140}

Poți filtra apoi după service="comenzi" and level="error", fără expresii regulate fragile.

Colectare: în containere, aplicația scrie la stdout și stderr (principiul Twelve-Factor), iar runtime-ul salvează fluxul pe nod. Un agent rulat ca DaemonSet în Kubernetes (Fluent Bit, Vector, Promtail sau Grafana Alloy) citește fișierele, adaugă metadate (namespace, pod, imagine) și le trimite mai departe.

Stocare și căutare:

  • Loki indexează doar etichetele, deci e ieftin, dar căutarea în conținut e mai lentă;
  • Elasticsearch sau OpenSearch indexează tot conținutul: căutare puternică, cost mai mare;
  • serviciile gestionate (CloudWatch Logs, Datadog) reduc efortul operațional.

Corelare: un request_id sau trace_id generat la intrare și propagat prin antete între servicii permite reconstituirea drumului unei cereri. OpenTelemetry standardizează propagarea.

Control: nivelurile de log (DEBUG doar temporar), eșantionarea logurilor foarte frecvente, retenție diferită pe tipuri (de exemplu 14 zile pentru loguri de aplicație, mai mult pentru audit). Nu se loghează parole, token-uri, numere de card sau date personale inutile: logurile ajung la mulți oameni și trebuie tratate conform GDPR.

Ce urmărește intervievatorul: Se verifică arhitectura de logging și atenția la cost și la date personale. Logurile structurate și ID-ul de corelare sunt esențiale.

91 Senior

Ce face o alertă să fie bună? Cum eviți oboseala de alertare (alert fatigue)?

Răspuns scurt: O alertă bună e declanșată de un simptom care afectează utilizatorii, cere o acțiune umană acum, este rară și vine cu un runbook. Eviți oboseala eliminând alertele fără acțiune, alertând pe SLO în loc de cauze și separând paginile urgente de notificările informative.

Dacă un om este trezit noaptea de o alertă care nu cere nimic de la el, a doua oară o va ignora, iar a zecea oară va rata o alertă reală. Oboseala de alertare este o problemă de fiabilitate, nu de confort.

Principii:

  • Alertezi pe simptome, nu pe cauze: „rata de erori la checkout a depășit pragul” este o alertă bună. „CPU peste 80% pe un nod” de obicei nu este: poate fi normal și nu afectează pe nimeni. Cauzele sunt utile pe dashboard-uri, pentru investigație.
  • Fiecare alertă urgentă cere o acțiune: dacă reacția corectă este „mă uit și aștept”, alerta nu trebuie să trezească pe nimeni.
  • Niveluri: pagini (telefon, imediat) pentru impact real și urgent; tichete sau mesaje pentru ce poate aștepta până dimineață, cum ar fi un certificat care expiră în 14 zile sau un disc care se va umple în trei zile.
  • Alertare pe SLO cu burn rate pe mai multe ferestre (rapidă și lentă), care reduce alarmele false provocate de vârfuri scurte.
  • Durată minimă: for: 5m în Prometheus, ca un vârf de câteva secunde să nu declanșeze alerta.
  • Runbook atașat: ce înseamnă alerta, cum verifici, ce pași de atenuare există, pe cine escaladezi.
  • Grupare și deduplicare în Alertmanager.
YAML
- alert: CheckoutErori
  expr: job:checkout_error_ratio:rate5m > 0.02
  for: 5m
  labels: {severity: page}
  annotations:
    summary: "Peste 2% erori la checkout"
    runbook_url: "https://wiki.intern/runbooks/checkout-erori"

Periodic, echipa revizuiește alertele: cele fără nicio acțiune se șterg sau se retrogradează.

Ce urmărește intervievatorul: La senior se verifică judecata despre ce merită alertat. Alertarea pe simptome și revizuirea periodică sunt ideile centrale.

92 Senior

Cum gestionezi un incident major în producție, de la alertă până la postmortem?

Răspuns scurt: Confirm impactul, declar incidentul și stabilesc roluri: un incident commander care coordonează, oameni care investighează și cineva care comunică. Prioritatea este atenuarea (rollback, failover, scoaterea traficului), nu cauza. După rezolvare urmează un postmortem fără vinovați, cu acțiuni urmărite.

Detectare și declarare: alerta sau un raport de la utilizatori. Verifici rapid impactul: cine e afectat, cât de grav. Dacă e semnificativ, declari incidentul pe canalul stabilit, cu un nivel de severitate. Este mai bine să declari prea devreme decât prea târziu.

Roluri (inspirate din Incident Command System):

  • Incident commander: coordonează, decide, ține evidența; nu se apucă el însuși de depanare;
  • operațiuni: oamenii care investighează și aplică remedieri;
  • comunicare: actualizări regulate către echipele interne, suport, pagina de status, la intervale fixe, chiar și când nu există noutăți;
  • un jurnal cronologic al evenimentelor și deciziilor, cu ore.

Atenuare înaintea cauzei: întrebarea „ce s-a schimbat?” duce adesea direct la soluție. Rollback la versiunea anterioară, dezactivarea unui feature flag, failover, scalare, blocarea traficului abuziv. Investigația completă vine după ce utilizatorii nu mai sunt afectați.

Rezolvare: confirmi revenirea pe metrici, nu pe impresii, și monitorizezi o perioadă.

Postmortem, în câteva zile:

  • cronologia, impactul, detectarea (cât a durat până am aflat), cauzele;
  • fără vinovați (blameless): întrebarea nu este „cine a greșit”, ci „de ce sistemul a permis greșeala și de ce nu am prins-o mai devreme”. Oamenii care se tem de pedeapsă ascund informații;
  • acțiuni concrete, cu responsabil și termen, urmărite ca orice altă muncă: teste lipsă, alerte noi, protecții în pipeline, runbook-uri actualizate;
  • distribuit larg, ca și alte echipe să învețe.

Măsurile de interes pe termen lung sunt timpul de detectare și timpul de restabilire, plus frecvența incidentelor care se repetă.

Ce urmărește intervievatorul: La senior se verifică maturitatea operațională. Intervievatorul caută separarea rolurilor, atenuarea înaintea cauzei și cultura fără vinovați.

93 Senior

Ce este toil și cum faci ca turele de on-call ale echipei să fie sustenabile?

Răspuns scurt: Toil este munca operațională manuală, repetitivă, automatizabilă și fără valoare durabilă, care crește odată cu sistemul. O reduci prin automatizare și eliminarea cauzelor. On-call-ul devine sustenabil cu rotații echitabile, alerte puține și relevante, runbook-uri și timp alocat pentru reparații după ture.

Cartea Google SRE definește toil ca muncă manuală, repetitivă, automatizabilă, reactivă, fără valoare de durată și care crește liniar cu serviciul. Exemple: rotirea manuală a certificatelor, restartarea unui serviciu care cade periodic, crearea manuală de conturi sau medii, curățarea discurilor pline.

În cantități mici e acceptabil, dar dacă ocupă mult din timpul echipei, nu mai rămâne timp de îmbunătățiri. Ghidul Google propune ca toil-ul să nu depășească aproximativ jumătate din timpul unui inginer SRE.

Cum îl reduci:

  • îl măsori: echipa notează timpul petrecut pe sarcini repetitive și le clasează după frecvență și durată;
  • elimini cauza, nu doar simptomul: un serviciu care cade la două zile are nevoie de o reparație, nu de un script de restart mai bun;
  • automatizezi cu protecții: self-service pentru dezvoltatori (crearea unui mediu dintr-un template), reînnoirea automată a certificatelor, autoscalare;
  • refuzi procesele noi care adaugă toil fără justificare.

On-call sustenabil:

  • rotații cu suficienți oameni ca fiecare să aibă pauze lungi între ture, plus un nivel secundar pentru escaladare;
  • un volum de alerte urmărit ca metrică; dacă o tură are prea multe pagini, se discută și se acționează;
  • runbook-uri pentru fiecare alertă, ca oricine din rotație să se descurce;
  • timp de recuperare după nopțile grele și compensare clară;
  • dezvoltatorii serviciului participă la on-call sau la analiza alertelor, ca să simtă direct costul codului fragil.

Un on-call epuizant duce la plecări și la decizii proaste, deci este și o problemă de fiabilitate.

Ce urmărește intervievatorul: La senior se verifică grija pentru echipă și pentru sistem pe termen lung. Diferența dintre eliminarea cauzei și automatizarea simptomului e cheia.

Comportamentale și HR

94 Junior

De ce vrei să lucrezi în DevOps sau cloud?

Răspuns scurt: Un răspuns bun leagă motivația de lucruri concrete pe care le-ai făcut deja: ți-a plăcut să automatizezi, să faci sisteme care rulează fiabil, să înțelegi cum ajunge codul în producție. Arată că știi ce presupune rolul, inclusiv partea operațională și on-call-ul.

Intervievatorul vrea să afle dacă alegerea e informată sau doar o reacție la „DevOps e căutat”. Un răspuns structurat are trei părți:

  • Ce te-a atras, cu un exemplu concret: „Când am pus prima dată aplicația mea pe un server, partea care mi-a plăcut cel mai mult a fost să automatizez deploy-ul. Am scris un pipeline care rula testele, construia imaginea și o lansa. Am înțeles că mă interesează mai mult cum rulează sistemele decât funcționalitățile în sine.”
  • Ce ai făcut ca să te pregătești: cursuri, un homelab, proiecte personale, certificări, contribuții. Detaliile contează: „am un cluster k3s pe două mașini virtuale, cu Argo CD și monitorizare cu Prometheus” e mult mai convingător decât „am învățat Kubernetes”.
  • De ce acest rol, la această firmă: ce ai aflat despre produsul și infrastructura lor, din anunț, din blogul tehnic sau din prezentări publice.

Arată că înțelegi și părțile mai puțin strălucitoare: depanare sub presiune, documentare, on-call, munca de a face lucrurile plictisitoare să fie fiabile. Un candidat care spune „îmi place să înțeleg de ce pică lucrurile” sună mai credibil decât unul care vorbește doar despre unelte la modă.

Evită răspunsurile care pun accentul doar pe salariu sau pe ideea că DevOps „nu e programare”. În realitate rolul cere mult cod: scripturi, IaC, pipeline-uri, uneori unelte interne în Python sau Go. Dacă vii din altă meserie (suport, administrare, dezvoltare), prezintă experiența anterioară ca avantaj.

Ce urmărește intervievatorul: Se verifică motivația și cât de bine înțelegi rolul. Răspunsurile generice, fără exemple concrete, sunt cea mai frecventă greșeală.

95 Junior

Povestește-ne despre un proiect personal de infrastructură pe care l-ai construit.

Răspuns scurt: Alege un proiect pe care îl poți explica în detaliu: ce problemă rezolva, ce arhitectură ai ales și de ce, ce a mers prost și cum ai rezolvat, ce ai face diferit acum. Intervievatorul vrea să vadă raționamentul, nu doar lista de tehnologii.

La nivel de junior, proiectele personale țin locul experienței profesionale, deci merită pregătite atent. Structura recomandată:

  • Contextul și scopul: „Am vrut să găzduiesc aplicația mea și un blog pe un VPS, cu deploy automat și HTTPS.”
  • Arhitectura și deciziile: „Am folosit Docker Compose cu nginx ca reverse proxy și certificate Let's Encrypt. Am ales Compose în loc de Kubernetes pentru că aveam un singur server și voiam ceva ce pot opera singur. Infrastructura am scris-o în Terraform, iar configurarea serverului cu un script cloud-init.”
  • Automatizarea: „La fiecare push pe main, GitHub Actions rulează testele, construiește imaginea, o publică în GHCR și face deploy prin SSH cu un utilizator dedicat, cu permisiuni limitate.”
  • Problema reală întâlnită: „După o lună discul s-a umplut din cauza imaginilor vechi și a logurilor. Am adăugat curățarea imaginilor în pipeline, limite de log în Docker și o alertă la 80% ocupare.”
  • Ce ai învățat și ce ai schimba: „Aș separa baza de date pe un serviciu gestionat și aș face backup-uri testate; inițial le făceam, dar nu verificasem niciodată restaurarea.”

Pregătește-te pentru întrebările de aprofundare: de ce ai ales X și nu Y, ce se întâmplă dacă pică serverul, unde ții secretele, cum faci rollback. Intervievatorii pun aceste întrebări tocmai ca să vadă dacă ai construit efectiv proiectul.

Dacă proiectul e public pe GitHub, cu un README care explică arhitectura și pașii de rulare, menționează-l. Un proiect mic, dar înțeles complet, valorează mai mult decât unul ambițios copiat dintr-un tutorial.

Ce urmărește intervievatorul: Se verifică experiența practică și capacitatea de a explica decizii. Candidații care nu pot răspunde la întrebările „de ce” pierd puncte rapid.

96 Junior

Cum înveți o tehnologie nouă pe care nu ai mai folosit-o, atunci când proiectul o cere repede?

Răspuns scurt: Pornești de la documentația oficială și de la un exemplu minim care funcționează, apoi îl aplici pe problema reală, cu pași mici. Înveți întâi conceptele, ceri feedback devreme și documentezi ce afli pentru echipă.

În DevOps uneltele se schimbă des, deci capacitatea de a învăța repede este evaluată explicit. Un răspuns convingător descrie un proces și îl ilustrează cu un exemplu real.

Un proces bun:

  • Înțeleg problema pe care o rezolvă unealta: de ce există Helm, ce problemă rezolvă Argo CD, de ce cineva a ales această unealtă.
  • Documentația oficială și ghidul de pornire rapidă, înaintea tutorialelor aleatoare, care pot fi învechite.
  • Un exemplu minim funcțional într-un mediu local sau de test: un cluster kind, un cont de test, un container.
  • Aplicarea pe problema reală, treptat, cu verificări la fiecare pas.
  • Feedback devreme de la un coleg cu experiență, înainte să construiesc mult peste o abordare greșită.
  • Notițe și documentare pentru echipă: un README sau o pagină internă cu ce am învățat.

Exemplu de formulare: „La ultimul proiect trebuia să adăugăm monitorizare cu Prometheus, pe care nu îl folosisem. În prima zi am citit conceptele de bază și am pornit Prometheus cu Grafana local, în Docker Compose. A doua zi am instrumentat un endpoint și am făcut primul dashboard. Am cerut review unui coleg, care m-a avertizat despre cardinalitatea etichetelor; aveam ID-ul utilizatorului ca etichetă. Până la finalul săptămânii aveam metricile principale și o alertă, plus o pagină de documentație.”

Este în regulă să spui ce nu știi încă, cu condiția să arăți cum ai afla. „Nu am lucrat cu Pulumi, dar am folosit Terraform și aș începe prin a compara modelul lor de state” este un răspuns bun.

Ce urmărește intervievatorul: Se verifică autonomia și metoda de învățare. Răspunsurile vagi de tipul „mă uit pe YouTube” sunt slabe; contează procesul și exemplul.

97 Junior

Ce întrebări ai pentru noi?

Răspuns scurt: Pune întrebări care te ajută să înțelegi cum lucrează echipa: cum arată un deploy, cum e organizat on-call-ul, ce probleme de infrastructură au acum, cum arată primele luni pentru un junior. Ele arată interes real și te ajută să decizi.

Interviul merge în ambele sensuri, iar la final intervievatorul observă dacă te-ai gândit la rol. „Nu am întrebări” transmite lipsă de interes.

Întrebări utile pentru un rol DevOps sau cloud:

  • Despre infrastructură: „Ce rulează acum în producție și unde? Folosiți Kubernetes, ECS, mașini virtuale?” sau „Câtă infrastructură este gestionată ca cod și cât s-a făcut manual?”
  • Despre procesul de livrare: „Cum arată drumul unei schimbări de la commit la producție? Cât de des faceți deploy?”
  • Despre operare: „Cum e organizat on-call-ul? Cât de des sunt alerte în afara programului? Faceți postmortem-uri după incidente?”
  • Despre echipă: „Cum colaborați cu echipele de dezvoltare? Ei își operează serviciile sau le operați voi?”
  • Despre rol: „Care ar fi primele proiecte pentru mine? Cum arată primele trei luni? Cine m-ar îndruma?”
  • Despre provocări: „Care este cea mai mare problemă tehnică pe care vreți să o rezolvați anul acesta?”

Răspunsurile îți dau informații reale. Dacă afli că nu există infrastructură ca cod, nici postmortem-uri, iar on-call-ul îl face o singură persoană, știi la ce să te aștepți. O echipă care descrie deschis problemele sale este, de obicei, un semn bun.

Câteva sfaturi: pregătește 4–5 întrebări și pune două sau trei, în funcție de timp; evită întrebările la care răspunsul e pe prima pagină a site-ului firmei; întrebările despre salariu și beneficii se discută de obicei cu recruiter-ul, în etapa potrivită. Poți încheia întrebând care sunt pașii următori în proces.

Ce urmărește intervievatorul: Se verifică interesul real și maturitatea profesională. Lipsa întrebărilor sau întrebările generice lasă o impresie slabă.

98 Mid

Povestește despre cel mai greu incident sau bug de infrastructură pe care l-ai investigat.

Răspuns scurt: Folosește structura STAR: situația și impactul, rolul tău, pașii concreți de investigare cu ipotezele eliminate, rezultatul și ce s-a schimbat după. Insistă pe raționament și pe măsurile care au prevenit repetarea, nu doar pe soluția finală.

Este una dintre cele mai importante întrebări comportamentale pentru DevOps, pentru că arată exact cum gândești sub presiune.

Structura STAR:

  • Situația: contextul și impactul. „Aplicația principală avea erori 502 intermitente, în jur de 1% din cereri, doar în orele de vârf. Durase deja câteva zile și echipa de suport primea plângeri.”
  • Sarcina: rolul tău. „Am preluat investigația din partea echipei de platformă.”
  • Acțiunile, cu ipotezele și cum le-ai testat:
  • „Am corelat erorile cu deploy-urile; nu exista legătură.”
  • „Logurile load balancer-ului arătau că erorile veneau de la conexiuni închise de backend.”
  • „Am observat că timeout-ul keep-alive al aplicației era mai mic decât timeout-ul de inactivitate al load balancer-ului. Load balancer-ul refolosea o conexiune pe care aplicația tocmai o închisese.”
  • „Am reprodus problema în staging, cu un test de încărcare, înainte de a schimba ceva în producție.”
  • Rezultatul: „Am mărit timeout-ul keep-alive al aplicației peste cel al load balancer-ului; erorile au dispărut. Am documentat setarea în template-ul comun al serviciilor și am adăugat o alertă pe rata de 502.”

Ce face răspunsul puternic:

  • ipotezele sunt eliminate cu date, nu prin ghicit;
  • recunoști pașii greșiți: „inițial am crezut că e o problemă de resurse și am pierdut o zi cu scalarea”;
  • explici ce s-a schimbat sistemic, ca problema să nu se repete și la alte servicii;
  • menționezi colaborarea și comunicarea în timpul investigației.

Pregătește dinainte două povești de acest tip, cu detalii tehnice pe care le poți aprofunda dacă ți se cere.

Ce urmărește intervievatorul: Se verifică metoda de depanare și onestitatea. Poveștile fără detalii tehnice verificabile sau fără lecții învățate sunt neconvingătoare.

99 Mid

Spune-ne despre o greșeală pe care ai făcut-o în producție. Ce s-a întâmplat și ce ai făcut?

Răspuns scurt: Alege o greșeală reală, cu impact moderat, și descrie-o cinstit: ce ai făcut, cum ai observat, cum ai limitat impactul și ai comunicat, apoi ce ai schimbat în proces ca să nu se mai poată întâmpla. Accentul cade pe responsabilitate și pe îmbunătățirea sistemului.

Intervievatorul nu caută candidați care nu greșesc, pentru că aceștia nu există. Caută oameni care își asumă greșeala, reacționează calm și repară cauza. A spune că nu ai greșit niciodată este un semnal de alarmă.

Structură:

  • Ce s-a întâmplat, fără a minimiza: „Am rulat o modificare Terraform pentru security groups și nu am citit atent planul. O regulă a fost înlocuită, iar timp de câteva minute serviciul intern de rapoarte nu s-a mai putut conecta la baza de date.”
  • Cum ai observat: „Alerta pe rata de erori a pornit după două minute.”
  • Reacția imediată: „Am anunțat în canalul echipei că e de la modificarea mea, ca nimeni să nu piardă timp căutând altă cauză, și am reaplicat versiunea anterioară. Serviciul și-a revenit în aproximativ zece minute.”
  • Ce ai schimbat ulterior: „Am propus ca planul Terraform să fie afișat automat în pull request și ca înlocuirile de resurse critice să ceară aprobare explicită. Am adăugat create_before_destroy pentru regulile respective, iar aplicarea în producție s-a mutat exclusiv în pipeline.”
  • Lecția: o formulare scurtă despre ce faci diferit acum.

Puncte importante:

  • comunicarea rapidă și deschisă a contat la fel de mult ca soluția tehnică;
  • soluția finală privește procesul, nu „voi fi mai atent”, care nu este o măsură verificabilă;
  • tonul este calm și matur, fără să dai vina pe alții sau pe unealtă.

Alege o greșeală al cărei impact a fost limitat și pentru care ai o poveste completă, cu final constructiv.

Ce urmărește intervievatorul: Se verifică asumarea responsabilității și mentalitatea de îmbunătățire. „Voi fi mai atent” ca singură concluzie este un răspuns slab.

100 Mid

Un dezvoltator senior vrea să facă deploy vineri seara, ocolind pipeline-ul, pentru o funcționalitate urgentă. Cum procedezi?

Răspuns scurt: Înțeleg întâi urgența reală și riscul, apoi caut o variantă sigură care să răspundă nevoii: pipeline-ul normal accelerat, un feature flag, un deploy controlat cu cineva disponibil pentru rollback. Dacă rămânem în dezacord, escaladez decizia la cine o poate lua, cu riscurile scrise.

Întrebarea verifică dacă poți ține la principii fără să devii un obstacol și dacă știi să rezolvi un conflict cu cineva mai senior.

Un răspuns structurat:

  • Ascult și clarific: „Ce se întâmplă dacă așteptăm până luni? E un client care pierde bani, o obligație legală, o demonstrație?” Uneori urgența e reală, alteori dispare la a doua întrebare.
  • Explic riscul concret, nu regula: „Pipeline-ul rulează testele și scanările care ne-au prins regresii; fără el nu avem nici artefact trasabil, nici rollback rapid. Vineri seara sunt mai puțini oameni disponibili dacă ceva nu merge.” Argumentele despre risc convin mai mult decât „așa e procesul”.
  • Propun alternative:
  • pipeline-ul normal, cu prioritate și review rapid;
  • lansare în spatele unui feature flag, activată pentru un grup mic;
  • deploy cu canary sau într-un interval în care suntem amândoi disponibili o oră după;
  • un plan de rollback clar înainte de lansare.
  • Dacă dezacordul rămâne: nu ocolesc singur regulile și nici nu blochez în tăcere. Escaladez la responsabilul tehnic sau la managerul care poate accepta riscul, cu opțiunile și riscurile scrise. Decizia de a accepta un risc de producție ține de business, nu de o dispută între doi ingineri.
  • După: dacă pipeline-ul a fost perceput ca obstacol, merită discutat de ce. Poate e prea lent sau există nevoia unui proces documentat pentru hotfix-uri urgente.

Tonul contează: colaborativ, nu „poliția deploy-urilor”. Scopul comun este ca funcționalitatea să ajungă la clienți fără un incident în weekend.

Ce urmărește intervievatorul: Se verifică abilitățile de comunicare și judecata sub presiune. Atât refuzul rigid, cât și cedarea fără discuție sunt răspunsuri slabe.

Întrebări de interviu pe tehnologii

Pregătire de interviu pentru alte meserii

Exerciții rezolvate pentru DevOps / Cloud Engineer

← 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 DevOps / Cloud Engineer, de la junior la mid, iar pe JoburiIT.ro îți poți certifica apoi cunoștințele.

De la întrebări la primul job de DevOps / Cloud Engineer

Traseul de carieră îți pune cursurile în ordine, cu exerciții verificate automat și proiecte despre care poți vorbi la interviu. Primele lecții sunt gratuite.