...
Pregătire interviuri

100 de întrebări de interviu pentru Database Administrator (PostgreSQL), cu răspunsuri

Întrebările care apar des la interviurile de Database Administrator (PostgreSQL), 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
  • 180 minde citit
Întrebări de interviu Database Administrator (PostgreSQL) cu răspunsuri

Un proces de interviu pentru un post de Database Administrator are de obicei trei-patru etape: o discuție inițială cu recrutorul, unul sau două interviuri tehnice și, des, un exercițiu practic. Exercițiul poate fi o sesiune live în care scrii interogări SQL, citești un plan de execuție și propui un index, sau un scenariu de depanare: serverul e lent, discul se umple, o replică a rămas în urmă, un coleg a șters date din greșeală. La multe firme urmează și o discuție despre ture de gardă, incidente și felul în care comunici cu echipele de dezvoltare când ceva nu merge.

La nivel de junior se verifică fundamentul: SQL fără greșeli, chei primare și străine, indecși și EXPLAIN, tranzacții, roluri și drepturi, backup cu pg_dump și noțiuni de bază despre Linux. Nu se așteaptă să fi administrat clustere mari, ci să înțelegi de ce există fiecare mecanism și să lucrezi atent. La nivel mid apar MVCC și VACUUM în detaliu, recuperarea la un moment anume, replicarea, PgBouncer, upgrade-urile de versiune și optimizarea interogărilor grele, iar la senior arhitectura de disponibilitate ridicată, strategia de backup față de RPO și RTO, migrările mari și gestionarea incidentelor. Multe anunțuri din România cer Oracle sau SQL Server; conceptele de aici se transferă direct, iar întrebările despre cum ai învăța un sistem nou apar des.

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ă. Rulează comenzile într-un PostgreSQL pornit în Docker: la interviurile de DBA diferența o face cine a făcut efectiv un backup, o restaurare sau o replică, nu cine a memorat definițiile.

SQL: interogări de bază și avansate

1 Junior

În ce ordine se execută logic clauzele unei interogări SELECT?

Răspuns scurt: Logic, ordinea este FROM și JOIN, WHERE, GROUP BY, HAVING, SELECT, DISTINCT, ORDER BY și la final LIMIT/OFFSET. De aceea un alias definit în SELECT nu poate fi folosit în WHERE.

Interogarea se scrie începând cu SELECT, dar baza de date o evaluează logic în altă ordine:

  • FROM și JOIN: se construiește setul de rânduri din tabele.
  • WHERE: se filtrează rândurile individuale.
  • GROUP BY: rândurile rămase se grupează.
  • HAVING: se filtrează grupurile.
  • SELECT: se calculează coloanele și expresiile, inclusiv window functions.
  • DISTINCT: se elimină duplicatele.
  • ORDER BY: se sortează rezultatul.
  • LIMIT / OFFSET: se taie rezultatul.
SQL
-- Greșit: alias-ul total nu există încă în WHERE
SELECT client_id, SUM(valoare) AS total
FROM comenzi
WHERE total > 1000          -- eroare: column "total" does not exist
GROUP BY client_id;

-- Corect: condiția pe agregat merge în HAVING
SELECT client_id, SUM(valoare) AS total
FROM comenzi
GROUP BY client_id
HAVING SUM(valoare) > 1000
ORDER BY total DESC;        -- aici alias-ul e permis

Ordinea este logică, nu fizică: optimizatorul PostgreSQL poate muta filtrele, poate alege alt tip de join sau poate folosi un index care face sortarea inutilă. Rezultatul trebuie însă să fie identic cu cel al ordinii logice. Pentru un DBA, înțelegerea acestei ordini ajută la citirea planurilor de execuție: vezi în EXPLAIN că filtrul din WHERE apare jos, lângă scanarea tabelului, iar sortarea sus.

Ce urmărește intervievatorul: Se verifică dacă înțelegi SQL-ul ca model de procesare, nu ca șir de cuvinte memorate. Greșeala tipică este folosirea unui alias sau a unui agregat în WHERE.

2 Junior

Care este diferența dintre WHERE și HAVING?

Răspuns scurt: WHERE filtrează rândurile înainte de grupare, HAVING filtrează grupurile după agregare. Condițiile pe coloane simple merg în WHERE, cele pe SUM, COUNT sau AVG în HAVING.

WHERE acționează asupra fiecărui rând, înainte ca rândurile să fie grupate. Nu poate folosi funcții de agregare, pentru că în acel moment grupurile nu există încă. HAVING acționează după GROUP BY și primește grupurile cu valorile lor agregate.

SQL
-- Clienții din Cluj care au cheltuit peste 5.000 de lei în 2026
SELECT c.id, c.nume, SUM(o.valoare) AS total
FROM clienti c
JOIN comenzi o ON o.client_id = c.id
WHERE c.oras = 'Cluj'                      -- filtru pe rânduri
  AND o.data >= DATE '2026-01-01'
GROUP BY c.id, c.nume
HAVING SUM(o.valoare) > 5000;               -- filtru pe grupuri

Tehnic, poți pune și condiții fără agregare în HAVING (de exemplu HAVING c.oras = 'Cluj'), iar rezultatul poate fi același. Este însă o practică proastă: rândurile sunt grupate degeaba și filtrate abia la final. Optimizatorul PostgreSQL mută uneori singur astfel de condiții, dar nu te baza pe asta.

Regula simplă: filtrează cât mai devreme, în WHERE, tot ce se poate, ca baza de date să lucreze cu mai puține rânduri. Păstrează în HAVING doar condițiile care au nevoie de agregat. Un filtru timpuriu permite și folosirea indecșilor, lucru imposibil pe o valoare calculată după grupare.

Ce urmărește intervievatorul: Este o întrebare de încălzire care arată rapid dacă ai scris efectiv interogări cu agregări. Intervievatorul apreciază când menționezi și impactul asupra performanței.

3 Junior

Explică tipurile de JOIN: INNER, LEFT, RIGHT, FULL OUTER și CROSS.

Răspuns scurt: INNER păstrează doar rândurile cu potrivire în ambele tabele, LEFT păstrează tot din stânga, RIGHT tot din dreapta, FULL OUTER tot din ambele, iar CROSS face produsul cartezian.

Un JOIN combină rânduri din două tabele pe baza unei condiții.

  • INNER JOIN: doar perechile pentru care condiția este adevărată. Un client fără comenzi dispare din rezultat.
  • LEFT JOIN: toate rândurile din tabela din stânga; unde nu există potrivire, coloanele din dreapta sunt NULL.
  • RIGHT JOIN: simetric, toate rândurile din dreapta. În practică se rescrie aproape mereu ca LEFT JOIN, inversând tabelele, pentru lizibilitate.
  • FULL OUTER JOIN: toate rândurile din ambele părți, cu NULL unde lipsește perechea. Util la reconcilieri între două surse.
  • CROSS JOIN: fiecare rând cu fiecare rând (produs cartezian), fără condiție.
SQL
-- Toți clienții, cu numărul de comenzi (0 pentru cei fără comenzi)
SELECT c.nume, COUNT(o.id) AS nr_comenzi
FROM clienti c
LEFT JOIN comenzi o ON o.client_id = c.id
GROUP BY c.nume;

-- Clienții fără nicio comandă (anti-join)
SELECT c.*
FROM clienti c
LEFT JOIN comenzi o ON o.client_id = c.id
WHERE o.id IS NULL;

Observă COUNT(o.id) și nu COUNT(*): pentru un client fără comenzi, LEFT JOIN produce un rând cu o.id NULL, iar COUNT(*) l-ar număra ca 1. Pentru un DBA, contează și cum execută PostgreSQL join-ul: nested loop, hash join sau merge join, pe care le vezi în EXPLAIN și care depind de indecși și de numărul estimat de rânduri.

Ce urmărește intervievatorul: Intervievatorul verifică fundamentul SQL. Capcana clasică este COUNT(*) după un LEFT JOIN sau o condiție pe tabela din dreapta pusă în WHERE, care transformă LEFT JOIN în INNER JOIN.

4 Junior

Cum se comportă NULL în SQL și de ce WHERE coloana = NULL nu întoarce nimic?

Răspuns scurt: NULL înseamnă valoare necunoscută, iar orice comparație cu NULL dă rezultatul necunoscut, nu adevărat. Se testează cu IS NULL sau IS NOT NULL.

În SQL, NULL nu este zero și nici șir gol: înseamnă „valoare lipsă sau necunoscută”. Logica devine pe trei valori: adevărat, fals și necunoscut (UNKNOWN). Expresia x = NULL nu este niciodată adevărată, nici măcar când x este NULL, iar WHERE păstrează doar rândurile pentru care condiția este adevărată.

SQL
SELECT * FROM clienti WHERE telefon = NULL;      -- 0 rânduri, mereu
SELECT * FROM clienti WHERE telefon IS NULL;     -- corect

SELECT NULL = NULL;                -- NULL
SELECT NULL IS DISTINCT FROM NULL; -- false: comparație care tratează NULL ca valoare
SELECT COALESCE(telefon, 'fără telefon') FROM clienti;

Consecințe practice pe care un DBA le întâlnește des:

  • COUNT(*) numără toate rândurile, COUNT(coloana) doar valorile nenule.
  • SUM, AVG, MAX ignoră NULL-urile.
  • NOT IN (subinterogare) nu întoarce nimic dacă subinterogarea conține un singur NULL. Folosește NOT EXISTS.
  • Într-o constrângere UNIQUE, mai multe NULL-uri sunt permise implicit, pentru că nu sunt considerate egale. Din PostgreSQL 15 poți schimba asta cu UNIQUE NULLS NOT DISTINCT.
  • Un index B-tree obișnuit indexează și valorile NULL, deci IS NULL poate folosi indexul.

La proiectarea tabelelor, regula bună este să pui NOT NULL pe toate coloanele care trebuie să aibă mereu valoare. Asta previne date incomplete și simplifică interogările.

Ce urmărește intervievatorul: NULL este sursa multor bug-uri în rapoarte și aplicații. Intervievatorul vrea să vadă dacă știi capcana cu NOT IN și diferența dintre COUNT(*) și COUNT(coloană).

5 Junior

Ce sunt cheia primară și cheia străină? Ce se întâmplă când ștergi un rând referit de alt tabel?

Răspuns scurt: Cheia primară identifică unic fiecare rând și nu poate fi NULL. Cheia străină obligă o coloană să conțină doar valori existente în cheia altui tabel. La ștergere, comportamentul îl decide clauza ON DELETE.

O cheie primară (PRIMARY KEY) identifică unic fiecare rând: este UNIQUE și NOT NULL, iar PostgreSQL creează automat un index B-tree pe ea. O cheie străină (FOREIGN KEY) leagă un rând de unul din alt tabel și garantează integritatea referențială: nu poți avea o comandă pentru un client inexistent.

SQL
CREATE TABLE clienti (
  id    bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
  email text NOT NULL UNIQUE
);

CREATE TABLE comenzi (
  id         bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
  client_id  bigint NOT NULL REFERENCES clienti(id) ON DELETE RESTRICT,
  valoare    numeric(12,2) NOT NULL CHECK (valoare >= 0)
);
CREATE INDEX ON comenzi (client_id);   -- PostgreSQL NU îl creează automat

La ștergerea unui client referit, opțiunile ON DELETE sunt:

  • NO ACTION / RESTRICT (implicit): ștergerea eșuează.
  • CASCADE: se șterg și comenzile. Puternic, dar periculos pe date importante.
  • SET NULL sau SET DEFAULT: legătura se rupe, rândul rămâne.

Un detaliu important pentru DBA: PostgreSQL indexează automat cheia primară, dar nu și coloana cu cheia străină. Fără index pe comenzi.client_id, fiecare ștergere sau actualizare a cheii din clienti scanează tot tabelul comenzi ca să verifice referințele, iar join-urile sunt lente. Este una dintre primele verificări într-o bază de date moștenită.

Ce urmărește intervievatorul: Se verifică integritatea datelor și atenția la performanță. Mențiunea indexului lipsă pe cheia străină arată experiență reală cu PostgreSQL.

6 Junior

Care este diferența dintre DELETE, TRUNCATE și DROP TABLE?

Răspuns scurt: DELETE șterge rânduri, eventual filtrate, unul câte unul și declanșează triggere. TRUNCATE golește tot tabelul instant. DROP TABLE șterge tabelul cu totul, inclusiv structura.

Toate trei elimină date, dar la niveluri diferite:

  • DELETE: șterge rândurile care respectă condiția din WHERE. Fiecare rând este marcat ca șters (în PostgreSQL rămâne fizic până la VACUUM), se scrie în WAL, se execută triggerele ON DELETE și se verifică cheile străine. Pe milioane de rânduri este lent și umflă tabelul.
  • TRUNCATE: golește tabelul întreg dintr-o dată, alocând fișiere noi, goale. Este aproape instantaneu, eliberează imediat spațiul, nu execută triggerele pe rând. Eșuează dacă alte tabele au chei străine către el, cu excepția TRUNCATE ... CASCADE.
  • DROP TABLE: șterge tabelul, indecșii, constrângerile și drepturile. Structura dispare.
SQL
DELETE FROM sesiuni WHERE expira_la < now() - interval '30 days';
TRUNCATE TABLE import_temporar RESTART IDENTITY;
DROP TABLE IF EXISTS raport_vechi;

Un detaliu des întrebat: în PostgreSQL, și TRUNCATE, și DROP sunt tranzacționale. Le poți rula într-un BEGIN și le poți anula cu ROLLBACK, spre deosebire de alte sisteme. În schimb, TRUNCATE ia un lock ACCESS EXCLUSIVE, care blochează inclusiv citirile pe tabel până la finalul tranzacției.

Pentru ștergeri mari în producție, un DBA preferă de obicei să șteargă în loturi (de exemplu câte 10.000 de rânduri) sau, și mai bine, să folosească partiționarea și să elimine partiții întregi cu DROP sau DETACH PARTITION.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi impactul fiecărei comenzi asupra performanței, lock-urilor și recuperării. Faptul că TRUNCATE e tranzacțional în PostgreSQL surprinde mulți candidați.

7 Junior

Ce este o subinterogare corelată și când preferi EXISTS în locul lui IN?

Răspuns scurt: O subinterogare corelată folosește coloane din interogarea exterioară, deci se evaluează logic pentru fiecare rând. EXISTS este preferat la verificări de existență și este sigur cu NULL, spre deosebire de NOT IN.

O subinterogare obișnuită se poate evalua o singură dată. O subinterogare corelată face referire la un rând din interogarea exterioară, deci logic se reevaluează pentru fiecare rând.

SQL
-- Corelată: ultima comandă a fiecărui client
SELECT c.nume,
       (SELECT max(o.data) FROM comenzi o WHERE o.client_id = c.id) AS ultima
FROM clienti c;

-- Clienți care au cel puțin o comandă
SELECT * FROM clienti c
WHERE EXISTS (SELECT 1 FROM comenzi o WHERE o.client_id = c.id);

-- Clienți fără comenzi: NOT EXISTS, nu NOT IN
SELECT * FROM clienti c
WHERE NOT EXISTS (SELECT 1 FROM comenzi o WHERE o.client_id = c.id);

EXISTS se oprește la primul rând găsit și nu îi pasă ce coloane întoarce subinterogarea. PostgreSQL transformă de obicei EXISTS și IN în același plan de tip semi-join, deci la variantele pozitive diferența de performanță e mică.

Diferența mare apare la negație. NOT IN (SELECT client_id FROM comenzi) întoarce zero rânduri dacă subinterogarea conține un singur NULL, pentru că x NOT IN (1, NULL) este necunoscut, nu adevărat. În plus, PostgreSQL nu poate transforma NOT IN într-un anti-join eficient, iar pe tabele mari poate rula foarte lent. NOT EXISTS este corect și cu NULL și devine un anti-join rapid.

Ca DBA, când găsești în pg_stat_statements o interogare lentă cu NOT IN pe o subinterogare mare, rescrierea cu NOT EXISTS este una dintre cele mai simple optimizări.

Ce urmărește intervievatorul: Se verifică dacă știi capcana NOT IN cu NULL și dacă te gândești la planul de execuție, nu doar la sintaxă.

8 Junior

Ce este un CTE (WITH) și ce este un CTE recursiv?

Răspuns scurt: Un CTE este o subinterogare cu nume, definită înainte de interogarea principală, care face codul mai lizibil. Un CTE recursiv se referă la el însuși și parcurge structuri ierarhice, ca un arbore de categorii.

Un CTE (Common Table Expression) se definește cu WITH și funcționează ca un tabel temporar cu nume, valabil doar în acea interogare. Ajută la împărțirea unei interogări complicate în pași clari.

SQL
WITH vanzari_luna AS (
  SELECT client_id, SUM(valoare) AS total
  FROM comenzi
  WHERE data >= date_trunc('month', now())
  GROUP BY client_id
)
SELECT c.nume, v.total
FROM vanzari_luna v JOIN clienti c ON c.id = v.client_id
ORDER BY v.total DESC
LIMIT 10;

Un CTE recursiv are o parte de pornire și o parte care se referă la CTE-ul însuși, unite prin UNION ALL. Se repetă până nu mai apar rânduri noi.

SQL
-- Toți subordonații (direcți și indirecți) ai managerului cu id 7
WITH RECURSIVE echipa AS (
  SELECT id, nume, manager_id, 1 AS nivel
  FROM angajati WHERE id = 7
  UNION ALL
  SELECT a.id, a.nume, a.manager_id, e.nivel + 1
  FROM angajati a JOIN echipa e ON a.manager_id = e.id
)
SELECT * FROM echipa;

Un detaliu de performanță: până la PostgreSQL 12, orice CTE era o „barieră de optimizare”, calculat separat și materializat. Din versiunea 12, un CTE nerecursiv folosit o singură dată este integrat automat în interogarea principală. Poți controla explicit comportamentul cu WITH x AS MATERIALIZED (...) sau NOT MATERIALIZED. La un CTE recursiv, protejează-te de cicluri în date (de exemplu cu clauza CYCLE din PostgreSQL 14 sau cu o limită pe nivel).

Ce urmărește intervievatorul: Intervievatorul vrea să vadă că scrii SQL lizibil și că știi parcurgerea ierarhiilor. Mențiunea schimbării din PostgreSQL 12 arată că urmărești versiunile.

9 Junior

Ce sunt window functions? Dă un exemplu cu ROW_NUMBER().

Răspuns scurt: Window functions calculează o valoare pentru fiecare rând pe baza unui grup de rânduri înrudite, fără să le comprime într-un singur rând ca GROUP BY. Exemple: ROW_NUMBER, RANK, LAG, SUM() OVER.

O funcție de fereastră (window function) primește o „fereastră” de rânduri definită cu OVER (PARTITION BY ... ORDER BY ...) și întoarce o valoare pentru fiecare rând. Spre deosebire de GROUP BY, rândurile originale rămân în rezultat.

SQL
-- Ultima comandă a fiecărui client
SELECT *
FROM (
  SELECT o.*,
         ROW_NUMBER() OVER (PARTITION BY client_id ORDER BY data DESC) AS rn
  FROM comenzi o
) t
WHERE rn = 1;

-- Total cumulat pe zile și diferența față de ziua anterioară
SELECT zi, vanzari,
       SUM(vanzari) OVER (ORDER BY zi) AS cumulat,
       vanzari - LAG(vanzari) OVER (ORDER BY zi) AS diferenta
FROM vanzari_zilnice;

Funcții frecvente:

  • ROW_NUMBER(): numerotare unică, fără egalități.
  • RANK() și DENSE_RANK(): clasament, cu sau fără goluri la egalitate.
  • LAG() și LEAD(): valoarea din rândul anterior sau următor.
  • SUM(), AVG(), COUNT() cu OVER: totaluri cumulate sau medii mobile.

Funcțiile de fereastră se calculează după WHERE și GROUP BY, de aceea nu le poți filtra direct în WHERE și ai nevoie de o subinterogare sau un CTE. Pentru performanță, un index pe (client_id, data DESC) poate scuti PostgreSQL de sortare. Pentru varianta „ultimul rând pe grup”, PostgreSQL are și DISTINCT ON (client_id) ... ORDER BY client_id, data DESC, adesea mai simplă și la fel de rapidă.

Ce urmărește intervievatorul: Window functions apar în aproape orice interviu cu SQL. Un DBA trebuie să le înțeleagă și pentru că interogările analitice lente care ajung la el le folosesc des.

10 Junior

Care este diferența dintre UNION și UNION ALL?

Răspuns scurt: UNION combină rezultatele și elimină duplicatele, ceea ce cere o sortare sau un hash. UNION ALL le lipește pur și simplu și este mai rapid. Folosește UNION doar când chiar ai nevoie de deduplicare.

Ambele operații pun una sub alta rezultatele a două interogări cu același număr de coloane și tipuri compatibile.

  • UNION elimină rândurile duplicate din rezultatul final. Pentru asta, PostgreSQL trebuie să sorteze sau să construiască un hash pe toate rândurile, ceea ce costă memorie (work_mem) și timp.
  • UNION ALL păstrează toate rândurile, inclusiv duplicatele, fără niciun pas suplimentar.
SQL
-- Toate adresele de e-mail din două surse, fără duplicate
SELECT email FROM clienti
UNION
SELECT email FROM abonati_newsletter;

-- Comenzile din tabelul curent și din arhivă, care nu se suprapun
SELECT id, data, valoare FROM comenzi
UNION ALL
SELECT id, data, valoare FROM comenzi_arhiva;

În planul de execuție, UNION apare ca un nod Append urmat de HashAggregate sau Sort + Unique. Pe milioane de rânduri, acest pas poate ajunge să scrie fișiere temporare pe disc, iar în EXPLAIN (ANALYZE) vezi external merge sau Disk.

Regula practică: pornește cu UNION ALL și treci la UNION doar când duplicatele sunt posibile și nedorite. Când știi din logica datelor că seturile nu se suprapun (ca în exemplul cu arhiva), UNION doar consumă resurse. Există și INTERSECT (rândurile comune) și EXCEPT (rândurile din primul set care lipsesc din al doilea), utile la verificarea unei migrări de date.

Ce urmărește intervievatorul: Este o întrebare scurtă, dar intervievatorul urmărește dacă te gândești la costul deduplicării. Mulți candidați folosesc UNION din reflex.

11 Mid

Cum faci un „upsert” în PostgreSQL? Ce diferență este între INSERT ... ON CONFLICT și MERGE?

Răspuns scurt: INSERT ... ON CONFLICT inserează un rând sau, dacă încalcă o constrângere unică, îl actualizează ori îl ignoră, atomic. MERGE (din PostgreSQL 15) sincronizează un tabel cu o sursă, cu ramuri pentru potrivire și lipsă de potrivire.

„Upsert” înseamnă inserează dacă nu există, actualizează dacă există. Varianta naivă (un SELECT urmat de INSERT sau UPDATE) are o condiție de cursă: două sesiuni pot vedea simultan că rândul lipsește și pot încerca amândouă să-l insereze.

PostgreSQL rezolvă asta atomic cu ON CONFLICT, care are nevoie de o constrângere unică sau de un index unic:

SQL
INSERT INTO stoc (produs_id, depozit_id, cantitate)
VALUES (42, 3, 10)
ON CONFLICT (produs_id, depozit_id)
DO UPDATE SET cantitate = stoc.cantitate + EXCLUDED.cantitate,
              actualizat_la = now();

-- Ignoră duplicatele la un import
INSERT INTO evenimente (id, payload) VALUES (...)
ON CONFLICT (id) DO NOTHING;

EXCLUDED este rândul pe care ai încercat să-l inserezi. Instrucțiunea garantează că rezultatul este fie un insert, fie un update, chiar și sub concurență mare.

MERGE, standard SQL și disponibil din PostgreSQL 15, compară un tabel țintă cu o sursă (tabel, subinterogare) și permite mai multe ramuri:

SQL
MERGE INTO produse p
USING import_produse i ON p.cod = i.cod
WHEN MATCHED AND i.sters THEN DELETE
WHEN MATCHED THEN UPDATE SET pret = i.pret
WHEN NOT MATCHED THEN INSERT (cod, pret) VALUES (i.cod, i.pret);

Diferența practică: ON CONFLICT este construit special pentru concurență și se bazează pe un index unic, fiind alegerea potrivită în aplicații. MERGE este mai flexibil la sincronizări în loturi, dar sub concurență poate întoarce erori de cheie duplicată, pe care trebuie să le tratezi sau să le eviți prin lock-uri.

Ce urmărește intervievatorul: Se verifică dacă știi să eviți condițiile de cursă la nivelul bazei de date. Întrebarea apare des când echipa migrează cod de pe alt sistem care folosea MERGE.

12 Mid

Ce tipuri de date folosești pentru bani, date calendaristice și identificatori în PostgreSQL? Ce greșeli vezi des?

Răspuns scurt: Pentru bani numeric(p,s), nu float sau money; pentru momente în timp timestamptz; pentru identificatori bigint cu IDENTITY sau uuid. Greșelile tipice sunt float pentru sume, timestamp fără fus orar și int care se umple.

Alegerea tipurilor de date afectează corectitudinea, spațiul pe disc și performanța, iar schimbarea lor mai târziu, pe un tabel mare, poate cere rescrierea întregului tabel.

Bani: numeric(12,2) păstrează exact valorile zecimale. real și double precision sunt aproximative (0.1 + 0.2 nu dă exact 0.3), deci nepotrivite pentru sume. Tipul money depinde de setarea lc_monetary și creează probleme la import și export.

Timp: timestamptz (timestamp with time zone) stochează un moment absolut, în UTC, și îl afișează în fusul sesiunii. timestamp fără fus orar este doar o „oră de perete”, ambiguă când serverele sau utilizatorii sunt în fusuri diferite sau la schimbarea orei de vară. Pentru zile fără oră se folosește date.

Identificatori: bigint GENERATED ALWAYS AS IDENTITY este forma modernă, standard, a lui serial. Un integer se oprește la aproximativ 2,1 miliarde, iar tabelele de evenimente ajung acolo mai repede decât crezi. uuid este util când ID-urile se generează în mai multe sisteme, dar UUID-urile complet aleatorii fragmentează indexul B-tree; variantele ordonate în timp (UUIDv7) se comportă mai bine.

SQL
CREATE TABLE plati (
  id          bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
  suma        numeric(12,2) NOT NULL CHECK (suma > 0),
  moneda      char(3) NOT NULL DEFAULT 'RON',
  efectuata_la timestamptz NOT NULL DEFAULT now(),
  detalii     jsonb
);

Alte greșeli frecvente: varchar(255) din obișnuință (în PostgreSQL text are aceeași performanță), date stocate ca text și liste de valori puse într-o singură coloană în loc de un tabel separat.

Ce urmărește intervievatorul: Intervievatorul verifică dacă te gândești la corectitudinea datelor pe termen lung. Un DBA care prinde un float pentru sume sau un int care se va umple economisește firmei o migrare dureroasă.

Proiectarea schemei și constrângeri

13 Junior

Ce este normalizarea? Explică pe scurt formele normale 1NF, 2NF și 3NF.

Răspuns scurt: Normalizarea organizează datele în tabele astfel încât fiecare informație să fie stocată o singură dată. 1NF cere valori atomice, 2NF ca fiecare coloană să depindă de toată cheia, 3NF ca o coloană să nu depindă de altă coloană care nu e cheie.

Normalizarea este procesul prin care împarți datele în tabele ca să elimini redundanța și anomaliile: dacă adresa unui client apare în fiecare comandă, o modificare de adresă trebuie făcută în o mie de locuri și una va fi uitată.

  • 1NF (prima formă normală): fiecare coloană conține o singură valoare atomică și nu există grupuri repetitive. O coloană telefoane = '0722..., 0744...' încalcă 1NF; soluția este un tabel telefoane_client.
  • 2NF: tabelul este în 1NF și fiecare coloană care nu face parte din cheie depinde de toată cheia primară, nu doar de o parte. Într-un tabel linii_comanda (comanda_id, produs_id, cantitate, nume_produs), nume_produs depinde doar de produs_id, deci locul lui este în produse.
  • 3NF: tabelul este în 2NF și nicio coloană nu depinde de altă coloană care nu e cheie (dependență tranzitivă). Dacă clienti are cod_postal și oras, iar orașul rezultă din codul poștal, orașul ar trebui să stea într-un tabel separat de coduri poștale.
SQL
-- Nenormalizat: datele clientului copiate în fiecare comandă
-- comenzi(id, client_nume, client_email, client_adresa, produs, pret)

-- Normalizat
CREATE TABLE clienti (id bigint PRIMARY KEY, nume text, email text UNIQUE);
CREATE TABLE produse (id bigint PRIMARY KEY, nume text, pret numeric(12,2));
CREATE TABLE comenzi (id bigint PRIMARY KEY, client_id bigint REFERENCES clienti);
CREATE TABLE linii_comanda (
  comanda_id bigint REFERENCES comenzi, produs_id bigint REFERENCES produse,
  cantitate int NOT NULL, pret_unitar numeric(12,2) NOT NULL,
  PRIMARY KEY (comanda_id, produs_id)
);

Observă pret_unitar în linii_comanda: nu este redundanță, ci prețul de la momentul comenzii, care trebuie păstrat chiar dacă prețul produsului se schimbă. Să distingi o copie inutilă de un fapt istoric este exact judecata pe care o caută intervievatorul.

Ce urmărește intervievatorul: Se verifică dacă poți proiecta o schemă care nu produce date contradictorii. Exemplul cu prețul istoric arată că înțelegi regulile, nu doar le recitești.

14 Junior

Ce constrângeri poți defini pe un tabel în PostgreSQL și de ce sunt mai bune decât validarea doar în aplicație?

Răspuns scurt: PRIMARY KEY, FOREIGN KEY, UNIQUE, NOT NULL, CHECK și EXCLUDE. Sunt mai sigure decât validarea din aplicație pentru că se aplică oricui scrie în baza de date, inclusiv scripturilor, importurilor și altor aplicații.

Constrângerile sunt reguli pe care baza de date le verifică la fiecare scriere:

  • NOT NULL: coloana trebuie să aibă valoare.
  • UNIQUE: valorile nu se repetă (creează automat un index unic).
  • PRIMARY KEY: UNIQUE + NOT NULL, identificatorul rândului.
  • FOREIGN KEY: valoarea trebuie să existe în tabelul referit.
  • CHECK: o condiție booleană pe rând, de exemplu CHECK (pret >= 0).
  • EXCLUDE: generalizarea lui UNIQUE, de exemplu două rezervări ale aceleiași camere nu au voie să se suprapună în timp.
SQL
CREATE EXTENSION IF NOT EXISTS btree_gist;
CREATE TABLE rezervari (
  id      bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
  camera  int NOT NULL,
  perioada tstzrange NOT NULL,
  status  text NOT NULL CHECK (status IN ('activa', 'anulata')),
  EXCLUDE USING gist (camera WITH =, perioada WITH &&) WHERE (status = 'activa')
);

Validarea în aplicație rămâne utilă pentru mesaje prietenoase către utilizator, dar nu este suficientă. Într-o firmă, aceeași bază de date este scrisă de aplicația principală, de un job de import, de un script rulat manual de cineva la 2 noaptea și poate de un al doilea serviciu. Doar baza de date vede toate aceste scrieri. În plus, două cereri simultane pot trece amândouă de o verificare din aplicație („emailul nu există”) și pot insera duplicate; un index unic previne asta garantat.

Pe un tabel mare existent, adaugi o constrângere fără să blochezi mult timp cu ALTER TABLE ... ADD CONSTRAINT ... NOT VALID, urmat de VALIDATE CONSTRAINT, care verifică rândurile vechi cu un lock mai slab.

Ce urmărește intervievatorul: Intervievatorul vrea un DBA care apără integritatea datelor. Exemplul cu NOT VALID arată că știi să aplici regula și pe o bază de date care rulează în producție.

15 Junior

Cum modelezi o relație unu-la-mulți și una mulți-la-mulți?

Răspuns scurt: Unu-la-mulți: o cheie străină în tabelul de pe partea „mulți” (comenzi.client_id). Mulți-la-mulți: un tabel de legătură cu două chei străine și o cheie primară compusă din ele.

Unu-la-mulți (un client are multe comenzi): pui cheia străină pe partea „mulți”.

SQL
CREATE TABLE comenzi (
  id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
  client_id bigint NOT NULL REFERENCES clienti(id)
);
CREATE INDEX ON comenzi (client_id);

Mulți-la-mulți (un student urmează mai multe cursuri, un curs are mai mulți studenți): ai nevoie de un tabel de legătură (junction table).

SQL
CREATE TABLE inscrieri (
  student_id bigint NOT NULL REFERENCES studenti(id) ON DELETE CASCADE,
  curs_id    bigint NOT NULL REFERENCES cursuri(id),
  inscris_la timestamptz NOT NULL DEFAULT now(),
  nota       numeric(4,2),
  PRIMARY KEY (student_id, curs_id)
);
CREATE INDEX ON inscrieri (curs_id);

Câteva detalii care fac diferența la interviu:

  • Cheia primară compusă (student_id, curs_id) împiedică înscrierea dublă și servește ca index pentru căutările după student. Pentru căutările după curs ai nevoie de un al doilea index, pe curs_id, pentru că un index compus ajută doar când condiția folosește prima lui coloană.
  • Tabelul de legătură poate avea propriile atribute (data înscrierii, nota). Când devine o entitate importantă, unii preferă un id propriu plus un UNIQUE (student_id, curs_id).
  • Unu-la-unu se modelează cu o cheie străină care este și UNIQUE (sau chiar cheia primară a tabelului secundar), folosită de exemplu pentru a separa coloane rar accesate sau sensibile.

Evită anti-modelul în care stochezi lista de cursuri într-o coloană text sau într-un array: nu poți pune chei străine pe elemente și interogările devin greu de indexat.

Ce urmărește intervievatorul: Este fundamentul modelării relaționale. Detaliul despre indexul pe a doua coloană a cheii compuse este cel care separă un DBA de un utilizator de SQL.

16 Junior

Ce sunt schemele în PostgreSQL și ce face search_path?

Răspuns scurt: O schemă este un spațiu de nume în interiorul unei baze de date, care grupează tabele, vederi și funcții. search_path stabilește în ce scheme caută PostgreSQL un obiect scris fără prefix.

Ierarhia în PostgreSQL este: cluster (o instanță de server) → baze de date → scheme → obiecte (tabele, vederi, funcții, secvențe). O conexiune este legată de o singură bază de date, dar poate folosi obiecte din toate schemele ei.

SQL
CREATE SCHEMA facturare AUTHORIZATION app_facturare;
CREATE TABLE facturare.facturi (...);

SHOW search_path;                 -- "$user", public
SET search_path = facturare, public;
SELECT * FROM facturi;            -- găsește facturare.facturi

ALTER ROLE raportare SET search_path = raportare, public;

Utilizări tipice:

  • Separarea modulelor unei aplicații sau a mai multor aplicații în aceeași bază de date.
  • Drepturi pe grupuri de obiecte: GRANT USAGE ON SCHEMA facturare TO raportare.
  • Extensiile instalate într-o schemă dedicată, ca să nu aglomereze public.

Securitate: în PostgreSQL 15 s-a schimbat comportamentul implicit, iar utilizatorii obișnuiți nu mai pot crea obiecte în schema public. Pe versiunile mai vechi, orice utilizator putea crea acolo o funcție cu același nume ca una folosită de alt rol, iar un search_path nesigur putea duce la executarea codului lui. Recomandarea este să rulezi REVOKE CREATE ON SCHEMA public FROM PUBLIC și, în funcțiile SECURITY DEFINER, să setezi explicit SET search_path = pg_catalog, schema_mea.

Pentru scripturi de administrare și migrări, scrie numele complet (facturare.facturi), ca rezultatul să nu depindă de configurația sesiunii.

Ce urmărește intervievatorul: Se verifică dacă înțelegi organizarea logică a unui cluster PostgreSQL. Partea de securitate cu search_path apare des la interviurile pentru roluri de DBA.

17 Mid

Când folosești o coloană jsonb și când tabele relaționale? Cum indexezi jsonb?

Răspuns scurt: jsonb e potrivit pentru atribute variabile, rar filtrate sau venite din surse externe. Datele interogate des, cu relații și constrângeri, merită coloane normale. Indexarea se face cu GIN pe toată coloana sau cu indecși pe expresii pentru câmpuri anume.

jsonb stochează JSON într-un format binar, descompus, care permite operatori și indexare. Este util pentru:

  • atribute care variază de la un rând la altul (specificațiile produselor dintr-un magazin cu sute de categorii);
  • payload-uri primite de la API-uri externe, păstrate pentru audit;
  • setări sau metadate citite întregi, rar filtrate.

Nu este potrivit când datele au o structură stabilă, sunt filtrate și agregate des sau au nevoie de chei străine și CHECK. Statisticile optimizatorului sunt mult mai slabe pentru valorile din interiorul unui JSON, deci estimările de rânduri pot fi greșite și planurile proaste. Fiecare actualizare rescrie toată valoarea, iar documentele mari ajung în TOAST și costă la citire.

SQL
CREATE TABLE produse (
  id bigint PRIMARY KEY, nume text NOT NULL, pret numeric(12,2) NOT NULL,
  atribute jsonb NOT NULL DEFAULT '{}'
);

-- Index GIN pentru operatorul de conținere @>
CREATE INDEX produse_atribute_gin ON produse USING gin (atribute jsonb_path_ops);
SELECT * FROM produse WHERE atribute @> '{"culoare": "rosu"}';

-- Index pe expresie pentru un câmp filtrat des
CREATE INDEX produse_marca ON produse ((atribute->>'marca'));
SELECT * FROM produse WHERE atribute->>'marca' = 'Dacia';

jsonb_path_ops creează un index mai mic și mai rapid, dar suportă doar @>; clasa implicită jsonb_ops suportă și operatorii de existență a cheii (?, ?|). Un index pe expresie trebuie folosit exact cu aceeași expresie în interogare. Dacă un câmp din JSON ajunge folosit peste tot, mută-l într-o coloană reală, eventual o coloană generată: marca text GENERATED ALWAYS AS (atribute->>'marca') STORED.

Ce urmărește intervievatorul: Intervievatorul verifică judecata, nu sintaxa: echipele de dezvoltare cer des „punem totul în JSON”. Un DBA bun știe când e o idee bună și ce costă.

18 Mid

Ce este partiționarea declarativă în PostgreSQL și când o recomanzi?

Răspuns scurt: Partiționarea împarte un tabel logic în mai multe tabele fizice după o cheie (interval de date, listă, hash). O recomanzi la tabele foarte mari cu date pe timp, unde vrei să ștergi rapid datele vechi și să scanezi doar partițiile relevante.

Cu partiționarea declarativă, un tabel părinte nu conține date; rândurile ajung automat în partiții după valoarea cheii de partiționare.

SQL
CREATE TABLE evenimente (
  id bigint GENERATED ALWAYS AS IDENTITY,
  creat_la timestamptz NOT NULL,
  tip text NOT NULL,
  payload jsonb,
  PRIMARY KEY (id, creat_la)          -- cheia unică trebuie să includă cheia de partiționare
) PARTITION BY RANGE (creat_la);

CREATE TABLE evenimente_2026_11 PARTITION OF evenimente
  FOR VALUES FROM ('2026-11-01') TO ('2026-12-01');
CREATE TABLE evenimente_default PARTITION OF evenimente DEFAULT;

Tipuri: RANGE (intervale, cel mai des pe date calendaristice), LIST (valori discrete, de exemplu țara) și HASH (distribuire uniformă).

Avantaje reale:

  • Ștergerea datelor vechi devine DROP TABLE sau ALTER TABLE ... DETACH PARTITION ... CONCURRENTLY, instant, în loc de un DELETE uriaș care umflă tabelul și generează WAL.
  • Partition pruning: o interogare cu WHERE creat_la >= '2026-11-01' citește doar partițiile relevante.
  • VACUUM și indexarea lucrează pe bucăți mai mici.

Costuri și capcane: orice cheie primară sau constrângere unică trebuie să conțină cheia de partiționare; interogările care nu filtrează pe cheie scanează toate partițiile; prea multe partiții (mii) încetinesc planificarea. Partițiile trebuie create din timp, de un job programat sau cu extensia pg_partman, altfel rândurile ajung în partiția DEFAULT sau inserarea eșuează.

Recomand partiționarea când un tabel trece de zeci sau sute de GB, datele au o dimensiune clară de timp și există o politică de retenție. Pentru un tabel de câteva milioane de rânduri, indecșii buni sunt de obicei suficienți.

Ce urmărește intervievatorul: Se verifică dacă știi și beneficiile, și costurile. Un candidat care recomandă partiționare peste tot, fără să menționeze cheia primară și pruning-ul, nu a lucrat cu ea.

19 Mid

Ce este denormalizarea și când este o decizie bună?

Răspuns scurt: Denormalizarea înseamnă să duplici intenționat date ca să faci citirile mai rapide sau mai simple. Este o decizie bună când citirile sunt mult mai dese decât scrierile și ai un mecanism clar care ține copiile sincronizate.

Un model normalizat este corect și ușor de întreținut, dar unele interogări frecvente ajung să facă multe join-uri și agregări. Denormalizarea mută o parte din efort de la citire la scriere.

Forme frecvente:

  • Coloane calculate stocate: comenzi.total actualizat când se modifică liniile comenzii, în loc de SUM la fiecare afișare.
  • Copii ale unor atribute: numele clientului salvat pe factură, pentru că legal factura trebuie să arate datele de la momentul emiterii.
  • Vederi materializate pentru rapoarte: CREATE MATERIALIZED VIEW vanzari_zilnice AS ..., reîmprospătate periodic cu REFRESH MATERIALIZED VIEW CONCURRENTLY (care cere un index unic pe vedere).
  • Tabele de rezumat pentru dashboard-uri, actualizate de un job.
SQL
CREATE MATERIALIZED VIEW vanzari_zilnice AS
SELECT date_trunc('day', data) AS zi, SUM(valoare) AS total, COUNT(*) AS nr
FROM comenzi GROUP BY 1;
CREATE UNIQUE INDEX ON vanzari_zilnice (zi);
REFRESH MATERIALIZED VIEW CONCURRENTLY vanzari_zilnice;

Întrebările pe care le pun înainte să accept denormalizarea: este problema reală, măsurată cu EXPLAIN ANALYZE, sau presupusă? Nu ajunge un index bun? Cine actualizează copia și ce se întâmplă dacă actualizarea eșuează? Cât de vechi au voie să fie datele?

Cel mai sigur este ca sincronizarea să se facă în aceeași tranzacție cu scrierea originală (prin aplicație sau printr-un trigger), sau să accepți explicit întârzierea, ca la vederile materializate. Denormalizarea fără un responsabil clar produce, după câteva luni, cifre diferite în rapoarte diferite.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă un compromis gândit, nu o regulă dogmatică. Menționarea măsurării înainte de optimizare și a sincronizării copiilor arată maturitate.

20 Senior

Echipa vrea să adauge o coloană NOT NULL cu valoare implicită și un index pe un tabel de 500 de milioane de rânduri, în producție. Cum faci schimbarea fără întrerupere?

Răspuns scurt: Din PostgreSQL 11, ADD COLUMN cu DEFAULT constant este instant. Indexul se creează cu CREATE INDEX CONCURRENTLY, iar constrângerile cu NOT VALID și apoi VALIDATE. Setezi lock_timeout ca migrarea să nu blocheze traficul cât așteaptă un lock.

Problema principală la migrările pe tabele mari nu este durata, ci lock-urile. Multe comenzi ALTER TABLE cer un lock ACCESS EXCLUSIVE, care blochează inclusiv citirile. Mai grav, dacă migrarea așteaptă un lock în spatele unei tranzacții lungi, toate interogările care vin după ea se pun la coadă în spatele migrării, iar aplicația pare căzută.

Plan pas cu pas:

SQL
SET lock_timeout = '3s';          -- renunță repede dacă nu primește lock-ul
SET statement_timeout = 0;

-- 1. Coloana: din PG 11, DEFAULT constant nu rescrie tabelul (doar metadate)
ALTER TABLE comenzi ADD COLUMN canal text NOT NULL DEFAULT 'web';

-- 2. Indexul: fără să blocheze scrierile
CREATE INDEX CONCURRENTLY comenzi_canal_idx ON comenzi (canal);

-- 3. O cheie străină sau un CHECK: întâi NOT VALID, apoi validarea separată
ALTER TABLE comenzi ADD CONSTRAINT comenzi_magazin_fk
  FOREIGN KEY (magazin_id) REFERENCES magazine(id) NOT VALID;
ALTER TABLE comenzi VALIDATE CONSTRAINT comenzi_magazin_fk;

Detalii care contează:

  • Un DEFAULT volatil (de exemplu clock_timestamp() sau gen_random_uuid()) rescrie tot tabelul. Atunci adaugi coloana nulă, completezi valorile în loturi mici și abia apoi adaugi NOT NULL, folosind un CHECK (canal IS NOT NULL) NOT VALID validat ca să eviți scanarea sub lock exclusiv.
  • CREATE INDEX CONCURRENTLY nu poate rula într-o tranzacție, durează mai mult și, dacă eșuează, lasă un index INVALID care trebuie șters și recreat. Verifici cu \d comenzi sau în pg_index.indisvalid.
  • Înainte de migrare verifici în pg_stat_activity dacă există tranzacții lungi.
  • Migrarea se rulează cu reîncercări automate când expiră lock_timeout, într-o perioadă cu trafic mic.

Ca senior, aș cere ca aceste reguli să fie verificate automat în pipeline-ul de migrări, nu lăsate la memoria fiecărui programator.

Ce urmărește intervievatorul: Este o întrebare clasică pentru seniori, pentru că o migrare greșită poate opri producția. Intervievatorul urmărește lock_timeout, CONCURRENTLY și NOT VALID, plus gândirea în pași reversibili.

Indecși, EXPLAIN și performanța interogărilor

21 Junior

Ce este un index și cum funcționează un index B-tree?

Răspuns scurt: Un index este o structură separată care permite găsirea rapidă a rândurilor după valoarea unor coloane, fără scanarea întregului tabel. B-tree, tipul implicit, este un arbore echilibrat și sortat, bun pentru egalitate, intervale și sortare.

Fără index, ca să găsească rândurile cu email = 'ana@exemplu.ro', PostgreSQL citește tot tabelul (sequential scan). Un index funcționează ca indexul de la finalul unei cărți: păstrează valorile sortate, fiecare cu adresa fizică a rândului (TID-ul, adică pagina și poziția).

Un B-tree este un arbore echilibrat: pagina rădăcină trimite spre pagini intermediare, care trimit spre frunze. Frunzele conțin valorile sortate și sunt legate între ele. Pentru o tabelă de 100 de milioane de rânduri, arborele are de obicei 3–4 niveluri, deci câteva citiri de pagini ajung pentru a găsi o valoare.

SQL
CREATE INDEX clienti_email_idx ON clienti (email);

-- Interogări care pot folosi un B-tree
SELECT * FROM clienti WHERE email = 'ana@exemplu.ro';
SELECT * FROM comenzi WHERE data BETWEEN '2026-10-01' AND '2026-10-31';
SELECT * FROM comenzi ORDER BY data DESC LIMIT 20;
SELECT * FROM clienti WHERE nume LIKE 'Pop%';   -- doar cu collation "C" sau text_pattern_ops

B-tree suportă =, <, <=, >, >=, BETWEEN, IN, IS NULL și poate livra rândurile deja sortate, evitând un pas de sortare.

Indexul nu este gratuit. Ocupă spațiu pe disc și în memorie, iar fiecare INSERT, UPDATE pe coloanele indexate și DELETE trebuie să actualizeze și indexul. Un tabel cu 15 indecși are inserări vizibil mai lente. De aceea un DBA creează indecși pe baza interogărilor reale, nu „pe toate coloanele, să fie”.

Ce urmărește intervievatorul: Este punctul de plecare pentru toate întrebările de performanță. Intervievatorul vrea să audă și costul indecșilor, nu doar beneficiul.

22 Junior

Ai creat un index pe o coloană, dar interogarea face tot sequential scan. Care pot fi cauzele?

Răspuns scurt: Optimizatorul poate considera scanarea completă mai ieftină (tabel mic sau multe rânduri întoarse), statisticile pot fi învechite, sau condiția nu poate folosi indexul: o funcție pe coloană, un tip diferit, LIKE cu % la început.

PostgreSQL alege planul cu costul estimat cel mai mic. Un sequential scan nu este automat o greșeală. Cauze frecvente:

  • Interogarea întoarce o parte mare din tabel. Dacă 30% din rânduri au status = 'livrata', citirea secvențială a tabelului este mai ieftină decât mii de salturi aleatorii prin index.
  • Tabelul este mic. Câteva pagini se citesc mai repede direct.
  • Statistici învechite. După un import mare, optimizatorul poate crede că tabelul e gol. Rulezi ANALYZE nume_tabel.
  • Funcție sau calcul pe coloană. WHERE lower(email) = '...' sau WHERE data::date = '2026-11-04' nu pot folosi un index simplu pe coloană. Soluția: rescrii condiția ca interval sau creezi un index pe expresie.
  • Tipuri diferite. Compararea unei coloane bigint cu un parametru numeric sau a unui text cu alt collation poate împiedica folosirea indexului.
  • LIKE '%abc': un B-tree nu ajută la căutarea în mijlocul textului; aici ajută un index trigram (pg_trgm) cu GIN.
  • Index compus folosit greșit: condiția nu include prima coloană a indexului.
  • Setări de cost: pe SSD, random_page_cost = 4 (implicit) supraestimează costul citirilor aleatorii; valori ca 1.1 sunt mai realiste.
SQL
EXPLAIN ANALYZE SELECT * FROM comenzi WHERE data::date = '2026-11-04';
-- Rescriere care poate folosi indexul pe data:
EXPLAIN ANALYZE SELECT * FROM comenzi
WHERE data >= '2026-11-04' AND data < '2026-11-05';

Pentru testare, poți rula SET enable_seqscan = off într-o sesiune, ca să vezi costul planului cu index. Nu se folosește în producție, ci doar ca diagnostic.

Ce urmărește intervievatorul: Este o situație pe care orice DBA o întâlnește săptămânal. Intervievatorul verifică dacă gândești ca optimizatorul și nu tratezi seq scan ca pe o eroare din principiu.

23 Junior

Contează ordinea coloanelor într-un index compus? Dă un exemplu.

Răspuns scurt: Da. Un index pe (a, b) este sortat întâi după a, apoi după b, deci ajută la condiții pe a sau pe a și b, dar aproape deloc la condiții doar pe b. Pune primele coloanele folosite la egalitate, apoi pe cea folosită la interval sau sortare.

Un index compus seamănă cu o carte de telefon sortată după nume, apoi după prenume. Găsești ușor toți cei cu numele „Popescu” sau „Popescu Ana”, dar nu și pe toți cei cu prenumele „Ana”.

SQL
CREATE INDEX comenzi_client_data_idx ON comenzi (client_id, data);

-- Folosesc bine indexul
SELECT * FROM comenzi WHERE client_id = 42;
SELECT * FROM comenzi WHERE client_id = 42 AND data >= '2026-01-01';
SELECT * FROM comenzi WHERE client_id = 42 ORDER BY data DESC LIMIT 10;

-- Nu îl folosesc eficient: lipsește prima coloană
SELECT * FROM comenzi WHERE data >= '2026-11-01';

Reguli practice pentru ordinea coloanelor:

  • Întâi coloanele comparate prin egalitate.
  • Apoi coloana folosită pentru interval sau sortare. După o condiție de interval, coloanele următoare nu mai restrâng căutarea în arbore, doar se filtrează.
  • Gândește-te la ce interogări există de fapt: un index (client_id, data) servește și interogările doar pe client_id, deci un index separat pe client_id devine redundant.

În ultimele versiuni, PostgreSQL poate folosi uneori un index și fără prima coloană (de exemplu prin „skip scan”, introdus în PostgreSQL 18, când prima coloană are puține valori distincte), dar nu te baza pe asta la proiectare.

Și direcția sortării contează pentru combinații mixte: pentru ORDER BY client_id ASC, data DESC, un index (client_id, data DESC) evită sortarea.

Ce urmărește intervievatorul: Indecșii compuși greșit ordonați sunt una dintre cele mai comune cauze de interogări lente. Intervievatorul vrea să vadă regula egalitate-apoi-interval aplicată pe un exemplu.

24 Junior

Cum citești rezultatul unui EXPLAIN? Ce înseamnă cost, rows și width?

Răspuns scurt: EXPLAIN arată planul ales ca arbore de noduri, citit de la interior spre exterior. cost are două valori, costul de pornire și costul total, în unități arbitrare; rows este numărul estimat de rânduri; width este dimensiunea medie estimată a unui rând în octeți.

EXPLAIN afișează planul pe care l-ar folosi optimizatorul, fără să ruleze interogarea. Planul este un arbore: nodurile cele mai indentate se execută primele și trimit rânduri către nodul părinte.

SQL
EXPLAIN SELECT c.nume, SUM(o.valoare)
FROM clienti c JOIN comenzi o ON o.client_id = c.id
WHERE o.data >= '2026-10-01'
GROUP BY c.nume;

HashAggregate  (cost=18234.50..18334.50 rows=10000 width=40)
  Group Key: c.nume
  ->  Hash Join  (cost=331.00..17734.50 rows=100000 width=38)
        Hash Cond: (o.client_id = c.id)
        ->  Index Scan using comenzi_data_idx on comenzi o
              (cost=0.43..15890.00 rows=100000 width=14)
              Index Cond: (data >= '2026-10-01')
        ->  Hash  (cost=206.00..206.00 rows=10000 width=36)
              ->  Seq Scan on clienti c  (cost=0.00..206.00 rows=10000 width=36)
  • cost=0.43..15890.00: primul număr este costul până la primul rând, al doilea costul total. Unitățile sunt relative (o citire secvențială de pagină = 1), nu milisecunde.
  • rows: câte rânduri estimează optimizatorul că iese din nod.
  • width: dimensiunea medie a unui rând, în octeți.
  • Index Cond versus Filter: condiția din Index Cond restrânge căutarea în index; un Filter se aplică după citire, pe rânduri deja aduse.

Ca să afli ce s-a întâmplat de fapt, folosești EXPLAIN (ANALYZE, BUFFERS), care rulează interogarea și adaugă timpul real, numărul real de rânduri și paginile citite din cache sau de pe disc. Atenție: ANALYZE execută efectiv instrucțiunea, deci un DELETE chiar șterge. Pentru instrucțiuni care modifică date îl rulezi într-o tranzacție urmată de ROLLBACK.

Ce urmărește intervievatorul: Citirea planurilor este meseria de bază a unui DBA. Intervievatorul verifică dacă știi că cost nu este timp și dacă distingi Index Cond de Filter.

25 Junior

Ce informații în plus îți dă EXPLAIN (ANALYZE, BUFFERS) și cum găsești o estimare greșită?

Răspuns scurt: Rulează interogarea și afișează timpul real, rândurile reale, numărul de bucle și paginile citite din cache (shared hit) sau din afara lui (read). O estimare greșită se vede când rows estimat diferă de zeci sau sute de ori de rows actual.

EXPLAIN ANALYZE execută interogarea și adaugă la fiecare nod valorile reale:

Nested Loop  (cost=0.85..120.40 rows=5 width=48)
             (actual time=0.051..2350.120 rows=480000 loops=1)
  Buffers: shared hit=1250000 read=86000
  ->  Index Scan using comenzi_status_idx on comenzi o
        (cost=0.43..8.45 rows=5 width=16)
        (actual time=0.030..310.400 rows=480000 loops=1)
        Index Cond: (status = 'in_asteptare')
  ->  Index Scan using clienti_pkey on clienti c
        (actual time=0.003..0.003 rows=1 loops=480000)
Planning Time: 0.4 ms
Execution Time: 2410.8 ms

Ce citești:

  • actual time=start..final, în milisecunde, pe o buclă. Timpul total al nodului este aproximativ timpul final înmulțit cu loops.
  • rows estimat versus actual: aici optimizatorul a crezut 5 rânduri, dar au venit 480.000. Pe baza estimării greșite a ales un nested loop, care a făcut 480.000 de căutări în index. Cu o estimare corectă ar fi ales un hash join.
  • Buffers: shared hit = pagini găsite în shared_buffers; read = pagini aduse din sistemul de operare sau de pe disc. Multe read înseamnă că datele nu sunt în cache. Apar și temp read/written când o sortare sau un hash nu încap în work_mem.

Când găsești o estimare greșită, cauzele tipice sunt statistici învechite (rulezi ANALYZE), o distribuție neuniformă pe care eșantionul nu o prinde (mărești ALTER TABLE comenzi ALTER COLUMN status SET STATISTICS 1000) sau coloane corelate între ele, pentru care creezi statistici extinse: CREATE STATISTICS ... (dependencies) ON oras, judet FROM clienti.

Pentru planuri lungi, unelte ca explain.depesz.com sau explain.dalibo.com colorează nodurile cele mai costisitoare. Nu lipi acolo planuri cu date sensibile.

Ce urmărește intervievatorul: Intervievatorul verifică dacă poți diagnostica o interogare lentă cu date reale, nu prin ghicit. Diferența dintre rândurile estimate și cele reale este cheia multor probleme de performanță.

26 Mid

Care este diferența dintre Seq Scan, Index Scan, Index Only Scan și Bitmap Heap Scan?

Răspuns scurt: Seq Scan citește tot tabelul. Index Scan caută în index și sare la rânduri unul câte unul. Index Only Scan ia datele doar din index, fără tabel. Bitmap Scan adună întâi adresele din index într-o hartă, apoi citește paginile tabelului în ordine fizică.

Sunt patru moduri prin care PostgreSQL poate citi un tabel:

  • Seq Scan: citește toate paginile tabelului în ordine și aplică filtrul. Eficient când se întoarce o parte mare din tabel sau tabelul e mic.
  • Index Scan: parcurge indexul și, pentru fiecare intrare găsită, citește rândul din tabel (heap). Citirile în tabel sunt aleatorii, deci este eficient pentru puține rânduri. Poate livra rândurile sortate după cheia indexului.
  • Index Only Scan: dacă toate coloanele cerute se află în index și paginile sunt marcate ca „toate vizibile” în visibility map, PostgreSQL nu mai citește tabelul deloc. În EXPLAIN ANALYZE urmărești Heap Fetches: dacă e mare, visibility map-ul nu este la zi și ajută un VACUUM.
  • Bitmap Index Scan + Bitmap Heap Scan: întâi se construiește din index o hartă de biți cu paginile care conțin rânduri potrivite, apoi se citesc acele pagini în ordine fizică. Este un compromis bun pentru un număr mediu de rânduri și permite combinarea mai multor indecși (BitmapAnd, BitmapOr).
SQL
CREATE INDEX comenzi_client_inc ON comenzi (client_id) INCLUDE (valoare, data);
-- Poate deveni Index Only Scan: toate coloanele sunt în index
EXPLAIN (ANALYZE, BUFFERS)
SELECT data, valoare FROM comenzi WHERE client_id = 42;

Dacă work_mem este prea mic pentru harta de biți, aceasta devine „lossy”: reține doar paginile, nu rândurile exacte, și în plan apare Recheck Cond cu Rows Removed by Index Recheck.

Alegerea între aceste metode se bazează pe estimarea numărului de rânduri și pe parametri precum random_page_cost și effective_cache_size. De aceea, pe servere cu SSD, ajustarea random_page_cost schimbă vizibil planurile.

Ce urmărește intervievatorul: Se verifică dacă poți interpreta un plan în detaliu. Menționarea visibility map și a lui Heap Fetches arată că înțelegi legătura dintre indecși și VACUUM.

27 Mid

Ce tipuri de indecși are PostgreSQL în afară de B-tree și când folosești fiecare?

Răspuns scurt: Hash pentru egalitate simplă, GIN pentru valori compuse (jsonb, array-uri, text complet, trigrame), GiST pentru date geometrice, intervale și căutări de proximitate, SP-GiST pentru structuri partiționate spațial și BRIN pentru tabele uriașe ordonate natural, ca jurnalele pe timp.

Fiecare tip de index este construit pentru alt tip de întrebare:

  • B-tree (implicit): egalitate, intervale, sortare. Acoperă majoritatea cazurilor.
  • Hash: doar egalitate. Din PostgreSQL 10 este sigur (scris în WAL), poate fi mai mic decât un B-tree pe chei lungi, dar nu suportă intervale, sortare sau unicitate. Se folosește rar.
  • GIN (Generalized Inverted Index): pentru valori care conțin mai multe elemente. Pentru fiecare element reține lista de rânduri. Potrivit pentru jsonb (@>), array-uri (&&, @>), căutare full-text (tsvector) și căutare de tip LIKE '%abc%' cu extensia pg_trgm. Citirile sunt rapide, scrierile mai scumpe (folosește o listă de așteptare, fastupdate).
  • GiST: un cadru pentru date „suprapuse”: geometrie și PostGIS, intervale (tstzrange), căutarea celor mai apropiați vecini (ORDER BY punct <-> ...) și constrângeri EXCLUDE.
  • SP-GiST: pentru structuri care se împart neechilibrat, ca prefixe de text sau adrese IP.
  • BRIN (Block Range Index): reține doar minimul și maximul pentru fiecare grup de pagini. Este extrem de mic (KB în loc de GB) și foarte bun pentru tabele uriașe în care valorile cresc odată cu ordinea fizică, cum ar fi un tabel de loguri cu creat_la.
SQL
CREATE EXTENSION IF NOT EXISTS pg_trgm;
CREATE INDEX produse_nume_trgm ON produse USING gin (nume gin_trgm_ops);
SELECT * FROM produse WHERE nume ILIKE '%laptop%';

CREATE INDEX loguri_creat_brin ON loguri USING brin (creat_la);
CREATE INDEX articole_fts ON articole USING gin (to_tsvector('simple', titlu || ' ' || continut));

Un BRIN pe o coloană fără corelație cu ordinea fizică este aproape inutil. Verifici corelația în pg_stats.correlation: valori aproape de 1 sau -1 sunt ideale.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi să alegi unealta potrivită, nu doar B-tree. GIN cu pg_trgm și BRIN pentru loguri sunt răspunsurile pe care le așteaptă cel mai des.

28 Mid

Ce sunt indecșii parțiali și indecșii pe expresii? Dă câte un exemplu util.

Răspuns scurt: Un index parțial indexează doar rândurile care respectă o condiție WHERE, deci este mai mic și mai rapid. Un index pe expresie indexează rezultatul unei funcții, de exemplu lower(email), ca interogările care folosesc aceeași expresie să poată folosi indexul.

Index parțial: are o clauză WHERE și conține doar rândurile care o îndeplinesc.

SQL
-- Doar comenzile neprocesate, căutate des de un job; restul de 99% nu intră în index
CREATE INDEX comenzi_in_asteptare_idx ON comenzi (creat_la)
WHERE status = 'in_asteptare';

SELECT * FROM comenzi
WHERE status = 'in_asteptare' AND creat_la < now() - interval '1 hour';

-- Unicitate doar pentru rândurile active (soft delete)
CREATE UNIQUE INDEX utilizatori_email_activ ON utilizatori (email)
WHERE sters_la IS NULL;

Indexul parțial este folosit doar dacă optimizatorul poate demonstra că condiția interogării implică condiția indexului. WHERE status = 'in_asteptare' merge; un parametru status = $1 dintr-un prepared statement generic poate să nu meargă.

Index pe expresie: indexează valoarea calculată.

SQL
CREATE INDEX clienti_email_lower ON clienti (lower(email));
SELECT * FROM clienti WHERE lower(email) = lower('Ana@Exemplu.ro');

CREATE INDEX comenzi_luna ON comenzi (date_trunc('month', creat_la AT TIME ZONE 'Europe/Bucharest'));

Expresia trebuie să fie IMMUTABLE, adică să dea mereu același rezultat pentru aceeași intrare. De aceea nu poți indexa direct date_trunc('day', coloana_timestamptz), care depinde de fusul orar al sesiunii; trebuie să fixezi fusul în expresie, ca mai sus. Interogarea trebuie să folosească exact aceeași expresie. După crearea unui index pe expresie, rulează ANALYZE pe tabel, ca PostgreSQL să adune statistici și despre valorile expresiei.

Cele două tehnici se pot combina, iar împreună rezolvă elegant multe cazuri în care un index complet ar fi uriaș și rar folosit.

Ce urmărește intervievatorul: Se verifică dacă știi tehnicile prin care un index devine mic și țintit. Exemplul cu unicitate parțială pentru soft delete apare des în aplicații reale.

29 Mid

Ce face ANALYZE și de ce statisticile optimizatorului sunt atât de importante?

Răspuns scurt: ANALYZE citește un eșantion din tabel și salvează statistici (valori frecvente, histograme, procentul de NULL, numărul de valori distincte). Optimizatorul le folosește ca să estimeze câte rânduri întoarce fiecare pas și să aleagă planul.

Optimizatorul PostgreSQL alege planul pe baza estimărilor de cost, iar estimările se bazează pe statistici din pg_statistic (vizibile ușor în pg_stats):

  • null_frac: procentul de valori NULL;
  • n_distinct: numărul de valori distincte;
  • most_common_vals și most_common_freqs: valorile cele mai frecvente și frecvența lor;
  • histogram_bounds: limitele unei histograme pentru restul valorilor;
  • correlation: cât de bine urmează ordinea fizică ordinea valorilor.
SQL
ANALYZE VERBOSE comenzi;

SELECT attname, null_frac, n_distinct, most_common_vals, correlation
FROM pg_stats WHERE tablename = 'comenzi' AND attname = 'status';

ALTER TABLE comenzi ALTER COLUMN status SET STATISTICS 1000;  -- eșantion mai mare
ANALYZE comenzi;

Autovacuum rulează și ANALYZE automat, după ce s-a modificat o anumită proporție din tabel (autovacuum_analyze_scale_factor, implicit 10%, plus un prag fix). Situații în care trebuie să intervii manual:

  • după un import sau o ștergere masivă, înainte ca autovacuum să ajungă la tabel;
  • după un pg_upgrade, pentru că statisticile nu se transferau între versiuni majore (din PostgreSQL 18 o parte se păstrează, dar rularea vacuumdb --analyze-in-stages rămâne practica sigură);
  • pe tabele foarte mari, unde 10% înseamnă zeci de milioane de rânduri, deci scazi scale factor-ul pe tabel;
  • la coloane corelate (oraș și județ): statisticile sunt per coloană și presupun independență, așa că estimarea pentru oras = 'Cluj-Napoca' AND judet = 'Cluj' iese mult prea mică. Rezolvi cu CREATE STATISTICS.

Statistici proaste înseamnă estimări proaste, iar estimările proaste înseamnă nested loop-uri pe sute de mii de rânduri sau sortări pe disc.

Ce urmărește intervievatorul: Multe incidente de performanță pornesc de la statistici, nu de la indecși lipsă. Intervievatorul verifică dacă știi unde sunt statisticile și când trebuie actualizate manual.

30 Mid

Cum găsești indecșii nefolosiți sau duplicați și de ce merită să-i ștergi?

Răspuns scurt: Din pg_stat_user_indexes vezi indecșii cu idx_scan aproape zero, iar din pg_index compari definițiile ca să găsești duplicate. Fiecare index în plus încetinește scrierile, ocupă disc și memorie și produce WAL.

Indecșii se adună în timp: unul creat pentru un raport abandonat, unul pus de un ORM, unul duplicat de cineva care nu a verificat ce există. Fiecare are un cost: actualizare la scrieri, spațiu, cache ocupat, WAL în plus și mai mult timp la VACUUM și la backup. În plus, un index pe o coloană modificată des împiedică actualizările HOT (Heap-Only Tuple), care sunt mult mai ieftine.

SQL
-- Indecși folosiți rar, cu dimensiunea lor
SELECT s.schemaname, s.relname AS tabel, s.indexrelname AS index,
       s.idx_scan, pg_size_pretty(pg_relation_size(s.indexrelid)) AS dimensiune
FROM pg_stat_user_indexes s
JOIN pg_index i ON i.indexrelid = s.indexrelid
WHERE s.idx_scan < 50
  AND NOT i.indisunique AND NOT i.indisprimary
ORDER BY pg_relation_size(s.indexrelid) DESC;

-- Indecși cu exact aceleași coloane pe același tabel
SELECT indrelid::regclass AS tabel, array_agg(indexrelid::regclass) AS indecsi
FROM pg_index
GROUP BY indrelid, indkey::text, indclass::text, coalesce(indexprs::text, ''), coalesce(indpred::text, '')
HAVING count(*) > 1;

Precauții înainte de ștergere:

  • Statisticile sunt per server: un index nefolosit pe primar poate fi folosit intens de rapoartele de pe o replică. Verifică pe toate nodurile.
  • Verifică de când sunt adunate statisticile (pg_stat_reset sau o repornire după crash le poate fi resetat). Un raport lunar poate folosi indexul o dată pe lună.
  • Nu șterge indecși care susțin constrângeri unice sau chei primare.
  • Un index pe (a) este de obicei redundant dacă există (a, b), dar nu și invers.

Ștergerea se face cu DROP INDEX CONCURRENTLY, ca să nu blochezi tabelul, și păstrezi definiția (pg_get_indexdef) ca să-l poți recrea rapid dacă cineva se plânge.

Ce urmărește intervievatorul: Este o sarcină reală de întreținere. Intervievatorul urmărește dacă știi să verifici și pe replici și să ștergi în siguranță.

31 Mid

Ce sunt actualizările HOT și ce legătură au cu fillfactor?

Răspuns scurt: O actualizare HOT (Heap-Only Tuple) scrie noua versiune a rândului în aceeași pagină și nu actualizează indecșii, pentru că nicio coloană indexată nu s-a schimbat. Un fillfactor mai mic lasă spațiu liber în pagini, ca actualizările HOT să fie posibile mai des.

În PostgreSQL, un UPDATE nu modifică rândul pe loc: creează o versiune nouă (MVCC). În mod normal, fiecare index al tabelului primește o intrare nouă care indică spre versiunea nouă, chiar dacă valoarea coloanei indexate nu s-a schimbat. Pe un tabel cu opt indecși, asta înseamnă opt scrieri în plus pentru fiecare actualizare.

O actualizare HOT evită asta când sunt îndeplinite două condiții:

  • nicio coloană folosită de vreun index nu a fost modificată;
  • noua versiune încape în aceeași pagină cu cea veche.

Atunci versiunea veche indică spre cea nouă printr-un lanț în interiorul paginii, iar indecșii nu se ating. În plus, versiunile vechi pot fi curățate direct la citirea paginii (page pruning), fără VACUUM complet.

SQL
-- Cât la sută din update-uri sunt HOT
SELECT relname, n_tup_upd, n_tup_hot_upd,
       round(100.0 * n_tup_hot_upd / nullif(n_tup_upd, 0), 1) AS procent_hot
FROM pg_stat_user_tables
ORDER BY n_tup_upd DESC LIMIT 10;

-- Lasă 20% spațiu liber în fiecare pagină pentru update-uri
ALTER TABLE sesiuni SET (fillfactor = 80);
-- Se aplică paginilor scrise de acum înainte; pentru cele existente e nevoie de rescriere (VACUUM FULL, pg_repack)

fillfactor implicit pentru tabele este 100 (pagini pline). Pentru tabele cu multe actualizări ale acelorași rânduri (sesiuni, stocuri, contoare), un fillfactor de 70–90 crește procentul de HOT și reduce bloat-ul indecșilor. Pentru tabele în care doar se inserează (loguri), fillfactor 100 este corect.

Concluzia practică: înainte să adaugi un index pe o coloană care se modifică foarte des, gândește-te că poate elimina actualizările HOT pentru tot tabelul.

Ce urmărește intervievatorul: Este o întrebare de nivel mid care separă candidații care înțeleg MVCC de cei care doar au citit despre el. Interogarea pe pg_stat_user_tables arată experiență practică.

32 Senior

Aplicația a devenit brusc lentă după o lansare. Cum găsești și rezolvi interogarea vinovată, pas cu pas?

Răspuns scurt: Confirmi simptomul în metrici, cauți în pg_stat_activity ce rulează acum și în pg_stat_statements ce s-a schimbat, iei planul cu EXPLAIN (ANALYZE, BUFFERS), identifici cauza (index lipsă, plan schimbat, lock-uri) și aplici o corecție sigură, apoi verifici efectul.

Abordarea metodică, de la general la particular:

1. Confirmă și delimitează. Ce s-a schimbat: CPU, I/O, numărul de conexiuni, latența? Toată aplicația sau un singur endpoint? Corelează momentul cu lansarea și cu eventuale migrări de schemă.

2. Ce rulează acum.

SQL
SELECT pid, now() - query_start AS durata, state, wait_event_type, wait_event,
       left(query, 120) AS interogare
FROM pg_stat_activity
WHERE state <> 'idle' AND pid <> pg_backend_pid()
ORDER BY durata DESC;

wait_event_type = 'Lock' indică blocări (verifici cu pg_blocking_pids(pid)), IO indică citiri de pe disc, iar fără eveniment de așteptare procesul consumă CPU.

3. Ce consumă cel mai mult. Cu pg_stat_statements compari interogările după timpul total și numărul de apeluri:

SQL
SELECT queryid, calls, round(total_exec_time) AS total_ms,
       round(mean_exec_time, 1) AS medie_ms, rows, left(query, 100)
FROM pg_stat_statements
ORDER BY total_exec_time DESC LIMIT 15;

O interogare nouă cu apeluri foarte multe (N+1 dintr-un ORM) sau una veche cu media crescută brusc sunt suspecții principali.

4. Planul. Rulezi EXPLAIN (ANALYZE, BUFFERS) cu parametri reali (pe o replică sau într-o tranzacție anulată, dacă scrie date). Cauți diferențe mari între rânduri estimate și reale, scanări secvențiale pe tabele mari, sortări pe disc, nested loop-uri cu mii de bucle. auto_explain poate salva automat planurile interogărilor lente.

5. Corecția, de la cea mai sigură. ANALYZE pe tabel, un index creat CONCURRENTLY, rescrierea interogării împreună cu echipa de dezvoltare sau, ca măsură temporară, rollback la versiunea anterioară a aplicației. Dacă un proces blochează totul, pg_cancel_backend(pid) înainte de pg_terminate_backend(pid).

6. Verifică și învață. Confirmi în metrici că latența a revenit, apoi scrii un scurt postmortem: de ce n-am prins asta înainte de producție? De obicei răspunsul este o bază de test prea mică; soluția este un mediu de test cu volume realiste și verificarea planurilor pentru migrările noi.

Ce urmărește intervievatorul: Intervievatorul evaluează metoda și calmul, nu o comandă anume. Un senior pornește de la date (pg_stat_activity, pg_stat_statements), alege corecții sigure și se gândește la prevenție.

Tranzacții, MVCC, lock-uri și VACUUM

33 Junior

Ce înseamnă ACID? Explică fiecare literă cu un exemplu.

Răspuns scurt: Atomicitate (totul sau nimic), Consistență (datele respectă regulile), Izolare (tranzacțiile simultane nu se încurcă) și Durabilitate (ce s-a confirmat nu se pierde, nici la o cădere). Sunt garanțiile unei tranzacții.

O tranzacție grupează mai multe operații într-o unitate logică. Exemplul clasic este un transfer de 500 de lei din contul A în contul B:

SQL
BEGIN;
UPDATE conturi SET sold = sold - 500 WHERE id = 'A';
UPDATE conturi SET sold = sold + 500 WHERE id = 'B';
COMMIT;
  • Atomicitate: fie se execută ambele actualizări, fie niciuna. Dacă serverul cade după prima, la repornire banii nu au dispărut din A fără să ajungă în B. Orice eroare în tranzacție duce la ROLLBACK.
  • Consistență: după tranzacție, datele respectă toate constrângerile definite: CHECK (sold >= 0), cheile străine, unicitatea. Dacă A nu are 500 de lei, constrângerea respinge tranzacția.
  • Izolare: alte tranzacții care rulează simultan nu văd starea intermediară, în care banii au plecat din A dar nu au ajuns în B. Gradul exact de izolare depinde de nivelul ales (Read Committed implicit în PostgreSQL).
  • Durabilitate: după ce COMMIT a întors succes, modificarea supraviețuiește unei căderi de curent. PostgreSQL scrie întâi modificările în WAL (Write-Ahead Log) și face fsync pe disc înainte de a confirma.

Pentru un DBA, partea de durabilitate are legătură directă cu configurația: setări ca fsync = off sau synchronous_commit = off cresc viteza, dar slăbesc garanțiile. fsync = off nu se folosește niciodată în producție, pentru că poate corupe baza de date la o cădere. synchronous_commit = off poate pierde ultimele tranzacții confirmate, fără corupere, și este acceptabil doar pentru date nesensibile.

Ce urmărește intervievatorul: Este fundamentul bazelor de date relaționale. Intervievatorul apreciază când legi durabilitatea de WAL și de setări concrete, nu doar recitești definiția.

34 Junior

Ce este MVCC și cum permite PostgreSQL citiri și scrieri simultane fără să se blocheze reciproc?

Răspuns scurt: MVCC (Multi-Version Concurrency Control) înseamnă că fiecare actualizare creează o versiune nouă a rândului, iar fiecare tranzacție vede versiunile valabile la momentul ei. Cititorii nu blochează scriitorii și scriitorii nu blochează cititorii.

În PostgreSQL, fiecare versiune de rând (tuple) are în antet două câmpuri ascunse: xmin, ID-ul tranzacției care a creat-o, și xmax, ID-ul tranzacției care a șters-o sau a înlocuit-o.

  • INSERT creează o versiune cu xmin = tranzacția curentă.
  • DELETE nu șterge fizic, ci setează xmax.
  • UPDATE = setează xmax pe versiunea veche și creează una nouă.

Când o tranzacție citește, folosește un snapshot: lista tranzacțiilor confirmate la momentul respectiv. O versiune este vizibilă dacă xmin este confirmat în snapshot și xmax lipsește sau nu este încă confirmat.

SQL
SELECT xmin, xmax, * FROM conturi WHERE id = 'A';

-- Sesiunea 1                         -- Sesiunea 2
BEGIN;
UPDATE conturi SET sold = 100
WHERE id = 'A';
                                      SELECT sold FROM conturi WHERE id = 'A';
                                      -- vede valoarea veche, fără să aștepte
COMMIT;
                                      SELECT sold FROM conturi WHERE id = 'A';
                                      -- acum vede 100 (Read Committed)

Avantajul este concurența: un raport lung nu blochează vânzările, iar vânzările nu blochează raportul. Doi scriitori pe același rând se blochează totuși: al doilea UPDATE așteaptă până când primul face COMMIT sau ROLLBACK.

Costul MVCC este că versiunile vechi („dead tuples”) rămân în tabel și în indecși. Ele trebuie curățate de VACUUM atunci când nicio tranzacție activă nu le mai poate vedea. O tranzacție deschisă ore întregi împiedică această curățare pe tot clusterul, iar tabelele se umflă (bloat). De aceea MVCC, VACUUM și tranzacțiile lungi sunt subiecte legate în orice interviu de DBA PostgreSQL.

Ce urmărește intervievatorul: MVCC explică aproape tot comportamentul specific PostgreSQL: VACUUM, bloat, HOT, wraparound. Intervievatorul vrea să vadă că înțelegi mecanismul, cu xmin și xmax.

35 Junior

Ce face VACUUM și care e diferența față de VACUUM FULL?

Răspuns scurt: VACUUM marchează spațiul ocupat de versiunile moarte ca refolosibil, actualizează visibility map și îngheață ID-urile vechi de tranzacție, fără să blocheze citirile și scrierile. VACUUM FULL rescrie tot tabelul ca să elibereze spațiu pe disc, dar îl blochează complet pe durata operației.

VACUUM (cel obișnuit, rulat și de autovacuum):

  • găsește versiunile de rând moarte, pe care nicio tranzacție nu le mai poate vedea, și le marchează ca spațiu liber în Free Space Map, pentru inserări viitoare;
  • curăță intrările corespunzătoare din indecși;
  • actualizează visibility map, care permite Index Only Scan și face următoarele vacuum-uri mai rapide;
  • „îngheață” (freeze) rândurile vechi, ca să prevină problema de wraparound a ID-urilor de tranzacție.

Rulează în paralel cu traficul normal (ia un lock SHARE UPDATE EXCLUSIVE, care permite citiri și scrieri). De regulă nu micșorează fișierul pe disc, doar face spațiul refolosibil. Excepția este când paginile goale sunt la finalul tabelului: acestea pot fi tăiate.

VACUUM FULL rescrie tabelul într-un fișier nou, compact, cu indecși reconstruiți, și eliberează spațiul înapoi sistemului de operare. Ia însă un lock ACCESS EXCLUSIVE, care blochează inclusiv SELECT, și are nevoie temporar de spațiu pe disc cât tabelul compactat.

SQL
VACUUM (VERBOSE, ANALYZE) comenzi;
VACUUM FULL comenzi;          -- doar în fereastră de mentenanță

SELECT relname, n_live_tup, n_dead_tup, last_autovacuum, last_autoanalyze
FROM pg_stat_user_tables ORDER BY n_dead_tup DESC LIMIT 10;

În producție, VACUUM FULL pe un tabel mare este aproape mereu o idee proastă, pentru că oprește aplicația. Alternativele sunt extensia pg_repack sau pg_squeeze, care reconstruiesc tabelul online și iau lock exclusiv doar câteva momente la final. Și mai bine este să previi bloat-ul printr-un autovacuum bine configurat.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi diferența de lock-uri. Un candidat care propune VACUUM FULL în producție, în timpul zilei, este un semnal de alarmă.

36 Junior

Ce este un deadlock și cum îl tratează PostgreSQL? Cum previi deadlock-urile?

Răspuns scurt: Un deadlock apare când două tranzacții așteaptă fiecare un lock ținut de cealaltă. PostgreSQL îl detectează după deadlock_timeout și anulează una dintre tranzacții cu o eroare. Le previi accesând rândurile mereu în aceeași ordine și ținând tranzacțiile scurte.

Exemplu clasic, cu două transferuri în sens invers:

SQL
-- Sesiunea 1                            -- Sesiunea 2
BEGIN;                                    BEGIN;
UPDATE conturi SET sold = sold - 10      UPDATE conturi SET sold = sold - 20
WHERE id = 'A';  -- lock pe A            WHERE id = 'B';  -- lock pe B
UPDATE conturi SET sold = sold + 10      UPDATE conturi SET sold = sold + 20
WHERE id = 'B';  -- așteaptă B           WHERE id = 'A';  -- așteaptă A

Niciuna nu poate continua. Când o sesiune așteaptă un lock mai mult de deadlock_timeout (implicit 1 secundă), PostgreSQL verifică graful de așteptări. Dacă găsește un ciclu, anulează una dintre tranzacții:

ERROR:  deadlock detected
DETAIL:  Process 4121 waits for ShareLock on transaction 9811; blocked by process 4127.
         Process 4127 waits for ShareLock on transaction 9810; blocked by process 4121.

Cealaltă tranzacție continuă normal. Aplicația care a primit eroarea trebuie să reîncerce tranzacția.

Prevenție:

  • Ordine constantă: blochează rândurile mereu în aceeași ordine, de exemplu după ID crescător: SELECT ... FROM conturi WHERE id IN ('A','B') ORDER BY id FOR UPDATE.
  • Tranzacții scurte, fără apeluri de rețea sau așteptări după utilizator în interiorul lor.
  • Indecși pe cheile străine, ca verificările să nu țină lock-uri pe multe rânduri.
  • Logică de reîncercare în aplicație pentru erorile 40P01 (deadlock) și 40001 (serialization failure).

Ca DBA, pornești log_lock_waits = on, care scrie în log așteptările mai lungi decât deadlock_timeout, și urmărești în log mesajele „deadlock detected”, ca să identifici împreună cu echipa de dezvoltare codul care le produce.

Ce urmărește intervievatorul: Deadlock-urile apar în orice aplicație cu concurență. Intervievatorul verifică dacă știi că PostgreSQL le rezolvă singur și că soluția reală este în ordinea accesului și în reîncercare.

37 Junior

Ce niveluri de izolare a tranzacțiilor există în PostgreSQL și care este cel implicit?

Răspuns scurt: Read Committed (implicit), Repeatable Read și Serializable. Read Uncommitted există ca sintaxă, dar se comportă ca Read Committed. Fiecare nivel elimină mai multe anomalii, cu prețul unor erori de serializare pe care aplicația trebuie să le reîncerce.

Standardul SQL definește anomalii pe care un nivel de izolare le permite sau le previne: citirea datelor neconfirmate (dirty read), citiri care se schimbă în aceeași tranzacție (non-repeatable read), rânduri noi care apar (phantom) și anomalii de serializare (write skew).

  • Read Committed (implicit): fiecare instrucțiune vede datele confirmate la începutul ei. Două SELECT-uri în aceeași tranzacție pot vedea valori diferite. Nu există dirty reads.
  • Repeatable Read: toată tranzacția folosește snapshot-ul de la prima instrucțiune. În PostgreSQL previne și phantoms. Dacă încerci să actualizezi un rând modificat între timp de altă tranzacție confirmată, primești could not serialize access due to concurrent update.
  • Serializable: garantează că rezultatul este identic cu o execuție a tranzacțiilor una după alta. PostgreSQL folosește SSI (Serializable Snapshot Isolation), care urmărește dependențele și anulează o tranzacție când detectează un risc, cu eroarea 40001.
  • Read Uncommitted: acceptat ca sintaxă, dar în PostgreSQL se comportă ca Read Committed; dirty reads nu sunt posibile.
SQL
BEGIN ISOLATION LEVEL REPEATABLE READ;
SELECT SUM(sold) FROM conturi;       -- raport consistent, chiar dacă durează
SELECT COUNT(*) FROM conturi;        -- același snapshot
COMMIT;

SHOW default_transaction_isolation;

Exemplu de write skew pe care doar Serializable îl previne: regula „cel puțin un medic de gardă”. Doi medici verifică simultan că mai e unul de gardă și se retrag amândoi. Fiecare tranzacție, luată separat, respectă regula.

În practică, majoritatea aplicațiilor rămân pe Read Committed și folosesc SELECT ... FOR UPDATE acolo unde e nevoie. pg_dump folosește intern Repeatable Read (de fapt un snapshot serializabil), ca exportul să fie consistent.

Ce urmărește intervievatorul: Se verifică înțelegerea concurenței și a anomaliilor. Faptul că Read Uncommitted nu există cu adevărat în PostgreSQL este un detaliu pe care intervievatorii îl caută.

38 Mid

Ce este bloat-ul și cum îl măsori și îl reduci?

Răspuns scurt: Bloat-ul este spațiul ocupat în tabele și indecși de versiuni moarte sau de spațiu liber nefolosit, care face tabelele mai mari decât datele utile. Îl estimezi cu pgstattuple sau cu interogări pe statistici și îl reduci cu autovacuum mai agresiv, REINDEX CONCURRENTLY sau pg_repack.

Din cauza MVCC, fiecare UPDATE și DELETE lasă versiuni moarte. VACUUM le face refolosibile, dar dacă vacuum-ul nu ține pasul sau o tranzacție lungă îl împiedică, tabelul crește. Și după curățare, spațiul rămâne alocat fișierului. Rezultatul: un tabel cu 2 GB de date utile ocupă 20 GB, scanările citesc de zece ori mai multe pagini, iar cache-ul se umple cu spațiu gol.

Măsurare:

SQL
-- Exact, dar citește tot obiectul (atenție la tabele mari)
CREATE EXTENSION IF NOT EXISTS pgstattuple;
SELECT * FROM pgstattuple('comenzi');          -- dead_tuple_percent, free_percent
SELECT * FROM pgstatindex('comenzi_pkey');      -- avg_leaf_density

-- Rapid, aproximativ
SELECT * FROM pgstattuple_approx('comenzi');

-- Indicator ieftin: rânduri moarte și ultimul autovacuum
SELECT relname, n_dead_tup, n_live_tup, last_autovacuum
FROM pg_stat_user_tables ORDER BY n_dead_tup DESC;

Există și interogări de estimare bazate pe pg_stats, publicate de comunitate, care nu citesc tabelul.

Reducere:

  • Prevenție: autovacuum mai agresiv pe tabelele cu multe modificări (autovacuum_vacuum_scale_factor mai mic pe tabel), eliminarea tranzacțiilor lungi și a sesiunilor idle in transaction, fillfactor mai mic pentru update-uri HOT.
  • Indecși: REINDEX INDEX CONCURRENTLY nume_index reconstruiește indexul fără să blocheze scrierile (din PostgreSQL 12).
  • Tabele: pg_repack reconstruiește tabelul online, cu un lock scurt la final. Are nevoie de spațiu liber cât tabelul și de o cheie primară sau un index unic. VACUUM FULL doar în fereastră de mentenanță.
  • Arhitectură: pentru date care se șterg periodic, partiționarea elimină bloat-ul la sursă.

Un anumit nivel de spațiu liber (10–20%) este normal și chiar util, pentru că inserările și update-urile noi îl refolosesc fără să mărească fișierul.

Ce urmărește intervievatorul: Bloat-ul este o problemă cronică în PostgreSQL. Intervievatorul verifică dacă știi să-l măsori corect și să-l reduci fără să oprești producția.

39 Mid

Ce problemă creează sesiunile idle in transaction și tranzacțiile lungi? Cum le detectezi și le limitezi?

Răspuns scurt: Țin deschis un snapshot vechi, care împiedică VACUUM să curețe versiunile moarte din tot clusterul, și pot ține lock-uri care blochează migrări și alte tranzacții. Le găsești în pg_stat_activity și le limitezi cu idle_in_transaction_session_timeout, statement_timeout și transaction_timeout.

O sesiune idle in transaction a deschis o tranzacție (BEGIN), a rulat ceva și apoi nu mai face nimic: aplicația a uitat să dea COMMIT, a apărut o excepție netratată sau un programator a lăsat o consolă deschisă. Efecte:

  • VACUUM nu poate curăța nicio versiune de rând mai nouă decât snapshot-ul acelei tranzacții, în nicio tabelă din baza de date. După câteva ore cu trafic mare, bloat-ul crește peste tot.
  • Lock-urile rămân ținute. Un ALTER TABLE care așteaptă după ea blochează apoi toate interogările care vin după el.
  • Conexiunea este ocupată și nu poate fi refolosită de un pool.
  • Pe replici, interogările lungi pot întârzia aplicarea WAL sau pot fi anulate, în funcție de configurație.
SQL
SELECT pid, usename, application_name, client_addr, state,
       now() - xact_start AS durata_tranzactie,
       now() - state_change AS de_cand_in_starea,
       backend_xmin, left(query, 80) AS ultima_interogare
FROM pg_stat_activity
WHERE xact_start IS NOT NULL
ORDER BY xact_start LIMIT 10;

-- Oprire controlată
SELECT pg_terminate_backend(12345);

Limitare prin configurație:

SQL
ALTER SYSTEM SET idle_in_transaction_session_timeout = '5min';
ALTER ROLE app_raportare SET statement_timeout = '2min';
ALTER ROLE app_web SET transaction_timeout = '30s';   -- PostgreSQL 17+
SELECT pg_reload_conf();

Pe lângă sesiuni, verifici și alte surse care țin xmin vechi: sloturi de replicare abandonate (pg_replication_slots), tranzacții pregătite uitate (pg_prepared_xacts) și hot_standby_feedback pe replici cu interogări lungi. Setezi o alertă pe vârsta celei mai vechi tranzacții, de exemplu peste 30 de minute.

Ce urmărește intervievatorul: Este una dintre cauzele cele mai frecvente de bloat și de blocaje în producție. Intervievatorul urmărește dacă știi toate sursele de xmin vechi, nu doar sesiunile.

40 Mid

Ce face SELECT ... FOR UPDATE și cum construiești o coadă de lucru sigură cu SKIP LOCKED?

Răspuns scurt: FOR UPDATE blochează rândurile citite până la finalul tranzacției, ca nimeni altcineva să nu le modifice între citire și actualizare. Cu SKIP LOCKED, mai mulți workeri pot lua fiecare alt rând dintr-o coadă, fără să se aștepte unii pe alții.

Într-un scenariu „citește, verifică, actualizează”, între SELECT și UPDATE altă tranzacție poate modifica rândul (lost update). FOR UPDATE blochează rândurile selectate:

SQL
BEGIN;
SELECT sold FROM conturi WHERE id = 'A' FOR UPDATE;   -- alții așteaptă aici
-- aplicația verifică dacă soldul ajunge
UPDATE conturi SET sold = sold - 500 WHERE id = 'A';
COMMIT;

Variante de lock pe rând, de la cel mai puternic la cel mai slab: FOR UPDATE, FOR NO KEY UPDATE (folosit implicit de UPDATE când nu se modifică cheia), FOR SHARE, FOR KEY SHARE (folosit de verificările cheilor străine). Lock-urile slabe permit mai multă concurență.

Modificatori utili:

  • NOWAIT: dacă rândul e blocat, eroare imediat în loc de așteptare.
  • SKIP LOCKED: sare peste rândurile blocate.

Coadă de lucru cu mai mulți workeri:

SQL
-- Fiecare worker ia următorul job liber, fără conflicte
WITH job AS (
  SELECT id FROM joburi
  WHERE status = 'nou'
  ORDER BY creat_la
  LIMIT 1
  FOR UPDATE SKIP LOCKED
)
UPDATE joburi j SET status = 'in_lucru', preluat_la = now(), worker = 'w3'
FROM job WHERE j.id = job.id
RETURNING j.*;

CREATE INDEX joburi_noi_idx ON joburi (creat_la) WHERE status = 'nou';

Doi workeri care rulează simultan primesc joburi diferite, fără să se blocheze. Ai nevoie de un index parțial pe joburile noi și de un mecanism pentru joburile rămase in_lucru după ce un worker a murit (de exemplu, readuse la nou după un timeout). Tabelul de joburi are multe actualizări, deci merită un autovacuum agresiv și ștergerea periodică a joburilor terminate.

Atenție: SKIP LOCKED oferă intenționat o imagine inconsistentă a datelor. Este potrivit pentru cozi, nu pentru rapoarte.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi să previi lost updates și dacă poți construi un mecanism concurent corect. Coada cu SKIP LOCKED este un model foarte folosit cu PostgreSQL.

41 Mid

O migrare ALTER TABLE a blocat toată aplicația, deși tabelul este mic. Ce s-a întâmplat?

Răspuns scurt: ALTER TABLE cerea un lock ACCESS EXCLUSIVE și a stat la coadă în spatele unei tranzacții lungi care ținea un lock mai slab pe tabel. Toate interogările venite după ea s-au pus la coadă în spatele migrării. Soluția este lock_timeout cu reîncercare și verificarea tranzacțiilor lungi înainte.

Este „coada de lock-uri”, unul dintre cele mai neintuitive fenomene din PostgreSQL. Lock-urile pe un tabel se acordă în ordinea cererii. Scenariul:

  • Un raport rulează de 10 minute un SELECT pe clienti și ține un lock ACCESS SHARE.
  • Migrarea rulează ALTER TABLE clienti ADD COLUMN ..., care cere ACCESS EXCLUSIVE, incompatibil cu orice alt lock. Așteaptă după raport.
  • Fiecare SELECT nou al aplicației pe clienti cere ACCESS SHARE. Deși este compatibil cu raportul, este incompatibil cu cererea migrării aflată înaintea lui la coadă, așa că așteaptă și el.
  • În câteva secunde, toate conexiunile aplicației sunt blocate, pool-ul se umple și site-ul pare căzut, deși migrarea în sine ar dura câteva milisecunde.

Diagnostic:

SQL
SELECT a.pid, a.state, now() - a.query_start AS asteapta_de,
       pg_blocking_pids(a.pid) AS blocat_de, left(a.query, 80)
FROM pg_stat_activity a
WHERE cardinality(pg_blocking_pids(a.pid)) > 0;

SELECT l.locktype, l.relation::regclass, l.mode, l.granted, l.pid
FROM pg_locks l WHERE l.relation = 'clienti'::regclass;

Rezolvare imediată: anulezi migrarea (pg_cancel_backend) sau, dacă e acceptabil, tranzacția lungă care o blochează.

Prevenție:

SQL
SET lock_timeout = '2s';
ALTER TABLE clienti ADD COLUMN segment text;
-- Dacă expiră, aplicația de migrări reîncearcă de câteva ori, cu pauză

Plus: verifici pg_stat_activity pentru tranzacții lungi înainte de migrare, rulezi migrările când traficul e mic și împarți operațiile grele în pași care cer lock-uri mai slabe (CREATE INDEX CONCURRENTLY, constrângeri NOT VALID).

Ce urmărește intervievatorul: Scenariul apare frecvent în producție și surprinde chiar și programatori experimentați. Intervievatorul vrea să audă despre coada de lock-uri și despre lock_timeout.

42 Mid

Cum funcționează autovacuum și cum îl ajustezi pentru un tabel cu foarte multe modificări?

Răspuns scurt: Autovacuum pornește procese care rulează VACUUM și ANALYZE pe tabele după ce numărul de rânduri moarte depășește un prag (un număr fix plus un procent din tabel). Pentru tabele mari sau foarte active scazi procentul pe tabel și crești viteza permisă (cost limit) și numărul de workeri.

Un proces lansator verifică periodic (autovacuum_naptime, implicit 1 minut) fiecare bază de date și pornește până la autovacuum_max_workers procese. Un tabel primește VACUUM când:

rânduri moarte > autovacuum_vacuum_threshold + autovacuum_vacuum_scale_factor × rânduri totale
                 (implicit 50)                  (implicit 0.2, adică 20%)

Pentru ANALYZE există praguri similare (10% implicit), iar pentru tabelele în care doar se inserează există din PostgreSQL 13 pragul autovacuum_vacuum_insert_*, necesar pentru visibility map și freeze.

Problema la tabele mari: 20% din 500 de milioane de rânduri înseamnă 100 de milioane de rânduri moarte înainte de prima curățare. Iar când pornește, vacuum-ul este frânat de autovacuum_vacuum_cost_limit și cost_delay, ca să nu sufoce I/O-ul, deci poate dura ore.

Ajustare pe tabel:

SQL
ALTER TABLE comenzi SET (
  autovacuum_vacuum_scale_factor = 0.01,     -- 1%
  autovacuum_vacuum_threshold = 10000,
  autovacuum_analyze_scale_factor = 0.005,
  autovacuum_vacuum_cost_limit = 2000
);

Ajustare globală (în postgresql.conf), pe servere cu SSD rapide: autovacuum_vacuum_cost_limit mai mare (de exemplu 1000–2000, pentru că limita se împarte între workeri), autovacuum_max_workers de 5–6 pe servere cu multe tabele active și maintenance_work_mem / autovacuum_work_mem suficient de mare (de exemplu 1 GB), ca vacuum-ul să nu treacă de mai multe ori prin indecși.

Monitorizare:

SQL
SELECT relname, n_dead_tup, last_autovacuum, autovacuum_count
FROM pg_stat_user_tables ORDER BY n_dead_tup DESC LIMIT 10;

SELECT * FROM pg_stat_progress_vacuum;      -- vacuum-urile în curs și faza lor

Setezi log_autovacuum_min_duration = '10s' ca să vezi în log vacuum-urile lente. Regula de bază: nu dezactiva niciodată autovacuum, nici măcar pe un singur tabel, decât temporar și cu un plan clar.

Ce urmărește intervievatorul: Autovacuum prost configurat este o cauză majoră de probleme pe bazele de date mari. Intervievatorul verifică dacă știi formula pragului și ajustarea per tabel.

43 Mid

Ce sunt advisory locks și când le-ai folosi?

Răspuns scurt: Sunt lock-uri definite de aplicație, identificate printr-un număr, pe care PostgreSQL le gestionează fără să fie legate de vreun tabel sau rând. Sunt utile ca să te asiguri că un job programat rulează o singură dată, chiar dacă există mai multe servere de aplicație.

Lock-urile normale protejează obiecte din baza de date. Un advisory lock protejează o resursă logică pe care o definești tu printr-o cheie numerică (bigint sau două int). PostgreSQL doar ține evidența cine deține cheia.

Tipuri:

  • la nivel de sesiune: pg_advisory_lock(cheie), rămâne până la pg_advisory_unlock sau până se închide conexiunea;
  • la nivel de tranzacție: pg_advisory_xact_lock(cheie), eliberat automat la COMMIT sau ROLLBACK;
  • variante try, care nu așteaptă: pg_try_advisory_lock(cheie) întoarce true sau false.
SQL
-- Jobul de facturare rulează pe trei servere, dar trebuie să ruleze o singură dată
SELECT pg_try_advisory_lock(hashtext('job_facturare_lunara'));
-- true: acest server rulează jobul; false: altul îl rulează deja

-- ... procesare ...
SELECT pg_advisory_unlock(hashtext('job_facturare_lunara'));

-- Serializarea operațiilor pe un client, în interiorul unei tranzacții
BEGIN;
SELECT pg_advisory_xact_lock(42);   -- 42 = id client
-- recalculare sold client
COMMIT;

SELECT locktype, objid, mode, granted, pid FROM pg_locks WHERE locktype = 'advisory';

Capcane de care trebuie să știe un DBA:

  • Cu un pool de conexiuni în modul transaction (PgBouncer), lock-urile la nivel de sesiune sunt periculoase: conexiunea fizică ajunge la alt client, iar lock-ul rămâne „agățat”. Folosește variantele la nivel de tranzacție.
  • Lock-urile de sesiune uitate rămân până la închiderea conexiunii.
  • Cheile trebuie alese cu un spațiu de nume clar (de exemplu, două chei int: tipul resursei și ID-ul), ca două funcționalități diferite să nu folosească accidental același număr.

Advisory locks înlocuiesc elegant tabelele de tip „lock” cu un rând și coloana in_executie, care rămân blocate dacă procesul moare.

Ce urmărește intervievatorul: Se verifică dacă știi uneltele de coordonare oferite de PostgreSQL. Capcana cu PgBouncer în modul transaction arată experiență practică.

44 Senior

Ce este transaction ID wraparound, de ce poate opri o bază de date și cum îl previi?

Răspuns scurt: ID-urile de tranzacție au 32 de biți și sunt comparate circular, așa că după aproximativ 2 miliarde de tranzacții rândurile vechi ar părea din viitor. VACUUM le îngheață ca să prevină asta. Dacă înghețarea nu ține pasul, PostgreSQL refuză tranzacții noi, ca să protejeze datele. Previi cu monitorizarea vârstei datfrozenxid și cu autovacuum sănătos.

Fiecare tranzacție care modifică date primește un XID pe 32 de biți. Comparația dintre XID-uri este circulară: pentru o tranzacție, aproximativ 2 miliarde de XID-uri sunt „în trecut” și 2 miliarde „în viitor”. Dacă un rând ar rămâne cu un xmin vechi neatins mai mult de 2 miliarde de tranzacții, ar ajunge brusc „în viitor” și ar deveni invizibil: date pierdute aparent.

Ca să prevină asta, VACUUM îngheață (freeze) rândurile suficient de vechi, marcându-le ca vizibile pentru toată lumea, indiferent de XID. Pentru fiecare tabel, relfrozenxid reține cel mai vechi XID neînghețat; vârsta lui crește cu fiecare tranzacție din cluster.

  • La autovacuum_freeze_max_age (implicit 200 de milioane), autovacuum pornește un vacuum anti-wraparound pe tabel, chiar dacă autovacuum este dezactivat. Acesta nu poate fi anulat automat de alte operații.
  • Aproape de limită, PostgreSQL emite avertismente în log.
  • La aproximativ 3 milioane de XID-uri înainte de limită, PostgreSQL refuză să mai aloce XID-uri noi: orice scriere eșuează, iar aplicația practic se oprește până rulezi VACUUM.
SQL
-- Vârsta pe baze de date
SELECT datname, age(datfrozenxid) AS varsta,
       round(100.0 * age(datfrozenxid) / 2000000000, 1) AS procent_din_limita
FROM pg_database ORDER BY varsta DESC;

-- Tabelele cele mai vechi
SELECT c.oid::regclass, age(c.relfrozenxid) AS varsta,
       pg_size_pretty(pg_total_relation_size(c.oid))
FROM pg_class c WHERE c.relkind IN ('r', 't', 'm')
ORDER BY age(c.relfrozenxid) DESC LIMIT 10;

Ce împiedică înghețarea: tranzacții foarte lungi, sloturi de replicare abandonate, tranzacții pregătite uitate, autovacuum prea lent pe un tabel uriaș sau anulat mereu de migrări.

Prevenție: alertă pe vârstă (de exemplu la 40–50% din limită), eliminarea surselor de xmin vechi, autovacuum cu buget suficient și VACUUM (FREEZE) programat pe tabelele mari, în perioade liniștite. Dacă ajungi totuși la oprire, rulezi VACUUM pe tabelele cu vârsta cea mai mare (eventual cu INDEX_CLEANUP off ca să fie mai rapid); modul single-user nu mai este necesar în versiunile recente. Există și MultiXact ID-uri, folosite pentru lock-uri partajate pe rânduri, cu un mecanism de wraparound similar.

Ce urmărește intervievatorul: Wraparound a oprit producția la companii mari, așa că este o întrebare clasică pentru seniori. Intervievatorul verifică dacă știi să-l monitorizezi și ce îl provoacă, nu doar definiția.

Backup, restaurare, WAL și PITR

45 Junior

Care e diferența dintre un backup logic și unul fizic în PostgreSQL?

Răspuns scurt: Backup-ul logic (pg_dump) exportă obiectele și datele ca instrucțiuni SQL sau într-un format de arhivă și poate fi restaurat pe altă versiune. Backup-ul fizic (pg_basebackup, pgBackRest) copiază fișierele de date ale clusterului și, împreună cu WAL, permite recuperarea la un moment anume.

Backup logic – pg_dump și pg_dumpall:

  • exportă definițiile (tabele, indecși, funcții) și datele, ca SQL sau în format arhivă;
  • poate face backup unei singure baze de date, unei scheme sau unui tabel;
  • este portabil între versiuni majore și arhitecturi, util la migrări și upgrade-uri;
  • restaurarea recreează indecșii și verifică constrângerile, deci pe baze mari durează ore;
  • reflectă un singur moment (snapshot-ul de la pornire), fără posibilitate de recuperare la un moment ulterior.

Backup fizic – pg_basebackup, pgBackRest, Barman, snapshot-uri de disc:

  • copiază fișierele din directorul de date al întregului cluster (toate bazele de date);
  • se restaurează doar pe aceeași versiune majoră și aceeași arhitectură;
  • restaurarea este rapidă: copiezi fișierele și pornești serverul;
  • împreună cu arhiva de WAL permite PITR (Point-In-Time Recovery), adică întoarcerea la orice secundă dintre backup și prezent.
BASH
# Logic: o bază de date, format custom, comprimat
pg_dump -h db1 -U backup -d magazin -Fc -f magazin_2026-11-04.dump

# Fizic: tot clusterul, cu WAL-ul necesar inclus
pg_basebackup -h db1 -U replicare -D /backup/base_2026-11-04 -Ft -z -Xs -P

În producție, strategia corectă folosește de obicei ambele: backup fizic cu arhivare continuă de WAL ca bază a recuperării după dezastru, plus dump-uri logice periodice pentru restaurarea unui singur tabel, pentru copii în mediile de test (cu date anonimizate) și ca plasă de siguranță independentă de formatul fișierelor.

Ce urmărește intervievatorul: Este prima întrebare despre backup la orice interviu de DBA. Intervievatorul vrea să audă că știi când folosești fiecare tip și că o strategie reală le combină.

46 Junior

Ce formate are pg_dump și cum restaurezi cu pg_restore?

Răspuns scurt: Formatele sunt plain (text SQL), custom (-Fc), directory (-Fd) și tar (-Ft). Plain se restaurează cu psql; custom și directory se restaurează cu pg_restore, care permite selecția obiectelor și restaurarea în paralel cu -j.

pg_dump are patru formate:

  • plain (-Fp, implicit): un fișier SQL citibil. Se restaurează cu psql -f. Simplu, dar nu poți alege ușor ce restaurezi și nu se poate restaura în paralel.
  • custom (-Fc): o arhivă comprimată. Se restaurează cu pg_restore, care poate alege obiecte, schimba ordinea și restaura în paralel.
  • directory (-Fd): un director cu un fișier per tabel. Singurul format care permite și exportul în paralel (-j).
  • tar (-Ft): similar cu directory, într-o arhivă tar, fără compresie și fără paralelism.
BASH
# Export în paralel, cu 4 procese
pg_dump -d magazin -Fd -j 4 -f /backup/magazin_dir

# Ce conține arhiva
pg_restore -l /backup/magazin.dump | head

# Restaurare completă într-o bază nouă, în paralel
createdb magazin_restaurat
pg_restore -d magazin_restaurat -j 4 --no-owner /backup/magazin.dump

# Doar un tabel
pg_restore -d magazin_restaurat -t comenzi --data-only /backup/magazin.dump

# Rolurile și tablespace-urile nu sunt incluse în pg_dump
pg_dumpall --globals-only -f /backup/globals.sql

Detalii pe care le verifică un intervievator:

  • pg_dump exportă o singură bază de date. Rolurile și setările globale se exportă separat cu pg_dumpall --globals-only; fără ele, restaurarea poate eșua la GRANT-uri și proprietari.
  • Exportul folosește un snapshot consistent și nu blochează scrierile, dar ține o tranzacție lungă pe server, deci întârzie VACUUM cât rulează.
  • Folosește versiunea de pg_dump cea mai nouă dintre sursă și destinație: un pg_dump 17 poate exporta dintr-un server 13, invers nu.
  • --no-owner și --no-privileges sunt utile când restaurezi pe alt server, cu alte roluri.

Ce urmărește intervievatorul: Intervievatorul verifică dacă ai făcut efectiv exporturi și restaurări. Uitarea rolurilor (pg_dumpall --globals-only) este o greșeală foarte comună.

47 Junior

Ce este WAL (Write-Ahead Log) și de ce este esențial pentru PostgreSQL?

Răspuns scurt: WAL este jurnalul în care PostgreSQL scrie fiecare modificare înainte să o aplice în fișierele de date. Permite recuperarea după o cădere, replicarea către alte servere și backup-ul continuu cu recuperare la un moment anume.

Principiul „write-ahead” este simplu: înainte ca o modificare să ajungă în fișierele tabelelor, descrierea ei este scrisă secvențial în WAL și forțată pe disc (fsync) la COMMIT. Paginile modificate din memorie (shared_buffers) pot fi scrise pe disc mai târziu, în grupuri, de checkpointer și de background writer.

De ce contează:

  • Recuperarea după cădere. Dacă serverul cade, la repornire PostgreSQL citește WAL-ul de la ultimul checkpoint și reaplică modificările. Tranzacțiile confirmate nu se pierd.
  • Performanță. Scrierea secvențială în WAL este mult mai rapidă decât scrierea aleatorie a paginilor de date la fiecare tranzacție.
  • Replicare. Replicile primesc fluxul de WAL de la primar și îl aplică (streaming replication).
  • Backup continuu și PITR. Arhivând toate segmentele de WAL, poți reconstrui baza de date la orice moment.

WAL-ul se află în directorul pg_wal, în segmente de 16 MB. Fiecare poziție în WAL are un LSN (Log Sequence Number), de forma 0/1A2B3C4D.

SQL
SELECT pg_current_wal_lsn();                    -- poziția curentă
SELECT pg_walfile_name(pg_current_wal_lsn());   -- segmentul curent
SHOW wal_level;                                 -- minimal, replica sau logical
SHOW max_wal_size;                              -- cât WAL se acumulează între checkpoint-uri

O alertă importantă pentru DBA: dacă directorul pg_wal umple discul, PostgreSQL se oprește. Cauzele obișnuite sunt arhivarea care eșuează (archive_command dă erori) și un slot de replicare pentru o replică oprită. Niciodată nu ștergi manual fișiere din pg_wal: rezolvi cauza, iar PostgreSQL le reciclează singur.

Ce urmărește intervievatorul: WAL stă la baza backup-ului, replicării și durabilității. Intervievatorul verifică dacă înțelegi legătura dintre ele și dacă știi riscul unui pg_wal care umple discul.

48 Junior

De ce trebuie testată restaurarea backup-urilor și cum ai face asta regulat?

Răspuns scurt: Un backup netestat nu este un backup: poate fi incomplet, corupt sau imposibil de restaurat în timpul cerut. Restaurarea se testează automat și regulat pe un server separat, verificând că baza pornește, că datele sunt complete și cât durează.

Multe firme descoperă abia în timpul unui incident că backup-ul nu funcționa: scriptul eșua în tăcere de luni de zile, lipsea un segment de WAL, cheia de criptare era pierdută sau restaurarea dura 14 ore, nu una. De aceea, ce contează pentru firmă nu este backup-ul, ci restaurarea.

Un test regulat, automatizat, poate arăta așa:

  • Un job (săptămânal sau zilnic) ia ultimul backup și îl restaurează pe un server sau container separat.
  • Pentru backup-ul fizic, face și o recuperare la un moment anume, ca să verifice că arhiva de WAL este completă.
  • Pornește PostgreSQL și rulează verificări: numărul de rânduri din tabelele principale comparat cu valori așteptate, data ultimei comenzi (ar trebui să fie foarte recentă), o interogare din fiecare schemă importantă.
  • Opțional, rulează pg_amcheck pentru a verifica integritatea tabelelor și indecșilor.
  • Măsoară durata restaurării și o compară cu RTO-ul promis.
  • Trimite rezultatul în monitorizare; o alertă apare dacă testul eșuează sau nu a rulat.
BASH
#!/usr/bin/env bash
set -euo pipefail
START=$(date +%s)
pgbackrest --stanza=main --delta --type=time --target="$(date -d '-1 hour' '+%F %T')" restore
pg_ctl -D /var/lib/postgresql/data -w start
psql -Atc "SELECT max(creat_la) > now() - interval '2 hours' FROM comenzi" | grep -q t
echo "restore_ok durata=$(( $(date +%s) - START ))s"

Pe lângă testele automate, merită un exercițiu manual de câteva ori pe an, în care un coleg care nu a mai făcut restaurarea urmează doar documentația. Astfel verifici și procedura, nu doar fișierele.

Ce urmărește intervievatorul: Intervievatorul caută mentalitatea corectă: un DBA răspunde de recuperare, nu de existența unor fișiere. Răspunsurile care includ automatizare și măsurarea duratei sunt cele mai bune.

49 Junior

Ce face pg_basebackup și ce înseamnă opțiunile -X stream și -R?

Răspuns scurt: pg_basebackup face o copie fizică a întregului cluster printr-o conexiune de replicare, fără oprirea serverului. -X stream copiază în paralel și WAL-ul generat în timpul backup-ului, ca acesta să fie consistent, iar -R pregătește configurația pentru ca copia să pornească drept replică.

pg_basebackup se conectează la server folosind protocolul de replicare și copiază directorul de date în timp ce serverul funcționează normal. Pentru că fișierele se modifică în timpul copierii, copia singură nu este consistentă: are nevoie de WAL-ul generat între începutul și finalul backup-ului, pe care îl aplică la pornire.

Opțiuni importante:

  • -D dir: directorul destinație.
  • -F p sau -F t: format plain (fișiere, gata de pornit) sau tar.
  • -X stream (implicit în versiunile noi): deschide o a doua conexiune care transmite WAL-ul în timpul backup-ului, ca acesta să fie complet chiar dacă segmentele sunt reciclate pe server între timp.
  • -R: scrie standby.signal și setările primary_conninfo în postgresql.auto.conf, ca la pornire copia să devină o replică a serverului sursă.
  • -C -S nume_slot: creează un slot de replicare pentru noua replică.
  • -c fast: cere un checkpoint imediat, ca backup-ul să pornească repede.
  • -P: afișează progresul.
  • --incremental (PostgreSQL 17+): backup incremental față de unul anterior, folosind WAL summaries; se combină apoi cu pg_combinebackup.
BASH
# Pe serverul nou, care va deveni replică
pg_basebackup -h primar.intern -U replicare \
  -D /var/lib/postgresql/17/main -Fp -Xs -R -C -S replica2 -c fast -P

# Pe primar, utilizatorul are nevoie de rolul REPLICATION și de o linie în pg_hba.conf:
# host  replication  replicare  10.0.1.0/24  scram-sha-256

Pentru backup-uri de producție cu retenție, compresie, criptare, verificare și restaurare la un moment anume, echipele folosesc de obicei unelte dedicate ca pgBackRest sau Barman, care se bazează pe aceleași mecanisme. pg_basebackup rămâne unealta standard pentru a crea rapid o replică nouă.

Ce urmărește intervievatorul: Se verifică dacă știi uneltele de bază pentru backup fizic și crearea replicilor. Explicarea motivului pentru -X stream arată că înțelegi de ce un backup online are nevoie de WAL.

50 Mid

Explică Point-In-Time Recovery (PITR). Ce îți trebuie și care sunt pașii?

Răspuns scurt: PITR înseamnă restaurarea bazei de date la un moment exact, de exemplu cu un minut înainte de o ștergere greșită. Ai nevoie de un backup fizic de bază și de toate segmentele de WAL arhivate de atunci. Restaurezi backup-ul, setezi restore_command și recovery_target_time, pornești serverul în recovery și apoi îl promovezi.

PITR combină două lucruri:

  • un backup fizic de bază (base backup), făcut cu pg_basebackup sau o unealtă dedicată;
  • arhiva continuă de WAL, configurată pe primar:
INI
# postgresql.conf pe primar
wal_level = replica
archive_mode = on
archive_command = 'test ! -f /arhiva/wal/%f && cp %p /arhiva/wal/%f'
# în producție: pgbackrest --stanza=main archive-push %p

Pornind de la backup, PostgreSQL reaplică segmentele de WAL în ordine și se oprește exact la momentul cerut.

Pașii unei recuperări manuale:

BASH
systemctl stop postgresql
mv /var/lib/postgresql/17/main /var/lib/postgresql/17/main.vechi   # nu șterge nimic încă
tar -xf /backup/base.tar -C /var/lib/postgresql/17/main
INI
# postgresql.auto.conf (sau postgresql.conf)
restore_command = 'cp /arhiva/wal/%f %p'
recovery_target_time = '2026-11-04 14:31:00+02'
recovery_target_action = 'pause'
BASH
touch /var/lib/postgresql/17/main/recovery.signal
systemctl start postgresql

Cu recovery_target_action = 'pause', serverul se oprește la ținta aleasă și acceptă interogări doar de citire. Verifici dacă datele sunt cele dorite. Dacă ai ales un moment prea târziu, oprești și reiei cu altă țintă; dacă e corect, rulezi SELECT pg_wal_replay_resume(); sau pg_promote(), iar serverul devine scriibil pe o timeline nouă.

Alte ținte posibile: recovery_target_xid, recovery_target_lsn, recovery_target_name (un punct creat dinainte cu pg_create_restore_point('inainte_de_migrare')) și recovery_target = 'immediate' (cel mai devreme punct consistent).

Cel mai des, PITR nu se face peste serverul de producție, ci pe un server separat, de unde extragi doar datele pierdute și le reintroduci în producție. Uneltele ca pgBackRest simplifică totul la o singură comandă de restore cu --type=time.

Ce urmărește intervievatorul: PITR este capacitatea cheie de recuperare pe care o așteaptă un angajator de la un DBA. Intervievatorul verifică dacă știi pașii concreți și precauțiile, nu doar conceptul.

51 Mid

Un coleg a rulat din greșeală DELETE FROM comenzi fără WHERE la ora 14:32. Cum recuperezi datele cu impact minim?

Răspuns scurt: Nu restaurezi peste producție. Faci PITR pe un server separat până la 14:31, extragi rândurile din comenzi și le reinserezi în producție, ținând cont de comenzile noi apărute după incident. Dacă există o replică întârziată, o folosești ca sursă mai rapidă.

Prima regulă: nu acționa în grabă peste producție. O restaurare completă a clusterului la 14:31 ar șterge toate modificările legitime făcute după incident, în toate tabelele.

Pașii:

  • Stabilește momentul exact și impactul. Caută în logurile PostgreSQL (log_statement = 'mod' sau pgaudit, dacă sunt active) sau în pg_stat_statements ora și utilizatorul. Dacă nu ai ora exactă, poți găsi LSN-ul tranzacției în WAL cu pg_waldump.
  • Oprește răul să se extindă. Dacă aplicația scrie comenzi noi care depind de cele șterse, discuți cu echipa despre punerea temporară a funcției în mentenanță.
  • Recuperare pe un server separat, la un moment dinaintea ștergerii:
BASH
pgbackrest --stanza=main --pg1-path=/srv/recuperare --type=time \
  --target="2026-11-04 14:31:30+02" --target-action=pause restore
  • Extrage datele din serverul de recuperare:
BASH
pg_dump -h recuperare -d magazin -t comenzi --data-only -Fc -f comenzi_14_31.dump
  • Reintrodu-le controlat în producție, într-un tabel separat, apoi doar rândurile lipsă:
SQL
CREATE TABLE recuperare.comenzi_14_31 (LIKE public.comenzi INCLUDING ALL);
-- pg_restore -d magazin -n recuperare ... sau \copy
BEGIN;
INSERT INTO public.comenzi
SELECT r.* FROM recuperare.comenzi_14_31 r
WHERE NOT EXISTS (SELECT 1 FROM public.comenzi c WHERE c.id = r.id);
-- verifici numerele, apoi COMMIT

Atenție la cheile străine cu ON DELETE CASCADE: e posibil ca și liniile comenzilor sau plățile să fi fost șterse în cascadă. Verifică toate tabelele dependente.

Prevenție după incident: drepturi limitate în producție (oamenii nu lucrează cu roluri care pot șterge orice), psql configurat cu \set AUTOCOMMIT off pentru intervenții manuale, o replică întârziată (recovery_min_apply_delay = '1h') ca sursă rapidă de recuperare și postmortem fără vinovați.

Ce urmărește intervievatorul: Este un scenariu real și frecvent. Intervievatorul verifică dacă alegi recuperarea țintită în locul restaurării complete și dacă te gândești la cascade și la datele noi apărute după incident.

52 Mid

Ce unelte folosești pentru backup în producție (pgBackRest, Barman) și ce oferă în plus față de pg_basebackup?

Răspuns scurt: pgBackRest și Barman gestionează backup-uri complete, diferențiale și incrementale, arhivarea WAL în paralel, compresia, criptarea, retenția, verificarea și restaurarea la un moment anume cu o singură comandă, inclusiv către stocare de tip S3.

pg_basebackup și o comandă cp în archive_command sunt suficiente pentru a înțelege mecanismul, dar nu pentru producție. Scripturile proprii ratează des cazuri: arhivare care eșuează fără alertă, fișiere WAL suprascrise, lipsa retenției, restaurare netestată.

pgBackRest (foarte răspândit):

  • backup full, diferențial (față de ultimul full) și incremental (față de ultimul backup de orice tip);
  • arhivare WAL asincronă și în paralel (archive-push, archive-get), importantă când primarul generează mult WAL;
  • compresie (zstd, lz4), criptare, verificarea sumelor de control;
  • retenție automată (de exemplu păstrează ultimele 4 backup-uri full și WAL-ul lor);
  • depozite (repository) locale sau în S3, Azure, GCS, inclusiv mai multe depozite simultan;
  • restaurare --delta, care copiază doar fișierele diferite, și PITR cu o singură comandă;
  • backup de pe o replică, ca primarul să nu fie încărcat.
BASH
pgbackrest --stanza=main stanza-create
pgbackrest --stanza=main check                 # verifică arhivarea WAL
pgbackrest --stanza=main --type=full backup
pgbackrest --stanza=main --type=incr backup
pgbackrest --stanza=main info                  # backup-uri și intervalul de WAL
INI
# postgresql.conf
archive_mode = on
archive_command = 'pgbackrest --stanza=main archive-push %p'

Barman (de la EDB) oferă funcții similare, cu un server central care administrează backup-urile mai multor clustere și poate primi WAL prin streaming (pg_receivewal), deci cu RPO aproape zero chiar fără arhivare pe fișiere.

WAL-G este o alternativă populară în mediile cloud, orientată spre stocarea în obiecte.

Indiferent de unealtă, regulile rămân: backup-urile stau pe alt sistem decât baza de date (ideal în altă regiune), restaurarea se testează automat, iar alertele acoperă atât backup-ul eșuat, cât și arhivarea WAL rămasă în urmă (pg_stat_archiver).

Ce urmărește intervievatorul: Se verifică dacă știi uneltele reale folosite în industrie. Un candidat care propune doar scripturi cu pg_dump pentru o bază mare de producție nu a lucrat încă la scară.

53 Senior

Cum proiectezi strategia de backup și recuperare pentru o bază de date critică? Ce înseamnă RPO și RTO?

Răspuns scurt: RPO este cantitatea maximă de date pe care firma acceptă să o piardă, măsurată în timp; RTO este cât timp poate sta sistemul oprit. Pornești de la aceste cerințe și alegi combinația: backup fizic cu arhivare continuă de WAL, replici (inclusiv întârziate), copii în altă regiune, retenție și teste de restaurare.

Strategia se construiește de la cerințele firmei spre tehnologie, nu invers.

1. Cerințele. Discuți cu business-ul:

  • RPO (Recovery Point Objective): câte date pot fi pierdute? 24 de ore pentru un sistem intern, câteva secunde pentru plăți.
  • RTO (Recovery Time Objective): cât poate dura indisponibilitatea? 4 ore sau 5 minute?
  • Retenția: cât de departe în trecut trebuie să poți merge (obligații legale, de exemplu ani pentru date financiare)?
  • Scenariile acoperite: căderea unui server, pierderea unei zone sau regiuni, o eroare umană, ransomware, o corupere silențioasă descoperită după săptămâni.

2. Straturile soluției, fiecare pentru alt scenariu:

  • Cade primarul: replică sincronă sau asincronă cu failover automat (Patroni); RPO de secunde, RTO sub un minut.
  • Eroare umană recentă: replică întârziată sau PITR; RPO și RTO de minute până la zeci de minute.
  • Pierderea regiunii: replică și backup în altă regiune; RPO de secunde sau minute, RTO de ore.
  • Ransomware sau ștergerea backup-urilor: copii imuabile (object lock), în conturi separate; RPO și RTO de ore.
  • Corupere veche, descoperită târziu: retenție lungă de backup-uri full; RPO de zile, RTO de ore.

3. Implementarea: pgBackRest cu backup full săptămânal, diferențial zilnic, arhivare WAL asincronă în două depozite (local și în altă regiune, cu criptare și imutabilitate); archive_timeout ca WAL-ul să fie arhivat și când traficul e mic; dump-uri logice zilnice pentru restaurări punctuale.

4. Verificarea: test automat de restaurare cu măsurarea timpului real față de RTO, alerte pe vârsta ultimului backup reușit și pe întârzierea arhivării, exerciții periodice de recuperare după dezastru.

5. Documentarea: un runbook pe care îl poate urma un coleg la 3 noaptea, cu comenzi exacte, cine decide și cum se comunică.

Ultima idee pe care aș spune-o la interviu: replicarea nu este backup. Un DROP TABLE ajunge în câteva milisecunde și pe toate replicile. Doar backup-urile istorice și replicile întârziate te protejează de erori logice.

Ce urmărește intervievatorul: Este o întrebare de arhitectură. Intervievatorul evaluează dacă pornești de la cerințele firmei, dacă acoperi mai multe scenarii și dacă știi că replicarea nu înlocuiește backup-ul.

54 Senior

Baza de date are 3 TB, iar restaurarea completă durează 9 ore, peste RTO-ul de 2 ore. Ce opțiuni ai?

Răspuns scurt: Reduci timpul de recuperare prin replici gata de promovat, restaurare delta și paralelă, backup-uri incrementale mai dese ca să fie mai puțin WAL de reaplicat, snapshot-uri de disc, infrastructură mai rapidă și reducerea volumului prin arhivarea datelor vechi și partiționare.

Mai întâi descompun cele 9 ore: cât durează copierea fișierelor de backup, cât reaplicarea WAL-ului și cât verificările și repornirea aplicației? Fiecare parte are alte soluții.

1. Să nu mai ai nevoie de restaurare în scenariul principal. Pentru căderea unui server, o replică fizică sincronizată, cu failover automat (Patroni sau serviciul gestionat din cloud), aduce RTO la sub un minut. Restaurarea din backup rămâne pentru dezastre și erori logice.

2. Copiere mai rapidă.

  • restaurare paralelă (pgbackrest --process-max=16 restore), depozitul de backup aproape de serverul de restaurare și conexiune de rețea suficientă;
  • --delta: dacă reconstruiești un server care are deja o copie veche a datelor, se copiază doar fișierele modificate;
  • compresie rapidă (lz4, zstd la nivel mic) în locul celor lente;
  • snapshot-uri de disc (EBS, LVM, ZFS), din care un volum de 3 TB poate fi disponibil în minute, cu încărcarea datelor în fundal.

3. Mai puțin WAL de reaplicat. Dacă ultimul backup full e de acum 6 zile, recuperarea reaplică WAL pe 6 zile. Backup-urile diferențiale sau incrementale zilnice scurtează serios această etapă. Setările de recovery contează și ele: recovery_prefetch (din PostgreSQL 15) și maintenance_io_concurrency mai mari, plus shared_buffers adecvat pe serverul de restaurare.

4. Mai puține date. Adesea 2 TB din cei 3 TB sunt istorice: loguri, evenimente, comenzi de acum 7 ani. Partiționarea și mutarea partițiilor vechi într-o bază de arhivă (sau în stocare ieftină, ca fișiere Parquet) reduce baza critică. Bloat-ul eliminat cu pg_repack scade și el dimensiunea. Indecșii nefolosiți ocupă și ei spațiu în backup.

5. Recuperare în trepte. Pentru unele sisteme e acceptabil să pornești întâi doar baza „caldă” (ultimul an de date) și să restaurezi istoricul ulterior.

6. Infrastructura. Discuri cu throughput mai mare pe serverul de restaurare, un server de rezervă pregătit, automatizarea completă a pașilor.

La final, măsor din nou într-un test real și prezint compromisurile de cost: o replică permanentă în plus costă bani, dar mai puțin decât 9 ore de indisponibilitate.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă o descompunere a problemei și mai multe pârghii, cu compromisurile lor. Un senior nu se oprește la „cumpărăm discuri mai rapide”.

Replicare, failover și disponibilitate ridicată

55 Junior

Ce este streaming replication și cum configurezi o replică de citire?

Răspuns scurt: Streaming replication înseamnă că o replică (standby) primește continuu WAL-ul de la primar printr-o conexiune și îl aplică, fiind o copie fizică identică. O configurezi cu un utilizator de replicare, o regulă în pg_hba.conf, un pg_basebackup -R și pornirea replicii.

Într-o replicare fizică, primarul trimite fluxul de WAL prin procesul walsender, iar replica îl primește prin walreceiver și îl reaplică prin procesul de startup. Replica este o copie bit cu bit a întregului cluster. Cu hot_standby = on (implicit), acceptă interogări doar de citire.

Pe primar:

SQL
CREATE ROLE replicare WITH REPLICATION LOGIN PASSWORD '...';
INI
# postgresql.conf (valorile implicite din versiunile noi sunt de obicei suficiente)
wal_level = replica
max_wal_senders = 10
max_replication_slots = 10
# pg_hba.conf
host  replication  replicare  10.0.1.20/32  scram-sha-256

Pe replică (cu directorul de date gol):

BASH
pg_basebackup -h 10.0.1.10 -U replicare -D /var/lib/postgresql/17/main \
  -Fp -Xs -R -C -S replica1 -P
systemctl start postgresql

-R creează standby.signal și scrie primary_conninfo, iar -C -S replica1 creează un slot de replicare, ca primarul să păstreze WAL-ul până îl primește replica.

Verificare:

SQL
-- pe primar
SELECT client_addr, state, sent_lsn, replay_lsn, replay_lag FROM pg_stat_replication;
-- pe replică
SELECT pg_is_in_recovery(), pg_last_wal_replay_lsn(), now() - pg_last_xact_replay_timestamp() AS intarziere;

Replica poate prelua rapoarte și interogări de citire, reducând încărcarea primarului, și este baza pentru failover. Aplicația trebuie însă să știe că datele de pe replică pot fi ușor în urmă: după ce un utilizator își schimbă parola, nu e bine ca verificarea imediat următoare să citească de pe replică.

Ce urmărește intervievatorul: Este fundamentul disponibilității ridicate în PostgreSQL. Intervievatorul verifică dacă poți configura o replică de la zero și dacă știi cum confirmi că funcționează.

56 Junior

Care e diferența dintre replicarea sincronă și cea asincronă?

Răspuns scurt: La replicarea asincronă primarul confirmă COMMIT fără să aștepte replica, deci e rapidă, dar la un failover se pot pierde ultimele tranzacții. La cea sincronă primarul așteaptă confirmarea replicii, deci nu se pierd date, dar fiecare COMMIT devine mai lent și depinde de disponibilitatea replicii.

Asincronă (implicit): primarul scrie WAL-ul local, confirmă COMMIT aplicației și trimite WAL-ul către replici cât de repede poate. Dacă primarul cade iremediabil, tranzacțiile confirmate dar încă netrimise se pierd. De obicei e vorba de sub o secundă de date, dar sub încărcare mare sau cu rețea lentă poate fi mai mult.

Sincronă: primarul așteaptă, înainte să confirme COMMIT, ca cel puțin o replică să confirme că a primit WAL-ul. Se configurează cu:

INI
synchronous_standby_names = 'ANY 1 (replica_a, replica_b)'
synchronous_commit = on

Numele trebuie să corespundă cu application_name din primary_conninfo al fiecărei replici.

Nivelurile lui synchronous_commit arată ce înseamnă exact „confirmat”:

  • remote_write: replica a primit WAL-ul și l-a transmis sistemului de operare;
  • on: replica l-a scris și pe disc (fsync);
  • remote_apply: replica l-a și aplicat, deci o citire de pe replică vede imediat modificarea;
  • local: doar discul local, fără să aștepte replica;
  • off: nici măcar discul local nu este așteptat.

Compromisuri:

  • Fiecare COMMIT adaugă latența unui drum dus-întors prin rețea. În aceeași zonă de disponibilitate e vorba de sub o milisecundă, între regiuni zeci de milisecunde.
  • Dacă singura replică sincronă cade, scrierile pe primar se blochează. De aceea se folosesc cel puțin două replici cu ANY 1, sau un manager de cluster (Patroni) care ajustează automat lista.

synchronous_commit se poate seta și per tranzacție: plățile pot rula cu on, iar logurile de activitate cu local, pe același server.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi compromisul dintre siguranța datelor și performanță. Riscul de blocare cu o singură replică sincronă este detaliul pe care îl caută.

57 Junior

Cum măsori întârzierea (lag-ul) unei replici și ce cauze poate avea un lag mare?

Răspuns scurt: Pe primar, în pg_stat_replication compari LSN-urile (sent, write, flush, replay) și coloanele write_lag, flush_lag, replay_lag; pe replică, compari now() cu pg_last_xact_replay_timestamp(). Cauzele tipice sunt rețeaua, discul lent al replicii, interogări lungi care blochează aplicarea WAL sau un volum mare de WAL pe primar.

Pe primar:

SQL
SELECT application_name, client_addr, state, sync_state,
       pg_size_pretty(pg_wal_lsn_diff(pg_current_wal_lsn(), sent_lsn))   AS netrimis,
       pg_size_pretty(pg_wal_lsn_diff(pg_current_wal_lsn(), replay_lsn)) AS neaplicat,
       write_lag, flush_lag, replay_lag
FROM pg_stat_replication;

Diferența de LSN arată câți octeți de WAL sunt în urmă, iar coloanele *_lag arată timpul. Separarea pe etape te ajută la diagnostic: dacă sent_lsn e în urmă, problema e la trimitere (rețea, primarul ocupat); dacă flush_lsn e la zi, dar replay_lsn în urmă, replica primește datele, dar nu le aplică destul de repede.

Pe replică:

SQL
SELECT now() - pg_last_xact_replay_timestamp() AS intarziere,
       pg_last_wal_receive_lsn(), pg_last_wal_replay_lsn();

Atenție: dacă primarul nu primește scrieri, ultima tranzacție aplicată devine „veche”, iar formula raportează o întârziere care crește, deși replica este la zi. De aceea, monitorizarea folosește des un tabel „heartbeat” actualizat la câteva secunde pe primar.

Cauze frecvente ale unui lag mare:

  • rețea saturată sau cu latență mare (replici în altă regiune);
  • disc lent pe replică, sau o replică cu resurse mai mici decât primarul;
  • conflicte cu interogări lungi pe replică: cu max_standby_streaming_delay mare, aplicarea WAL așteaptă după rapoarte;
  • operații masive pe primar: un CREATE INDEX sau o actualizare pe sute de milioane de rânduri generează mult WAL dintr-o dată;
  • aplicarea WAL este în mare parte un singur proces, deci o replică poate rămâne în urmă la volume foarte mari de scriere.

Setează alerte pe lag atât în octeți, cât și în secunde. Și verifică regulat dimensiunea pg_wal pe primar, pentru că o replică în urmă cu slot activ face ca WAL-ul să se acumuleze.

Ce urmărește intervievatorul: Lag-ul replicilor este una dintre metricile principale ale unui DBA. Intervievatorul vrea să vadă că știi unde să te uiți și cum interpretezi etapele lag-ului.

58 Mid

Ce sunt sloturile de replicare și ce risc au?

Răspuns scurt: Un slot de replicare face ca primarul să păstreze WAL-ul (și, la cele logice, să rețină versiunile vechi din catalog) până când consumatorul confirmă că l-a primit. Riscul este că un consumator oprit sau abandonat face ca WAL-ul să se acumuleze până umple discul primarului.

Fără slot, primarul păstrează WAL-ul doar conform wal_keep_size. Dacă o replică este oprită mai mult, segmentele de care are nevoie sunt reciclate și replica trebuie reconstruită de la zero (sau recuperată din arhiva de WAL).

Un slot de replicare reține poziția (LSN) până la care consumatorul a confirmat primirea. Primarul nu șterge niciun segment de WAL mai nou decât acea poziție. Sloturile sunt fizice (pentru replici) sau logice (pentru replicarea logică și pentru unelte de tip CDC, ca Debezium).

SQL
SELECT slot_name, slot_type, active, wal_status, safe_wal_size,
       pg_size_pretty(pg_wal_lsn_diff(pg_current_wal_lsn(), restart_lsn)) AS wal_retinut
FROM pg_replication_slots;

-- Ștergerea unui slot abandonat (după ce confirmi că nu mai e folosit)
SELECT pg_drop_replication_slot('replica_veche');

Riscul principal: o replică scoasă din uz fără ștergerea slotului sau un consumator CDC oprit. Slotul rămâne inactiv, WAL-ul se acumulează cu fiecare tranzacție, iar după câteva ore sau zile discul primarului se umple și PostgreSQL se oprește. Sloturile logice și cele fizice cu hot_standby_feedback țin în plus un xmin vechi, care blochează VACUUM și poate apropia baza de wraparound.

Protecții:

INI
max_slot_wal_keep_size = '100GB'     # peste această limită slotul este invalidat, nu se umple discul
idle_replication_slot_timeout = '2d' # PostgreSQL 18+: invalidează sloturile inactive prea mult timp

Plus alerte pe active = false și pe WAL-ul reținut de fiecare slot. Când un slot este invalidat (wal_status = 'lost'), consumatorul trebuie reinițializat, ceea ce e mult mai puțin grav decât oprirea primarului.

Ce urmărește intervievatorul: Sloturile abandonate sunt o cauză clasică de discuri pline în producție. Intervievatorul vrea să vadă că știi să le monitorizezi și să le limitezi cu max_slot_wal_keep_size.

59 Mid

Ce sunt conflictele de recuperare pe o replică hot standby și ce face hot_standby_feedback?

Răspuns scurt: Un conflict apare când WAL-ul de aplicat pe replică ar șterge versiuni de rând de care are nevoie o interogare care rulează pe replică. Replica fie amână aplicarea WAL, fie anulează interogarea. hot_standby_feedback = on spune primarului ce versiuni sunt încă necesare, ca VACUUM să nu le curețe, cu prețul unui bloat mai mare pe primar.

Pe primar, VACUUM șterge versiunile de rând pe care nicio tranzacție de pe primar nu le mai vede. Dar primarul nu știe, implicit, de un raport care rulează de 20 de minute pe replică și care are nevoie exact de acele versiuni. Când replica primește WAL-ul care conține curățarea, apare un conflict.

Replica are două opțiuni, controlate de max_standby_streaming_delay (și max_standby_archive_delay):

  • amână aplicarea WAL până la limita setată (implicit 30 de secunde), timp în care lag-ul replicii crește;
  • după limită, anulează interogarea:
ERROR:  canceling statement due to conflict with recovery
DETAIL:  User query might have needed to see row versions that must be removed.

Alte tipuri de conflicte: lock-uri exclusive luate pe primar (de exemplu DROP TABLE sau trunchierea fișierului la vacuum), ștergerea unui tablespace sau a unei baze de date. Le vezi în pg_stat_database_conflicts pe replică.

Opțiuni, fiecare cu un compromis:

  • hot_standby_feedback = on pe replică: aceasta trimite primarului xmin-ul celei mai vechi interogări, iar VACUUM pe primar nu mai curăță acele versiuni. Interogările nu mai sunt anulate din acest motiv, dar un raport foarte lung pe replică produce bloat pe primar.
  • max_standby_streaming_delay mare (sau -1, infinit): interogările nu sunt anulate, dar replica poate rămâne în urmă cu mult. Acceptabil pentru o replică dedicată rapoartelor, inacceptabil pentru una folosită la failover.
  • Replici separate pe roluri: una pentru failover, cu setări stricte, și una pentru analize, cu întârziere permisă.

Pe lângă setări, interogările de raportare foarte lungi pot fi mutate într-un sistem dedicat analizei, alimentat prin replicare logică sau ETL.

Ce urmărește intervievatorul: Este o problemă frecventă când echipele încep să trimită rapoarte pe replici. Intervievatorul verifică dacă știi compromisul dintre anularea interogărilor, lag și bloat pe primar.

60 Mid

Care e diferența dintre replicarea fizică și replicarea logică? Când folosești replicarea logică?

Răspuns scurt: Replicarea fizică copiază tot clusterul la nivel de blocuri, iar replica este read-only și pe aceeași versiune majoră. Replicarea logică transmite modificările rând cu rând pentru tabelele alese, prin publicații și abonamente, între versiuni diferite, iar destinația rămâne scriibilă. O folosești la upgrade-uri cu întrerupere minimă, consolidări de date și CDC.

Fizică (streaming):

  • copiază WAL-ul exact, deci replica este identică bit cu bit cu primarul, pentru tot clusterul;
  • replica este doar de citire și trebuie să aibă aceeași versiune majoră și aceeași arhitectură;
  • replică tot: DDL, indecși, secvențe, toate bazele de date;
  • este alegerea standard pentru disponibilitate ridicată și failover.

Logică:

  • decodifică WAL-ul în modificări de rânduri (INSERT, UPDATE, DELETE, TRUNCATE) pentru tabelele dintr-o publicație;
  • destinația este un server PostgreSQL normal, scriibil, care se abonează; poate avea altă versiune majoră, alți indecși sau doar o parte din tabele și coloane;
  • necesită wal_level = logical pe sursă.
SQL
-- Pe sursă
CREATE PUBLICATION pub_magazin FOR TABLE clienti, comenzi, produse;

-- Pe destinație (schema trebuie creată înainte, de exemplu cu pg_dump --schema-only)
CREATE SUBSCRIPTION sub_magazin
  CONNECTION 'host=sursa dbname=magazin user=replicare_logica'
  PUBLICATION pub_magazin;

SELECT * FROM pg_stat_subscription;

Limitări importante:

  • DDL-ul nu se replică: o coloană nouă trebuie adăugată manual pe ambele părți, în ordinea corectă (întâi pe destinație).
  • Secvențele nu se sincronizează (PostgreSQL 18 aduce un prim suport, dar la un upgrade le setezi manual înainte de comutare).
  • Tabelele au nevoie de cheie primară sau de un REPLICA IDENTITY pentru UPDATE și DELETE.
  • Conflictele (de exemplu, un rând deja existent pe destinație) opresc abonamentul până le rezolvi.
  • Obiectele mari (large objects) nu se replică.

Utilizări: upgrade de versiune majoră aproape fără întrerupere, migrarea către alt server sau către cloud, replicarea unui subset de tabele către o bază de raportare, consolidarea mai multor baze de date într-una singură și CDC către alte sisteme (Kafka, prin Debezium).

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi ce instrument potrivit să alegi. Limitările replicării logice (DDL, secvențe, cheie primară) sunt cele care contează în proiectele reale.

61 Mid

Cum faci un switchover planificat de pe primar pe o replică și ce rol are pg_rewind?

Răspuns scurt: Oprești scrierile, aștepți ca replica să fie complet la zi, oprești curat primarul, promovezi replica și muți aplicația pe ea, apoi transformi vechiul primar în replică. pg_rewind sincronizează un fost primar care a divergit de noul primar, fără un nou backup complet.

Un switchover este o schimbare controlată a primarului, de exemplu pentru mentenanța serverului sau pentru a testa procedura. Spre deosebire de un failover după o cădere, nu trebuie să se piardă nicio tranzacție.

Pași (manual, fără un manager de cluster):

  • Verifici că replica este sănătoasă și aproape la zi (pg_stat_replication).
  • Oprești sau pui în mentenanță aplicațiile care scriu, sau treci conexiunile prin PgBouncer în pauză (PAUSE).
  • Oprești curat primarul: pg_ctl stop -m fast. La o oprire curată, primarul trimite tot WAL-ul, inclusiv checkpoint-ul final, către replicile conectate.
  • Confirmi pe replică faptul că a primit tot (pg_last_wal_replay_lsn() egal cu ultimul LSN al primarului, vizibil cu pg_controldata).
  • Promovezi replica: SELECT pg_promote(); sau pg_ctl promote. Ea trece pe o timeline nouă și acceptă scrieri.
  • Muți aplicația: DNS, IP virtual, configurația PgBouncer sau a proxy-ului (HAProxy).
  • Transformi vechiul primar în replică: creezi standby.signal, setezi primary_conninfo către noul primar și îl pornești.

pg_rewind intervine când vechiul primar a primit scrieri care nu au ajuns la replică (de exemplu după un failover neplanificat). Timeline-urile au divergit, iar vechiul primar nu poate deveni direct replică. pg_rewind compară cele două clustere și copiază de pe noul primar doar blocurile modificate după punctul de divergență:

BASH
pg_rewind --target-pgdata=/var/lib/postgresql/17/main \
  --source-server='host=noul-primar user=postgres dbname=postgres' --progress

Are nevoie de wal_log_hints = on sau de data checksums activate. Tranzacțiile de pe vechiul primar care nu au ajuns la replică sunt pierdute din acel server; dacă sunt importante, le extragi înainte.

În practică, cu Patroni comanda patronictl switchover face toți acești pași și include pg_rewind automat.

Ce urmărește intervievatorul: Switchover-ul este o operațiune de rutină pentru un DBA. Intervievatorul urmărește oprirea curată, verificarea LSN-ului și înțelegerea rolului pg_rewind.

62 Senior

Cum funcționează failover-ul automat cu Patroni și cum previi situația de split-brain?

Răspuns scurt: Patroni rulează lângă fiecare PostgreSQL și folosește un depozit distribuit de consens (etcd, Consul) pentru un lock de lider cu durată limitată. Doar nodul care deține lock-ul este primar. Dacă nu îl poate reînnoi, se retrogradează singur, iar o replică sănătoasă îl preia. Split-brain-ul se previne prin consens, fencing, watchdog și rutarea traficului doar spre liderul curent.

Split-brain înseamnă două servere care acceptă scrieri în același timp, fiecare crezând că este primarul. Datele divergă și reconcilierea poate fi foarte dificilă. Un failover automat naiv („replica nu mai vede primarul, deci se promovează”) produce exact asta la o simplă problemă de rețea.

Cum lucrează Patroni:

  • Pe fiecare nod rulează un agent Patroni care pornește, oprește și configurează PostgreSQL.
  • Starea clusterului se ține într-un DCS (etcd, Consul, ZooKeeper sau API-ul Kubernetes), care oferă consens prin cvorum, deci are nevoie de minimum 3 noduri.
  • Primarul deține o cheie de lider cu TTL (de exemplu 30 de secunde) și o reînnoiește periodic.
  • Dacă primarul pierde legătura cu DCS-ul și nu poate reînnoi cheia, se retrogradează singur în replică. Acesta este punctul esențial: un primar izolat nu continuă să accepte scrieri.
  • Când cheia expiră, replicile concurează pentru ea. Câștigă una care este suficient de la zi (maximum_lag_on_failover) și eligibilă, iar celelalte se reconfigurează să replice de la ea. Fostul primar revine ca replică, de obicei cu pg_rewind.

Straturi suplimentare de protecție:

  • watchdog (/dev/watchdog): dacă agentul Patroni se blochează, sistemul de operare repornește nodul înainte să expire cheia, ca un PostgreSQL rămas fără supraveghere să nu poată scrie;
  • rutarea traficului pe baza stării reale: HAProxy verifică endpoint-ul REST al Patroni (/primary), sau serviciile Kubernetes se actualizează la schimbarea liderului; aplicația nu se conectează direct la un IP fix al unui server;
  • synchronous_mode în Patroni, pentru failover fără pierdere de date: se promovează doar o replică sincronă;
  • DCS-ul și nodurile împărțite pe cel puțin trei zone de disponibilitate.

Testare: oprești primarul, tai rețeaua între zone, oprești DCS-ul, cronometrezi failover-ul și verifici că aplicația se reconectează. Un failover automat netestat poate face mai mult rău decât unul manual bine documentat.

Ce urmărește intervievatorul: Este o întrebare de arhitectură de disponibilitate ridicată. Intervievatorul caută înțelegerea consensului, a lock-ului cu TTL și a retrogradării primarului izolat, nu doar numele unei unelte.

63 Senior

Proiectează o arhitectură PostgreSQL cu disponibilitate ridicată pe trei zone de disponibilitate. Ce compromisuri discuți?

Răspuns scurt: Un primar și două replici în zone diferite, gestionate de Patroni cu etcd pe trei zone, PgBouncer și un proxy care urmează liderul, replicare sincronă cu ANY 1 ca să nu pierzi date fără să blochezi scrierile la căderea unei replici, plus backup în altă regiune. Compromisurile sunt latența, costul, complexitatea operațională și RPO-ul.

O arhitectură tipică:

           aplicație (în toate zonele)
                     │
          PgBouncer + HAProxy (verifică /primary în Patroni)
         ┌───────────┼───────────┐
     Zona A        Zona B       Zona C
  PostgreSQL     PostgreSQL   PostgreSQL
   primar         replică      replică
  + Patroni      + Patroni    + Patroni
  + etcd         + etcd       + etcd
         └── pgBackRest → stocare obiecte în altă regiune ──┘

Decizii și compromisuri:

1. Replicare sincronă sau asincronă. Cu synchronous_standby_names = 'ANY 1 (b, c)', orice COMMIT este confirmat de cel puțin o altă zonă: RPO zero la căderea unei zone, iar căderea unei singure replici nu blochează scrierile. Costul este latența între zone (de obicei 1–2 ms) la fiecare COMMIT. Pentru sisteme cu scrieri multe și mici, merită măsurat efectul; tranzacțiile mai puțin importante pot folosi synchronous_commit = local.

2. Cvorumul. etcd pe trei zone tolerează pierderea unei zone. Cu doar două zone, nu poți avea un cvorum care să supraviețuiască pierderii unei zone fără risc de split-brain.

3. Rutarea. Aplicația se conectează la un endpoint stabil. HAProxy sau Kubernetes dirijează scrierile doar spre liderul confirmat de Patroni și citirile spre replici, dacă aplicația tolerează date ușor întârziate.

4. Conexiunile. PgBouncer în modul transaction protejează PostgreSQL de mii de conexiuni. Aplicația trebuie să știe să reîncerce după failover, pentru că tranzacțiile în curs sunt pierdute.

5. Recuperarea după dezastru. Disponibilitatea ridicată nu protejează de un DROP TABLE sau de pierderea regiunii. E nevoie de backup cu arhivare WAL în altă regiune, eventual de o replică asincronă acolo, plus opțional de o replică întârziată.

6. Capacitatea. Fiecare replică trebuie să poată prelua singură traficul primarului. Trei servere de aceeași mărime înseamnă cost triplu.

7. Alternativa gestionată. RDS Multi-AZ sau Aurora oferă mult din toate acestea gata făcut, cu mai puțin control asupra configurației și cu alt cost. Pentru o echipă mică, această alegere poate fi mai sigură decât un Patroni administrat fără experiență.

La final, aș defini SLO-ul (de exemplu 99,95%), RPO și RTO și aș programa teste regulate de failover.

Ce urmărește intervievatorul: Intervievatorul evaluează gândirea de arhitect: legătura dintre cerințe și soluție, cvorumul, latența și costul. Mențiunea alternativei gestionate arată pragmatism.

Configurare, conexiuni, securitate și upgrade-uri

64 Junior

Cum funcționează rolurile și drepturile în PostgreSQL? Cum dai unei aplicații doar drepturile de care are nevoie?

Răspuns scurt: În PostgreSQL utilizatorii și grupurile sunt roluri; un rol cu LOGIN se poate conecta, iar unul fără LOGIN servește ca grup. Drepturile se dau cu GRANT pe baze de date, scheme, tabele și secvențe, iar ALTER DEFAULT PRIVILEGES le aplică și obiectelor create în viitor.

Un rol poate fi utilizator (are LOGIN), grup (fără LOGIN, alte roluri sunt membre în el) sau ambele. Drepturile se moștenesc de la grupurile din care faci parte (INHERIT, implicit).

Modelul recomandat: aplicația nu este proprietara tabelelor și nu este superuser. Un rol separat deține schema și rulează migrările, iar aplicația primește doar drepturile de lucru.

SQL
-- Grupuri fără login
CREATE ROLE magazin_owner NOLOGIN;
CREATE ROLE magazin_rw NOLOGIN;
CREATE ROLE magazin_ro NOLOGIN;

-- Utilizatori cu login, membri în grupuri
CREATE ROLE app_web LOGIN PASSWORD '...' IN ROLE magazin_rw;
CREATE ROLE raportare LOGIN PASSWORD '...' IN ROLE magazin_ro;
CREATE ROLE migrari LOGIN PASSWORD '...' IN ROLE magazin_owner;

GRANT CONNECT ON DATABASE magazin TO magazin_rw, magazin_ro;
GRANT USAGE ON SCHEMA public TO magazin_rw, magazin_ro;
GRANT SELECT, INSERT, UPDATE, DELETE ON ALL TABLES IN SCHEMA public TO magazin_rw;
GRANT USAGE, SELECT ON ALL SEQUENCES IN SCHEMA public TO magazin_rw;
GRANT SELECT ON ALL TABLES IN SCHEMA public TO magazin_ro;

-- Tabelele create de acum înainte de rolul migrari primesc automat aceleași drepturi
ALTER DEFAULT PRIVILEGES FOR ROLE migrari IN SCHEMA public
  GRANT SELECT, INSERT, UPDATE, DELETE ON TABLES TO magazin_rw;
ALTER DEFAULT PRIVILEGES FOR ROLE migrari IN SCHEMA public
  GRANT SELECT ON TABLES TO magazin_ro;

Greșeli frecvente:

  • GRANT ... ON ALL TABLES se aplică doar tabelelor existente; fără ALTER DEFAULT PRIVILEGES, tabelul nou de mâine nu va fi accesibil.
  • Default privileges se aplică doar obiectelor create de rolul indicat în FOR ROLE.
  • Aplicația care rulează ca superuser sau ca proprietar poate șterge tabele în urma unei vulnerabilități de tip SQL injection.

Din PostgreSQL 14 există roluri predefinite utile, ca pg_read_all_data și pg_write_all_data, iar pg_monitor dă acces la vederile de monitorizare fără drepturi de superuser. Verifici drepturile cu \dp tabel și \du în psql.

Ce urmărește intervievatorul: Principiul celui mai mic privilegiu este esențial pentru securitate. Intervievatorul verifică dacă știi de ALTER DEFAULT PRIVILEGES, pe care mulți îl descoperă abia după un incident.

65 Junior

Ce rol are fișierul pg_hba.conf și cum citești o linie din el?

Răspuns scurt: pg_hba.conf decide cine se poate conecta, la ce bază de date, de unde și cu ce metodă de autentificare. Liniile se verifică de sus în jos și se aplică prima potrivire. O linie are tipul conexiunii, baza de date, utilizatorul, adresa și metoda.

HBA vine de la „host-based authentication”. Fiecare linie are forma:

# TIP      BAZA_DE_DATE   UTILIZATOR    ADRESA            METODA
local      all            postgres                        peer
host       magazin        app_web       10.0.2.0/24       scram-sha-256
hostssl    magazin        raportare     10.0.3.15/32      scram-sha-256
host       replication    replicare     10.0.1.20/32      scram-sha-256
host       all            all           0.0.0.0/0         reject
  • Tip: local (socket Unix, pe același server), host (TCP, cu sau fără SSL), hostssl (doar TCP criptat), hostnossl.
  • Baza de date: un nume, all, replication (pentru conexiunile de replicare fizică) sau o listă.
  • Utilizator: un rol, all, sau +grup pentru membrii unui grup.
  • Adresa: IP cu mască CIDR. 10.0.2.0/24 înseamnă toate adresele 10.0.2.x.
  • Metoda: scram-sha-256 (parolă, recomandat), md5 (vechi, de evitat), peer (utilizatorul din sistemul de operare trebuie să aibă același nume ca rolul), cert (certificat client), reject, trust (fără parolă, niciodată pe rețea).

Reguli importante:

  • Se aplică prima linie care se potrivește, iar ordinea contează. O linie generală pusă sus le anulează pe cele specifice de dedesubt.
  • După modificare, reîncarci configurația: SELECT pg_reload_conf(); sau systemctl reload postgresql. Nu e nevoie de repornire.
  • Verifici ce a înțeles PostgreSQL din fișier cu SELECT * FROM pg_hba_file_rules;, care arată și erorile de sintaxă.
  • În combinație cu listen_addresses din postgresql.conf: serverul trebuie să asculte pe interfața de rețea, iar firewall-ul sau security group-ul trebuie să permită portul 5432.

Când cineva primește „no pg_hba.conf entry for host ...”, mesajul din log spune exact adresa, utilizatorul și baza de date care nu se potrivesc cu nicio linie.

Ce urmărește intervievatorul: Configurarea accesului este o sarcină zilnică pentru un DBA. Intervievatorul verifică ordinea regulilor, diferența dintre metode și faptul că știi să reîncarci fără repornire.

66 Junior

Ce parametri din postgresql.conf ajustezi primii pe un server nou și ce valori de pornire alegi?

Răspuns scurt: shared_buffers (de obicei în jur de 25% din RAM), effective_cache_size (50–75% din RAM), work_mem (mic, câțiva MB până la zeci de MB), maintenance_work_mem (sute de MB până la 1–2 GB), max_connections, max_wal_size, random_page_cost pe SSD și parametrii de logging.

Valorile implicite ale PostgreSQL sunt foarte prudente, gândite să pornească pe orice mașină. Pentru un server dedicat cu, să zicem, 32 GB RAM și SSD, un punct de plecare rezonabil:

INI
# Memorie
shared_buffers = 8GB                # ~25% din RAM; restul îl folosește cache-ul sistemului de operare
effective_cache_size = 24GB         # doar o indicație pentru optimizator, nu alocă memorie
work_mem = 32MB                     # per operație de sortare/hash, per conexiune; atenție la înmulțire
maintenance_work_mem = 1GB          # VACUUM, CREATE INDEX
# Conexiuni
max_connections = 200               # mai bine puține conexiuni + PgBouncer
# WAL și checkpoint-uri
max_wal_size = 8GB
min_wal_size = 1GB
checkpoint_completion_target = 0.9
# Planificator, pe SSD
random_page_cost = 1.1
effective_io_concurrency = 200
# Logging
log_min_duration_statement = '500ms'
log_checkpoints = on
log_lock_waits = on
log_temp_files = 0
log_autovacuum_min_duration = '10s'
log_line_prefix = '%m [%p] %q%u@%d %a '
# Extensii
shared_preload_libraries = 'pg_stat_statements'

Câteva explicații:

  • shared_buffers foarte mare nu ajută neapărat, pentru că PostgreSQL se bazează și pe cache-ul sistemului de operare.
  • work_mem este cel mai periculos: o interogare complexă poate folosi de mai multe ori work_mem, pentru fiecare nod de sortare sau hash, în fiecare conexiune. 200 de conexiuni × 3 operații × 32 MB înseamnă aproape 19 GB. Valori mari se dau punctual, pe rol sau pe sesiune: ALTER ROLE raportare SET work_mem = '256MB'.
  • max_wal_size prea mic produce checkpoint-uri prea dese, vizibile în log ca „checkpoints are occurring too frequently”.

Unelte ca PGTune dau un prim set de valori, dar ajustarea reală se face după măsurători pe trafic real: rata de cache hit, fișierele temporare din log, frecvența checkpoint-urilor.

Ce urmărește intervievatorul: Se verifică dacă știi parametrii cu impact mare și riscurile lor. Explicația despre work_mem înmulțit cu numărul de conexiuni este răspunsul pe care îl așteaptă orice intervievator.

67 Junior

Ce parametri se aplică la reload și care cer repornirea serverului? Ce face ALTER SYSTEM?

Răspuns scurt: Fiecare parametru are un context: unele se aplică la reload (pg_reload_conf), altele, ca shared_buffers sau max_connections, cer restart, iar altele se pot schimba per sesiune. ALTER SYSTEM scrie valoarea în postgresql.auto.conf, care are prioritate față de postgresql.conf.

Coloana context din pg_settings arată când se aplică un parametru:

  • postmaster: doar la pornirea serverului (shared_buffers, max_connections, shared_preload_libraries, wal_level, listen_addresses);
  • sighup: la reîncărcarea configurației (pg_hba.conf, log_min_duration_statement, majoritatea setărilor autovacuum);
  • superuser și user: se pot schimba și în sesiune, cu SET (work_mem, statement_timeout), de către superuser sau de orice utilizator;
  • internal: valori fixate la compilare, doar de citit.
SQL
SELECT name, setting, unit, context, source, pending_restart
FROM pg_settings
WHERE name IN ('shared_buffers', 'work_mem', 'log_min_duration_statement');

ALTER SYSTEM SET log_min_duration_statement = '250ms';
SELECT pg_reload_conf();

ALTER SYSTEM SET shared_buffers = '8GB';
-- pending_restart devine true; se aplică doar după restart
ALTER SYSTEM RESET shared_buffers;   -- renunți la valoare

ALTER SYSTEM scrie în postgresql.auto.conf, în directorul de date. Acest fișier se citește după postgresql.conf, deci valorile lui au prioritate. Este comod, dar poate crea confuzie: cineva modifică postgresql.conf, iar schimbarea „nu are efect” pentru că există o valoare diferită în fișierul auto. Coloana sourcefile din pg_settings arată de unde vine valoarea curentă.

Ordinea de prioritate, de la cea mai slabă la cea mai puternică: valoarea implicită, postgresql.conf, postgresql.auto.conf, setările pe bază de date (ALTER DATABASE ... SET), pe rol (ALTER ROLE ... SET), pe rol și bază de date, iar la final SET în sesiune.

În echipele mature, configurația se gestionează prin unelte de infrastructură ca cod (Ansible, Patroni, parameter groups în RDS), nu prin modificări manuale, ca serverele să rămână identice și schimbările să fie urmărite.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi să aplici o schimbare fără restart inutil și dacă înțelegi de unde vine o valoare. Confuzia cu postgresql.auto.conf este frecventă în practică.

68 Junior

De ce nu crești pur și simplu max_connections la 5000 când aplicația rămâne fără conexiuni?

Răspuns scurt: Fiecare conexiune PostgreSQL este un proces separat care consumă memorie și CPU, iar peste câteva sute de conexiuni active performanța scade din cauza concurenței pentru resurse. Soluția este un pool de conexiuni, ca PgBouncer, care servește mii de clienți cu câteva zeci de conexiuni reale.

PostgreSQL folosește un model cu un proces de sistem de operare pentru fiecare conexiune. Fiecare proces are propria memorie (de obicei câțiva MB, mai mult cu work_mem și cache-urile de catalog), iar crearea unei conexiuni noi durează milisecunde, cu autentificare și pornirea procesului.

De ce 5000 de conexiuni sunt o problemă:

  • Memorie: 5000 de procese, fiecare cu câțiva MB, plus work_mem în timpul interogărilor, pot epuiza RAM-ul.
  • CPU și contention: un server cu 16 nuclee poate executa efectiv în paralel aproximativ 16 interogări care folosesc CPU. Cu sute de interogări active simultan, procesele se întrerup reciproc, cresc lock-urile interne și latența pentru toată lumea.
  • Snapshot-uri: fiecare tranzacție trebuie să afle ce alte tranzacții sunt active. Versiunile noi au optimizat mult asta, dar costul rămâne.
  • Majoritatea conexiunilor dintr-o aplicație web sunt idle în cea mai mare parte a timpului.
SQL
SELECT state, count(*) FROM pg_stat_activity GROUP BY state;
-- de obicei: câteva active, sute idle
SHOW max_connections;

Soluția corectă este un pool de conexiuni:

  • în aplicație (HikariCP în Java, pool-ul din SQLAlchemy), dimensionat corect, nu cu sute de conexiuni pe fiecare instanță;
  • și/sau un pooler extern, ca PgBouncer, care primește mii de conexiuni de la clienți și le multiplexează pe câteva zeci de conexiuni reale către PostgreSQL.

O formulă de pornire pentru dimensiunea pool-ului de conexiuni active este aproximativ de două până la patru ori numărul de nuclee, ajustată apoi prin măsurători. Rezervă și câteva conexiuni pentru administrare: superuser_reserved_connections și, din PostgreSQL 16, reserved_connections pentru rolul pg_use_reserved_connections.

Ce urmărește intervievatorul: Este o greșeală frecventă la echipele care cresc. Intervievatorul verifică dacă înțelegi modelul cu proces per conexiune și dacă recomanzi pooling în loc de mai multe conexiuni.

69 Junior

Cum faci un upgrade de versiune minoră, de exemplu de la 17.4 la 17.6?

Răspuns scurt: Versiunile minore conțin doar corecturi și sunt compatibile cu formatul datelor, deci instalezi noile binare și repornești serverul. Citești notele de lansare pentru pași suplimentari (de exemplu reindexări) și, cu replici, actualizezi întâi replicile, apoi faci switchover.

PostgreSQL numerotează versiunile ca major.minor (de exemplu 17.6). O versiune minoră nu schimbă formatul fișierelor de date și nu aduce funcționalități noi, doar corecturi de bug-uri și de securitate. Comunitatea recomandă să rulezi mereu ultima versiune minoră a seriei tale.

Pași pe un server simplu (Debian/Ubuntu, pachete PGDG):

BASH
# 1. Citește notele de lansare pentru toate versiunile minore sărite
#    (uneori cer REINDEX pentru anumite tipuri de indecși)
# 2. Verifică backup-ul recent
pgbackrest --stanza=main info
# 3. Instalează binarele noi
sudo apt-get update && sudo apt-get install --only-upgrade postgresql-17
# 4. Repornește (pachetul poate reporni automat; verifică politica)
sudo systemctl restart postgresql@17-main
# 5. Verifică versiunea
psql -c 'SELECT version();'

Întreruperea este doar cât durează repornirea, de obicei câteva secunde. Un CHECKPOINT rulat manual înainte de oprire scurtează timpul de oprire.

Cu replici, pentru întrerupere minimă:

  • Actualizezi și repornești replicile, pe rând.
  • Faci switchover controlat pe o replică deja actualizată.
  • Actualizezi fostul primar, care acum este replică.

O replică cu versiune minoră mai nouă poate replica de la un primar cu versiune minoră mai veche, invers nu este garantat.

Nu uita de extensii (PostGIS, pg_partman), care pot avea propriile actualizări (ALTER EXTENSION postgis UPDATE), și de uneltele client (pg_dump, pgbackrest). Pe servicii gestionate, ca RDS, versiunile minore se pot aplica automat într-o fereastră de mentenanță, pe care o alegi tu.

Ce urmărește intervievatorul: Intervievatorul verifică disciplina operațională: citirea notelor de lansare, backup înainte și ordinea corectă cu replici. Mulți candidați nu știu diferența dintre minor și major la PostgreSQL.

70 Mid

Ce moduri de pooling are PgBouncer și ce limitări are modul transaction?

Răspuns scurt: Session (o conexiune reală pe toată durata sesiunii clientului), transaction (conexiunea reală e dată clientului doar pe durata unei tranzacții) și statement (doar pe durata unei instrucțiuni). Modul transaction este cel mai eficient, dar nu suportă stare de sesiune: SET, advisory locks de sesiune, LISTEN, tabele temporare între tranzacții și, în versiunile vechi, prepared statements.

PgBouncer este un proces ușor care stă între aplicații și PostgreSQL. Clienții se conectează la PgBouncer (de obicei pe portul 6432), care le dă conexiuni reale dintr-un pool.

Modurile:

  • session: clientul primește o conexiune reală când se conectează și o păstrează până se deconectează. Compatibil cu orice, dar câștigul e mic: ajută doar la costul creării conexiunilor.
  • transaction: conexiunea reală este alocată la BEGIN (sau la o instrucțiune în afara unei tranzacții) și eliberată la COMMIT/ROLLBACK. O mie de clienți pot folosi 30 de conexiuni reale, pentru că majoritatea sunt idle în orice moment. Este modul cel mai folosit.
  • statement: conexiunea este eliberată după fiecare instrucțiune; tranzacțiile cu mai multe instrucțiuni nu sunt permise. Rar folosit.
INI
; pgbouncer.ini
[databases]
magazin = host=10.0.1.10 port=5432 dbname=magazin

[pgbouncer]
listen_addr = 0.0.0.0
listen_port = 6432
auth_type = scram-sha-256
auth_file = /etc/pgbouncer/userlist.txt
pool_mode = transaction
default_pool_size = 30
max_client_conn = 3000
max_prepared_statements = 200
server_reset_query =

Ce nu funcționează corect în modul transaction, pentru că tranzacțiile următoare ale aceluiași client pot ajunge pe altă conexiune reală:

  • SET la nivel de sesiune (de exemplu SET search_path); folosește SET LOCAL în tranzacție sau setări pe rol;
  • advisory locks de sesiune; folosește pg_advisory_xact_lock;
  • LISTEN/NOTIFY, cursoarele WITH HOLD, tabelele temporare păstrate între tranzacții;
  • prepared statements la nivel de protocol: suportate din PgBouncer 1.21 cu max_prepared_statements; în versiunile mai vechi trebuiau dezactivate în driver.

Monitorizare: te conectezi la baza virtuală pgbouncer și rulezi SHOW POOLS; (urmărești cl_waiting, clienții care așteaptă o conexiune) și SHOW STATS;. Comenzile PAUSE și RESUME sunt foarte utile la switchover: conexiunile clienților rămân deschise cât muți primarul.

Ce urmărește intervievatorul: PgBouncer este prezent în aproape orice instalare PostgreSQL serioasă. Intervievatorul verifică dacă știi limitările modului transaction, care produc bug-uri greu de diagnosticat.

71 Mid

Cum faci un upgrade de versiune majoră (de exemplu de la 13 la 17)? Compară pg_upgrade, dump/restore și replicarea logică.

Răspuns scurt: pg_dump/pg_restore e simplu, dar lent pe baze mari. pg_upgrade convertește clusterul pe loc; cu --link durează minute, dar necesită oprirea serverului. Replicarea logică către un server nou pe versiunea 17 permite comutarea cu întrerupere de câteva secunde, dar cere mai multă pregătire.

O versiune majoră schimbă formatul catalogului de sistem, deci nu ajunge să instalezi binarele noi. Trei metode:

1. pg_dump + pg_restore: exporți din vechiul server și imporți în cel nou. Simplu și sigur, curăță și bloat-ul. Dar pentru sute de GB durează ore, timp în care aplicația este oprită sau datele noi se pierd.

2. pg_upgrade: convertește clusterul vechi într-unul nou, pe același server.

BASH
# Ambele versiuni de binare instalate, noul cluster inițializat cu aceleași setări (locale, checksums)
/usr/lib/postgresql/17/bin/pg_upgrade \
  -b /usr/lib/postgresql/13/bin -B /usr/lib/postgresql/17/bin \
  -d /var/lib/postgresql/13/main -D /var/lib/postgresql/17/main \
  --link --check          # întâi doar verificare
# apoi fără --check, cu serverele oprite
vacuumdb --all --analyze-in-stages   # statisticile trebuie refăcute

Cu --link (hard link-uri), fișierele de date nu se copiază, iar upgrade-ul durează minute indiferent de mărimea bazei. Dezavantajul: după ce pornești noul cluster, cel vechi nu mai poate fi folosit în siguranță, deci backup-ul complet dinainte este obligatoriu. --clone (pe sisteme de fișiere care suportă reflink) oferă viteza lui --link fără acest risc. Replicile fizice se refac apoi cu rsync după procedura din documentație sau se reconstruiesc.

3. Replicare logică: pornești un server nou pe versiunea 17, creezi schema, configurezi o publicație pe vechiul server și un abonament pe cel nou. După sincronizare, oprești scrierile câteva secunde, aștepți ca abonamentul să fie la zi, setezi secvențele, muți aplicația. Întreruperea este minimă, iar vechiul server rămâne intact ca variantă de revenire. Costul: limitările replicării logice (DDL înghețat pe durata migrării, tabele fără cheie primară, obiecte mari).

Indiferent de metodă: testezi întâi pe o copie, verifici compatibilitatea extensiilor și a aplicației cu noua versiune (notele de lansare au o secțiune de incompatibilități), rulezi pg_upgrade --check și pregătești un plan de revenire.

Ce urmărește intervievatorul: Upgrade-urile majore sunt proiecte reale pe care un DBA le conduce. Intervievatorul vrea să vadă că știi toate cele trei metode, cu riscurile lor, inclusiv statisticile după pg_upgrade.

72 Mid

Ce măsuri de securitate aplici pe un server PostgreSQL de producție?

Răspuns scurt: Acces de rețea restrâns (listen_addresses, firewall, pg_hba.conf strict), autentificare scram-sha-256, TLS obligatoriu, roluri cu privilegii minime și fără superuser pentru aplicații, actualizări la zi, audit cu pgaudit, criptarea backup-urilor și, unde e nevoie, Row-Level Security.

Securitatea se construiește în straturi:

Rețea

  • serverul nu este expus pe internet; listen_addresses doar pe interfața privată;
  • firewall sau security group care permite portul 5432 doar de la serverele aplicației și de la bastion;
  • pg_hba.conf cu reguli exacte, hostssl pentru conexiunile de rețea și reject la final.

Autentificare și criptare

  • password_encryption = scram-sha-256 și metoda scram-sha-256 în pg_hba.conf; parolele vechi md5 se resetează;
  • ssl = on, certificate valide, iar clienții folosesc sslmode=verify-full ca să verifice serverul;
  • parolele aplicațiilor în manager de secrete (Vault, AWS Secrets Manager), cu rotație, nu în cod.

Autorizare

  • aplicațiile nu sunt superuser și nici proprietare ale schemei;
  • REVOKE CREATE ON SCHEMA public FROM PUBLIC pe versiunile mai vechi de 15;
  • REVOKE ALL ON DATABASE ... FROM PUBLIC și GRANT CONNECT doar rolurilor necesare;
  • funcțiile SECURITY DEFINER cu search_path fixat.

Row-Level Security pentru date pe mai mulți clienți (multi-tenant):

SQL
ALTER TABLE facturi ENABLE ROW LEVEL SECURITY;
CREATE POLICY doar_firma_mea ON facturi
  USING (firma_id = current_setting('app.firma_id')::bigint);
-- proprietarul tabelului și rolurile cu BYPASSRLS ocolesc politica

Audit și detecție

  • pgaudit pentru jurnalizarea operațiilor sensibile (DDL, acces la tabele cu date personale);
  • log_connections, log_disconnections și alerte pe autentificări eșuate repetate.

Date și backup

  • criptarea discului (la nivel de volum sau în cloud), backup-uri criptate, cu acces separat;
  • date anonimizate în mediile de test, nu copii ale producției;
  • ștergerea datelor personale conform GDPR.

Întreținere: versiunea minoră la zi (multe corecturi sunt de securitate) și extensii doar din surse de încredere.

Ce urmărește intervievatorul: Bazele de date conțin datele cele mai valoroase ale firmei. Intervievatorul verifică dacă gândești în straturi, nu doar „punem parolă”.

73 Mid

Serverul a rămas fără memorie și kernelul a oprit un proces PostgreSQL (OOM killer). Ce s-a întâmplat și cum previi?

Răspuns scurt: OOM killer a oprit un proces când memoria s-a epuizat, iar PostgreSQL a repornit toate conexiunile ca să protejeze memoria partajată. Cauzele tipice sunt work_mem prea mare înmulțit cu multe conexiuni sau o interogare cu multe hash-uri. Previi cu vm.overcommit_memory = 2, work_mem rezonabil, mai puține conexiuni și protejarea procesului principal.

Când Linux rămâne fără memorie, OOM killer alege un proces și îl oprește cu SIGKILL. Dacă oprește un proces backend PostgreSQL, procesul principal (postmaster) nu poate fi sigur că memoria partajată a rămas consistentă, așa că oprește toate conexiunile și face recuperare din WAL. Pentru aplicație arată ca o mică întrerupere, cu toate tranzacțiile în curs pierdute. Dacă e oprit chiar postmaster-ul, serverul cade complet.

Le vezi în log:

LOG:  server process (PID 21983) was terminated by signal 9: Killed
LOG:  terminating any other active server processes

și în jurnalul kernelului: dmesg -T | grep -i "out of memory" sau journalctl -k.

Cauze frecvente:

  • work_mem mare combinat cu multe conexiuni și interogări cu multe noduri de sortare sau hash (în versiunile noi, hash-urile pot folosi work_mem × hash_mem_multiplier);
  • maintenance_work_mem mare înmulțit cu numărul de workeri autovacuum;
  • shared_buffers prea mare pentru RAM-ul disponibil;
  • alte procese pe același server (aplicația, agenți de monitorizare).

Prevenție:

BASH
# /etc/sysctl.d/30-postgresql.conf
vm.overcommit_memory = 2      # fără supra-alocare: alocarea eșuează cu eroare în loc de OOM kill
vm.overcommit_ratio = 80      # ajustat la RAM și swap
vm.swappiness = 1

Cu overcommit_memory = 2, o interogare care cere prea multă memorie primește eroarea out of memory și doar ea eșuează, nu tot serverul. Ajustezi și work_mem la o valoare globală mică și o mărești doar pentru rolurile de raportare, reduci conexiunile cu PgBouncer și, pe sistemele cu systemd, poți proteja procesul principal prin setarea OOMScoreAdjust=-1000 în unitatea de serviciu.

Pentru diagnostic, log_temp_files și EXPLAIN (ANALYZE) pe interogările suspecte arată cât folosesc sortările și hash-urile. Din PostgreSQL 14, pg_log_backend_memory_contexts(pid) scrie în log memoria folosită de un proces anume.

Ce urmărește intervievatorul: Intervievatorul verifică legătura dintre configurația PostgreSQL și sistemul de operare. Un DBA care știe de vm.overcommit_memory a depanat deja asemenea incidente.

74 Senior

Trebuie să migrezi o bază de date critică de 2 TB de pe PostgreSQL 12 pe 17, cu cel mult 5 minute de întrerupere. Cum planifici proiectul?

Răspuns scurt: Alegi replicarea logică spre un cluster nou pe versiunea 17 (sau pg_upgrade --link pe o replică izolată, dacă e posibil), inventariezi incompatibilitățile și extensiile, testezi pe o copie cu trafic real, sincronizezi, faci repetiții de comutare cronometrate și pregătești un plan de revenire, inclusiv replicare inversă.

1. Inventar și riscuri (săptămâni înainte).

  • Extensii instalate (\dx) și disponibilitatea lor pe 17; tipuri de date sau funcții eliminate între versiuni.
  • Tabele fără cheie primară (problemă pentru replicarea logică), obiecte mari, secvențe, volumul de DDL în perioada migrării.
  • Driverele și ORM-urile aplicației compatibile cu 17; schimbările de comportament din notele de lansare.

2. Alegerea metodei. Pentru 2 TB cu maximum 5 minute:

  • pg_upgrade --link poate încăpea în 5 minute, dar revenirea înapoi e greu de garantat după pornire, iar replicile trebuie refăcute.
  • Replicarea logică spre un cluster nou pe 17 permite comutare în secunde și păstrează serverul vechi intact. O aleg ca variantă principală.

3. Pregătirea clusterului nou. Servere noi (ocazie bună pentru hardware sau configurație mai bună), Patroni, backup configurat de la început, pg_dump --schema-only aplicat, apoi abonamentul. Pentru tabelele foarte mari, sincronizarea inițială poate dura ore; o monitorizezi în pg_stat_subscription și urmărești WAL-ul reținut de slot pe sursă.

4. Validare. Compari numărul de rânduri și sume de control pe tabelele principale, rulezi suita de teste a aplicației pe noul cluster (în citire) și reluarea unui eșantion de trafic real cu planurile comparate (după ANALYZE complet).

5. Repetiții. Faci tot procesul cel puțin o dată pe un mediu de test și cronometrezi fiecare pas.

6. Comutarea (fereastra de 5 minute).

  • Îngheți DDL-ul și jobs-urile de mentenanță.
  • PAUSE în PgBouncer sau aplicațiile în modul doar citire.
  • Aștepți ca abonamentul să ajungă la LSN-ul curent al sursei.
  • Setezi secvențele pe noul cluster la valorile de pe sursă, plus o marjă.
  • Muți PgBouncer pe noul primar și RESUME.
  • Verifici rapid scrierile și erorile din aplicație.

7. Revenirea. Înainte de comutare, pregătești o publicație pe noul cluster și un abonament pe cel vechi, activat după comutare, ca datele noi să curgă și înapoi o perioadă. Dacă apare o problemă gravă în primele zile, poți reveni fără pierdere de date.

8. Comunicare. Echipele implicate, fereastra anunțată, cine decide revenirea și criteriile exacte de „merge” și „nu merge”.

Ce urmărește intervievatorul: Este o întrebare de conducere de proiect tehnic. Intervievatorul evaluează gestionarea riscurilor, repetițiile și planul de revenire, nu doar comanda folosită.

Monitorizare, loguri și alerte

75 Junior

Ce este pg_stat_statements și cum îl folosești ca să găsești interogările care trebuie optimizate?

Răspuns scurt: Este o extensie care adună statistici pentru fiecare tip de interogare (normalizată, cu parametrii înlocuiți): număr de apeluri, timp total și mediu, rânduri, blocuri citite. Sortezi după timpul total ca să găsești ce consumă cel mai mult din server.

pg_stat_statements grupează interogările după structură. SELECT * FROM clienti WHERE id = 5 și ... WHERE id = 7 devin aceeași intrare, ... WHERE id = $1, cu statistici cumulate.

Activare:

INI
# postgresql.conf (cere restart)
shared_preload_libraries = 'pg_stat_statements'
pg_stat_statements.track = top
compute_query_id = on
SQL
CREATE EXTENSION pg_stat_statements;

Interogări utile:

SQL
-- Ce consumă cel mai mult timp în total
SELECT queryid, calls,
       round(total_exec_time / 1000) AS total_sec,
       round(mean_exec_time, 2) AS medie_ms,
       round(100 * total_exec_time / sum(total_exec_time) OVER (), 1) AS procent,
       rows, left(query, 100) AS interogare
FROM pg_stat_statements
ORDER BY total_exec_time DESC
LIMIT 20;

-- Cele mai lente în medie, cu un minim de apeluri
SELECT calls, round(mean_exec_time) AS medie_ms, left(query, 100)
FROM pg_stat_statements WHERE calls > 50
ORDER BY mean_exec_time DESC LIMIT 20;

-- Care citesc cel mai mult de pe disc
SELECT shared_blks_read, shared_blks_hit, temp_blks_written, left(query, 100)
FROM pg_stat_statements ORDER BY shared_blks_read DESC LIMIT 20;

Cum interpretezi:

  • O interogare de 2 ms apelată de 5 milioane de ori pe zi poate costa mai mult decât un raport de 30 de secunde rulat o dată. De aceea sortezi întâi după timpul total.
  • temp_blks_written mare înseamnă sortări sau hash-uri care nu încap în work_mem.
  • rows / calls foarte mare la o interogare din aplicația web poate indica lipsa paginării.

Statisticile sunt cumulative de la ultima resetare. Pentru tendințe, salvezi periodic instantanee (de exemplu la oră, în sistemul de monitorizare) sau resetezi după o lansare cu SELECT pg_stat_statements_reset();, ca să compari înainte și după. Nu uita: extensia nu salvează planurile; pentru asta folosești auto_explain sau EXPLAIN manual.

Ce urmărește intervievatorul: pg_stat_statements este principala unealtă de optimizare a unui DBA PostgreSQL. Intervievatorul verifică dacă știi să sortezi după timpul total, nu doar după cele mai lente interogări.

76 Junior

Ce metrici urmărești zilnic la un server PostgreSQL?

Răspuns scurt: Disponibilitatea și numărul de conexiuni, tranzacțiile pe secundă și latența, interogările lente, lock-urile și tranzacțiile lungi, lag-ul replicilor, spațiul pe disc și creșterea bazei, starea backup-urilor și a arhivării WAL, rândurile moarte și autovacuum, plus CPU, memorie și I/O la nivel de server.

Metricile se împart în câteva grupuri:

Disponibilitate și încărcare

  • serverul răspunde (pg_isready, o interogare simplă);
  • conexiuni pe stare (active, idle, idle in transaction) față de max_connections;
  • tranzacții confirmate și anulate pe secundă (xact_commit, xact_rollback din pg_stat_database); o creștere bruscă a rollback-urilor indică erori în aplicație.

Performanță

  • latența interogărilor (din pg_stat_statements sau din aplicație);
  • rata de cache hit pentru shared_buffers;
  • fișierele temporare (temp_files, temp_bytes);
  • deadlock-uri și așteptări după lock-uri.

Sănătatea datelor

  • cea mai veche tranzacție deschisă și sesiunile idle in transaction;
  • rânduri moarte pe tabel și ultimul autovacuum;
  • vârsta XID-urilor (age(datfrozenxid)), pentru wraparound.

Replicare și backup

  • lag-ul fiecărei replici, în octeți și secunde;
  • sloturile inactive și WAL-ul reținut;
  • pg_stat_archiver: ultima arhivare reușită și eșecurile;
  • vârsta ultimului backup reușit.

Server

  • spațiul liber pe discul de date și pe cel de WAL, cu tendința de creștere;
  • CPU, memorie, I/O (latență, IOPS), rețea.
SQL
SELECT datname, numbackends, xact_commit, xact_rollback,
       round(100.0 * blks_hit / nullif(blks_hit + blks_read, 0), 2) AS cache_hit,
       temp_files, pg_size_pretty(temp_bytes) AS temp, deadlocks
FROM pg_stat_database WHERE datname NOT LIKE 'template%';

În practică, nu rulezi manual aceste interogări: le colectezi automat cu un exporter (postgres_exporter pentru Prometheus) sau cu o unealtă dedicată (pgwatch, PMM, Datadog, CloudWatch și Performance Insights pe RDS) și construiești un dashboard în Grafana. Contează mai mult tendința decât valoarea de moment: discul care crește cu 2% pe zi trebuie observat cu săptămâni înainte să se umple.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă dacă ai o imagine completă asupra sănătății unui server. Răspunsurile bune includ backup-ul, replicarea și wraparound, nu doar CPU și memorie.

77 Junior

Cum configurezi logurile PostgreSQL ca să fie utile la depanare?

Răspuns scurt: Setezi un log_line_prefix cu timp, PID, utilizator, bază de date și aplicație, log_min_duration_statement pentru interogările lente, log_lock_waits, log_temp_files, log_checkpoints, log_autovacuum_min_duration și, la nevoie, log_connections. Evită log_statement = 'all' în producție.

O configurație de pornire, echilibrată între detaliu și volum:

INI
logging_collector = on
log_directory = 'log'
log_filename = 'postgresql-%Y-%m-%d.log'
log_rotation_age = 1d
log_rotation_size = 0

log_line_prefix = '%m [%p] %q%u@%d app=%a client=%h '
log_min_duration_statement = '500ms'   # interogările mai lente de 0,5 s, cu durata
log_lock_waits = on                    # așteptări după lock mai lungi decât deadlock_timeout
log_temp_files = 0                     # orice fișier temporar (sortări care nu încap în memorie)
log_checkpoints = on
log_autovacuum_min_duration = '10s'
log_connections = on                   # util pentru audit; poate fi mult pe aplicații fără pool
log_disconnections = on
log_statement = 'ddl'                  # toate CREATE, ALTER, DROP

Ce înseamnă fiecare element din log_line_prefix: %m timpul cu milisecunde, %p PID-ul procesului (îl corelezi cu pg_stat_activity), %u utilizatorul, %d baza de date, %a numele aplicației (setat de client prin application_name), %h adresa clientului.

Recomandări:

  • log_statement = 'all' sau log_min_duration_statement = 0 produc un volum uriaș de log și încetinesc serverul. Le folosești doar temporar, pentru diagnostic.
  • Logurile pot conține date sensibile (parametrii interogărilor). Tratează-le ca atare: acces restrâns și retenție limitată.
  • Pentru analiză, unealta pgBadger transformă logurile într-un raport HTML cu interogările lente, erorile, lock-urile și checkpoint-urile.
  • auto_explain adaugă în log planul interogărilor lente:
INI
shared_preload_libraries = 'pg_stat_statements,auto_explain'
auto_explain.log_min_duration = '2s'
auto_explain.log_analyze = on
auto_explain.log_buffers = on

log_analyze adaugă un cost de măsurare la fiecare interogare, de aceea pe servere foarte încărcate se setează și auto_explain.sample_rate. Pe RDS, aceiași parametri se setează în parameter group, iar logurile se pot trimite în CloudWatch Logs. Formatul jsonlog (din PostgreSQL 15) este mai ușor de prelucrat automat.

Ce urmărește intervievatorul: Logurile sunt prima sursă de informație la un incident. Intervievatorul verifică dacă știi ce să activezi și ce să eviți, inclusiv riscul de date sensibile.

78 Mid

Ce este rata de cache hit și ce faci când este mică?

Răspuns scurt: Este procentul de citiri de pagini servite din shared_buffers față de totalul citirilor. Pentru o bază de date tranzacțională ar trebui să fie de obicei peste 99%. O rată mică poate însemna memorie insuficientă, interogări care scanează tabele mari, bloat sau un set de date activ mai mare decât RAM-ul.

PostgreSQL numără pentru fiecare tabel și index câte pagini au fost găsite în shared_buffers (hit) și câte au trebuit cerute sistemului de operare (read).

SQL
-- Pe bază de date
SELECT datname, round(100.0 * blks_hit / nullif(blks_hit + blks_read, 0), 2) AS cache_hit
FROM pg_stat_database WHERE datname = current_database();

-- Pe tabele: unde se citește cel mai mult din afara cache-ului
SELECT relname, heap_blks_read, heap_blks_hit,
       round(100.0 * heap_blks_hit / nullif(heap_blks_hit + heap_blks_read, 0), 2) AS hit,
       idx_blks_read, idx_blks_hit
FROM pg_statio_user_tables
ORDER BY heap_blks_read DESC LIMIT 10;

Interpretare cu atenție:

  • Un „read” din perspectiva PostgreSQL poate fi servit tot din memorie, de cache-ul sistemului de operare. Rata de hit subestimează deci cât de bine stă serverul. Valoarea reală a I/O-ului o vezi la nivelul sistemului (iostat) sau cu track_io_timing = on și coloanele blk_read_time.
  • Pentru o bază de date de raportare, care scanează periodic tabele uriașe, o rată mai mică este normală.
  • Statisticile sunt cumulative: compară valori pe intervale, nu de la pornirea serverului.

Ce faci când rata scade:

  • Cauți în pg_stat_statements interogările cu multe shared_blks_read. O singură scanare completă pe un tabel mare, rulată des, poate scoate din cache datele utile. Un index potrivit rezolvă adesea problema.
  • Verifici bloat-ul: un tabel umflat de trei ori ocupă de trei ori mai mult cache.
  • Compari dimensiunea setului de date activ cu RAM-ul. Dacă datele accesate des nu mai încap, ajustezi shared_buffers sau mărești memoria serverului.
  • Mutați rapoartele grele pe o replică, ca să nu concureze cu traficul aplicației pentru cache.

Extensia pg_buffercache arată ce tabele ocupă efectiv shared_buffers în acest moment, iar pg_prewarm poate reîncărca un tabel în cache după o repornire.

Ce urmărește intervievatorul: Intervievatorul verifică dacă interpretezi corect o metrică populară. Faptul că știi de cache-ul sistemului de operare și de track_io_timing arată profunzime.

79 Mid

În log apare des „checkpoints are occurring too frequently”. Ce înseamnă și cum ajustezi checkpoint-urile?

Răspuns scurt: Checkpoint-urile sunt declanșate de volumul de WAL (max_wal_size) mai des decât intervalul dorit (checkpoint_timeout). Checkpoint-urile dese produc vârfuri de I/O și mai mult WAL, din cauza paginilor complete scrise după fiecare checkpoint. Mărești max_wal_size și păstrezi checkpoint_completion_target în jur de 0,9.

Un checkpoint scrie pe disc toate paginile modificate din shared_buffers și marchează în WAL un punct de la care începe recuperarea după o cădere. Se declanșează la checkpoint_timeout (implicit 5 minute) sau când WAL-ul generat de la ultimul checkpoint atinge max_wal_size (implicit 1 GB), oricare vine primul.

Mesajul din log înseamnă că se ajunge la max_wal_size mai repede decât checkpoint_warning (implicit 30 de secunde). Efecte:

  • vârfuri de I/O: aceleași pagini sunt scrise des, iar scrierile concurează cu interogările;
  • mai mult WAL: după fiecare checkpoint, prima modificare a fiecărei pagini scrie în WAL pagina completă (full_page_writes), ca protecție la scrieri parțiale. Checkpoint-urile dese înseamnă mult mai multe pagini complete, deci mai mult WAL de arhivat și de trimis la replici.

Ce vezi cu log_checkpoints = on:

LOG:  checkpoint complete: wrote 412938 buffers (39.4%); ... write=26.913 s, sync=1.207 s,
      total=28.401 s; distance=1048576 kB, estimate=1048576 kB

Și din statistici (în PostgreSQL 17 au fost mutate în pg_stat_checkpointer):

SQL
SELECT num_timed, num_requested, write_time, sync_time, buffers_written
FROM pg_stat_checkpointer;
-- num_requested mult mai mare decât num_timed => max_wal_size prea mic

Ajustare tipică:

INI
max_wal_size = 16GB               # în funcție de volumul de WAL generat
checkpoint_timeout = 15min
checkpoint_completion_target = 0.9   # scrierile se întind pe 90% din interval

Compromisul: checkpoint-uri mai rare înseamnă mai mult WAL de reaplicat după o cădere, deci o recuperare puțin mai lungă, și mai mult spațiu ocupat de pg_wal. Ținta obișnuită este ca aproape toate checkpoint-urile să fie declanșate de timp, nu de volum. Dacă și după ajustare scrierile rămân o problemă, verifici discul (latență, throughput) și bgwriter, care scrie pagini murdare în fundal între checkpoint-uri.

Ce urmărește intervievatorul: Este un mesaj de log pe care un DBA trebuie să-l înțeleagă și să-l rezolve. Legătura cu full_page_writes și volumul de WAL este ce separă un răspuns mediu de unul bun.

80 Mid

Discul serverului de baze de date este plin 97% și crește. Ce verifici și ce faci, în ordine?

Răspuns scurt: Afli ce crește: pg_wal (arhivare eșuată, slot inactiv), loguri, fișiere temporare sau tabele și indecși. Rezolvi cauza (repari arhivarea, ștergi slotul abandonat, oprești interogarea cu fișiere temporare uriașe) și câștigi timp sigur, fără să ștergi niciodată manual fișiere din directorul de date.

Un disc plin oprește PostgreSQL: când nu mai poate scrie WAL, serverul se oprește ca să protejeze datele. Trebuie acționat repede, dar fără panică.

1. Ce anume ocupă spațiul.

BASH
df -h /var/lib/postgresql
du -sh /var/lib/postgresql/17/main/{base,pg_wal,log} 2>/dev/null
du -sh /var/lib/postgresql/17/main/base/pgsql_tmp 2>/dev/null

2. Dacă e pg_wal, WAL-ul nu poate fi reciclat. Cauzele obișnuite:

SQL
SELECT * FROM pg_stat_archiver;          -- last_failed_wal, last_failed_time
SELECT slot_name, active, wal_status,
       pg_size_pretty(pg_wal_lsn_diff(pg_current_wal_lsn(), restart_lsn)) AS retinut
FROM pg_replication_slots;
  • arhivarea eșuează (destinația plină, permisiuni, credențiale expirate): repari destinația; după ce arhivarea reia, PostgreSQL reciclează singur segmentele;
  • un slot inactiv al unei replici abandonate: îl ștergi cu pg_drop_replication_slot după ce confirmi că nu mai e folosit;
  • o replică cu lag mare: o repari sau, în ultimă instanță, îi ștergi slotul și o reconstruiești ulterior.

Niciodată nu ștergi manual fișiere din pg_wal: poți face baza de date imposibil de pornit.

3. Dacă sunt fișiere temporare: o interogare face o sortare sau un hash enorm. O găsești în pg_stat_activity și o anulezi cu pg_cancel_backend. Pe termen lung, temp_file_limit limitează spațiul temporar per proces.

4. Dacă sunt logurile: comprimi sau muți logurile vechi; verifici dacă nu a rămas activ log_statement = 'all'.

5. Dacă sunt datele: identifici tabelele care cresc (pg_total_relation_size), bloat-ul, datele vechi care pot fi arhivate. Pe termen scurt, cea mai sigură soluție este mărirea discului (pe cloud, de obicei fără oprire) sau un tablespace pe alt disc pentru tabele noi.

6. După incident: alertă pe spațiul liber la 80% și 90%, alertă pe predicția de umplere (de exemplu „se umple în 7 zile”), max_slot_wal_keep_size setat, monitorizarea arhivării. Discul de WAL separat de cel de date limitează efectele.

Ce urmărește intervievatorul: Discul plin este unul dintre cele mai frecvente incidente. Intervievatorul verifică ordinea de diagnostic și dacă știi că ștergerea manuală din pg_wal este interzisă.

81 Senior

Cum proiectezi alertele pentru o flotă de servere PostgreSQL, astfel încât echipa să nu ignore notificările?

Răspuns scurt: Alertele care trezesc pe cineva noaptea trebuie să fie puține, urgente și acționabile, fiecare cu un runbook. Restul devin notificări de zi sau dashboard-uri. Pornești de la impactul pentru utilizator și riscurile majore (disc, wraparound, replicare, backup), folosești praguri cu durată și predicții, și revizuiești periodic alertele care sună degeaba.

Problema reală a monitorizării nu este lipsa alertelor, ci oboseala de alertare: când telefonul sună de 20 de ori pe noapte pentru lucruri care se rezolvă singure, echipa începe să ignore și alertele importante.

Principii:

  • Fiecare alertă urgentă cere o acțiune umană imediată. Dacă răspunsul obișnuit este „mă uit mâine”, nu este o alertă de pager.
  • Fiecare alertă are un runbook: ce înseamnă, cum verifici, ce pași faci, cui escaladezi.
  • Două niveluri: *page* (oricând, imediat) și *ticket* (în timpul programului). Restul informațiilor stau în dashboard-uri.
  • Praguri cu durată (de exemplu „lag peste 60 s timp de 5 minute”), ca un vârf de câteva secunde să nu trezească pe nimeni.
  • Predicții în loc de praguri fixe pentru resursele care se umplu: „discul se umple în mai puțin de 6 ore” este mai util decât „discul e la 85%”.

Exemple de alerte urgente:

  • primarul nu răspunde sau nu există niciun primar în cluster;
  • discul de date sau de WAL se umple în câteva ore;
  • arhivarea WAL eșuează de peste 15 minute (RPO-ul crește);
  • lag-ul replicii sincrone sau al celei folosite la failover peste prag;
  • vârsta XID-urilor peste 50% din limita de wraparound;
  • conexiunile aproape de max_connections, clienți care așteaptă în PgBouncer.

Exemple de alerte de tip ticket:

  • ultimul backup reușit mai vechi de 26 de ore sau testul de restaurare a eșuat;
  • sloturi de replicare inactive;
  • bloat sau rânduri moarte în creștere pe tabele importante;
  • tranzacții deschise de peste 30 de minute;
  • certificate TLS care expiră în 21 de zile.

Proces: după fiecare tură de gardă, discuți alertele primite: au fost utile? Cele care au sunat fără să ceară acțiune se ajustează sau se șterg. Ideal, alertele sunt definite ca cod (reguli Prometheus în Git) și aplicate identic pe toată flota, cu excepții documentate. Merită și alerte „de la capăt la capăt”, din perspectiva aplicației (latența și erorile interogărilor), pentru că acolo se vede impactul real.

Ce urmărește intervievatorul: Intervievatorul evaluează maturitatea operațională a unui senior: un sistem de alerte în care echipa are încredere, nu o listă lungă de praguri.

82 Senior

Cum faci planificarea capacității pentru o bază de date care crește rapid?

Răspuns scurt: Măsori tendințele (dimensiunea datelor și a indecșilor, WAL generat, tranzacții pe secundă, CPU, IOPS, conexiuni), le legi de metricile de business, proiectezi pe 6–12 luni cu o marjă de siguranță și identifici din timp limitele: disc, memorie pentru setul activ, scrierile pe un singur primar, durata backup-ului și a restaurării.

Planificarea capacității înseamnă să afli înainte de incident când vei atinge o limită și ce faci atunci.

1. Colectezi date istorice, cel puțin câteva luni:

  • dimensiunea bazei, pe tabele și indecși (pg_total_relation_size), salvată zilnic;
  • WAL generat pe zi (diferența de LSN), care determină costul replicării, arhivării și backup-ului;
  • tranzacții și interogări pe secundă, la vârf, nu doar în medie;
  • CPU, memorie, IOPS și latența discului, conexiunile active;
  • durata backup-ului și a restaurării de test.
SQL
SELECT relname, pg_size_pretty(pg_total_relation_size(relid)) AS total,
       pg_size_pretty(pg_indexes_size(relid)) AS indecsi
FROM pg_catalog.pg_statio_user_tables
ORDER BY pg_total_relation_size(relid) DESC LIMIT 15;

2. Legi datele de business. Câte comenzi pe zi generează 1 GB de date? Ce spune echipa comercială despre anul următor: o campanie, o țară nouă, un client mare? O proiecție bazată doar pe trecut ratează aceste salturi.

3. Identifici limitele, nu doar resursele:

  • discul și costul lui, inclusiv pentru backup-uri și replici;
  • setul de date activ față de RAM: când datele accesate des nu mai încap în memorie, latența crește brusc, nu liniar;
  • scrierile pe un singur primar: replicile scalează citirile, nu scrierile; la un moment dat ai nevoie de partiționare, arhivare, separarea unor module în baze diferite sau sharding (Citus);
  • timpii operaționali: un backup care durează 10 ore, o restaurare peste RTO, un VACUUM care nu mai termină în timp util, un upgrade major tot mai dificil;
  • conexiunile și limitele unei instanțe gestionate (de exemplu tipurile de instanțe și IOPS pe RDS).

4. Planul. Proiectezi pe 6–12 luni, cu o marjă (de exemplu disc folosit sub 70% la sfârșitul perioadei) și praguri de declanșare: „când trecem de X tranzacții pe secundă la vârf, mutăm rapoartele pe o replică dedicată”. Măsurile ieftine vin primele: indecși nefolosiți, bloat, retenția datelor vechi, optimizarea celor mai costisitoare interogări din pg_stat_statements.

5. Testul. Un test de încărcare (pgbench cu un scenariu personalizat sau reluarea traficului real) pe un mediu cu volume viitoare arată unde cedează sistemul înainte să cedeze în producție.

Rezultatul se prezintă managementului ca opțiuni cu cost și termen, nu ca o cerere urgentă de servere noi.

Ce urmărește intervievatorul: Intervievatorul caută un senior care anticipează, nu doar reacționează. Răspunsurile bune leagă metricile tehnice de business și menționează limitele operaționale, nu doar discul.

Linux, Docker și cloud (AWS RDS)

83 Junior

Cum verifici în Linux dacă discul este problema când baza de date este lentă?

Răspuns scurt: Cu df -h vezi spațiul, cu iostat -x latența (await), utilizarea (%util) și operațiile pe secundă, cu iotop sau pidstat -d procesele care scriu și citesc, iar în PostgreSQL cu track_io_timing și pg_stat_io vezi cât timp petrec interogările așteptând discul.

Un disc poate fi problema în două feluri: este plin sau este prea lent pentru volumul de citiri și scrieri.

BASH
df -h /var/lib/postgresql             # spațiu liber
df -i /var/lib/postgresql             # inode-uri libere (rar, dar se întâmplă)

iostat -xz 2 5                        # pachetul sysstat
# r/s, w/s     operații de citire/scriere pe secundă
# rkB/s, wkB/s throughput
# r_await, w_await  latența medie în ms; pe SSD ar trebui să fie de obicei sub câteva ms
# aqu-sz       coada de cereri; valori mari constant = discul nu ține pasul
# %util        cât timp a fost discul ocupat (pe SSD/NVMe nu înseamnă neapărat saturare)

sudo iotop -oPa                       # ce procese fac I/O
pidstat -d 2                          # I/O pe procese
vmstat 2                              # coloana wa = timp CPU în așteptarea I/O

În PostgreSQL:

SQL
-- Interogări care așteaptă acum după disc
SELECT pid, wait_event_type, wait_event, left(query, 80)
FROM pg_stat_activity WHERE wait_event_type = 'IO';

-- Statistici de I/O pe tip de proces și operație (PostgreSQL 16+)
SELECT backend_type, object, context, reads, writes, read_time, write_time
FROM pg_stat_io WHERE reads > 0 OR writes > 0 ORDER BY read_time DESC NULLS LAST;

Pentru read_time și blk_read_time din pg_stat_statements ai nevoie de track_io_timing = on. Costul acestei setări este mic pe hardware modern; poți verifica cu pg_test_timing.

Cauze tipice ale unui disc lent: checkpoint-uri prea dese, autovacuum care rulează simultan pe mai multe tabele mari, interogări care scanează tabele uriașe, sortări pe disc, backup-ul care rulează în timpul zilei pe primar. În cloud, apare și limitarea de IOPS sau throughput a volumului: pe AWS, un volum gp3 are o limită configurată de IOPS și MB/s, iar la depășire latența crește brusc. Metricile volumului (în CloudWatch) arată dacă ai atins limita.

Ce urmărește intervievatorul: Un DBA trebuie să poată merge sub nivelul bazei de date. Intervievatorul verifică dacă știi iostat și dacă legi ce vezi în Linux de ce vezi în PostgreSQL.

84 Junior

Cum pornești, oprești și verifici serviciul PostgreSQL pe un server Linux și unde găsești logurile?

Răspuns scurt: Cu systemctl start, stop, restart, reload și status, iar logurile sistemului cu journalctl -u. Logurile PostgreSQL sunt de obicei în directorul log din directorul de date sau în /var/log/postgresql pe Debian și Ubuntu. pg_isready verifică dacă serverul acceptă conexiuni.

Pe majoritatea distribuțiilor, PostgreSQL rulează ca serviciu systemd. Numele unității diferă: pe Debian și Ubuntu, postgresql@17-main (versiune și nume de cluster), pe RHEL și Rocky, postgresql-17.

BASH
sudo systemctl status postgresql@17-main
sudo systemctl start postgresql@17-main
sudo systemctl reload postgresql@17-main    # reîncarcă configurația, fără deconectări
sudo systemctl restart postgresql@17-main   # oprește conexiunile
sudo systemctl enable postgresql@17-main    # pornește automat la boot

journalctl -u postgresql@17-main --since "1 hour ago"

pg_isready -h localhost -p 5432             # 0 = acceptă conexiuni
pg_lsclusters                               # Debian/Ubuntu: clusterele, porturile și statusul

Unde sunt fișierele:

SQL
SHOW data_directory;      -- de exemplu /var/lib/postgresql/17/main
SHOW config_file;         -- pe Debian: /etc/postgresql/17/main/postgresql.conf
SHOW hba_file;
SHOW log_directory;       -- relativ la data_directory dacă nu începe cu /
SELECT pg_current_logfile();

Moduri de oprire, cu pg_ctl stop -m:

  • smart: așteaptă ca toți clienții să se deconecteze (poate dura la nesfârșit);
  • fast (implicit): anulează tranzacțiile în curs, deconectează clienții și face un checkpoint curat;
  • immediate: oprire bruscă, fără checkpoint, cu recuperare la următoarea pornire. Doar în urgențe.

Dacă serverul nu pornește, primul loc unde te uiți este logul PostgreSQL: mesajele de tip FATAL spun de obicei exact cauza (port ocupat, permisiuni greșite pe directorul de date, eroare de sintaxă în postgresql.conf, disc plin). Directorul de date trebuie să aparțină utilizatorului postgres și să aibă permisiunile 0700 sau 0750.

Ce urmărește intervievatorul: Este o întrebare practică de bază. Intervievatorul verifică dacă te descurci singur pe un server: pornire, oprire, configurație și loguri.

85 Junior

Scrie un script Bash care face un pg_dump zilnic, păstrează ultimele 7 zile și semnalează erorile. Cum îl programezi?

Răspuns scurt: Scriptul folosește set -euo pipefail, creează un fișier cu data în nume, rulează pg_dump în format custom, verifică rezultatul cu pg_restore --list, șterge fișierele mai vechi de 7 zile și trimite un semnal de eroare la eșec. Îl programezi cu cron sau cu un timer systemd.

BASH
#!/usr/bin/env bash
# /usr/local/bin/backup-magazin.sh
set -euo pipefail

DB="magazin"
DIR="/backup/pg_dump"
RETENTIE_ZILE=7
DATA="$(date +%F_%H%M)"
FISIER="${DIR}/${DB}_${DATA}.dump"
LOG="/var/log/backup-magazin.log"

log() { echo "$(date '+%F %T') $*" | tee -a "$LOG"; }
esec() { log "EROARE: $*"; curl -fsS -m 10 "https://monitorizare.intern/alerta?job=backup-$DB" || true; exit 1; }
trap 'esec "linia $LINENO"' ERR

mkdir -p "$DIR"
log "Încep backup-ul pentru $DB"

# Autentificarea vine din ~/.pgpass (chmod 600), nu din script
pg_dump -h localhost -U backup -d "$DB" -Fc -Z 6 -f "${FISIER}.partial"
pg_restore --list "${FISIER}.partial" > /dev/null    # arhiva poate fi citită
mv "${FISIER}.partial" "$FISIER"

DIMENSIUNE=$(du -h "$FISIER" | cut -f1)
log "Backup reușit: $FISIER ($DIMENSIUNE)"

find "$DIR" -name "${DB}_*.dump" -mtime +"$RETENTIE_ZILE" -print -delete | tee -a "$LOG"
curl -fsS -m 10 "https://monitorizare.intern/ok?job=backup-$DB" || true

Explicații:

  • set -euo pipefail oprește scriptul la orice eroare, la variabile nedefinite și la erori în mijlocul unui pipe.
  • Fișierul se scrie întâi ca .partial și se redenumește doar după succes, ca un backup întrerupt să nu pară valid.
  • pg_restore --list verifică că arhiva este citibilă, dar nu înlocuiește un test real de restaurare.
  • Parola stă în ~/.pgpass, nu în script și nici în linia de comandă, unde ar fi vizibilă în ps.
  • Semnalul către monitorizare la succes permite o alertă și când scriptul nu a rulat deloc (heartbeat), nu doar când a eșuat.

Programare cu cron, ca utilizatorul postgres:

# crontab -e
30 2 * * * /usr/local/bin/backup-magazin.sh >> /var/log/backup-magazin.log 2>&1

Alternativ, un timer systemd oferă loguri în journal și opțiunea Persistent=true, care rulează jobul ratat după o repornire. Backup-urile trebuie copiate și în afara serverului (de exemplu în S3), altfel pierderea discului le ia și pe ele.

Ce urmărește intervievatorul: Intervievatorul verifică dacă scrii scripturi de administrare robuste. Detaliile care contează: set -euo pipefail, fișierul .partial, parola în .pgpass și alerta când jobul nu rulează.

86 Junior

Cum pornești PostgreSQL într-un container Docker fără să pierzi datele când containerul este șters?

Răspuns scurt: Folosești imaginea oficială postgres cu o versiune fixă, setezi parola prin POSTGRES_PASSWORD și montezi un volum Docker pe /var/lib/postgresql/data. Datele stau în volum, nu în stratul containerului, deci supraviețuiesc ștergerii și recreării lui.

Fiecare container are un strat de scriere propriu, care dispare la docker rm. Datele bazei trebuie deci puse într-un volum sau într-un bind mount.

BASH
docker volume create pgdata

docker run -d --name pg17 \
  -e POSTGRES_PASSWORD='parola-de-test' \
  -e POSTGRES_DB=magazin \
  -v pgdata:/var/lib/postgresql/data \
  -p 127.0.0.1:5432:5432 \
  --shm-size=256m \
  postgres:17.6

docker exec -it pg17 psql -U postgres -d magazin
docker logs -f pg17

Detalii importante:

  • Versiune fixă (postgres:17.6), nu latest. Un latest care trece de la 17 la 18 nu poate porni pe datele vechi, pentru că versiunile majore au formate diferite.
  • Calea volumului depinde de versiunea imaginii: pentru imaginile până la 17 este /var/lib/postgresql/data; din PostgreSQL 18, imaginea oficială folosește /var/lib/postgresql cu subdirectoare pe versiuni. Verifică documentația imaginii.
  • Variabilele POSTGRES_* și scripturile din /docker-entrypoint-initdb.d/ se aplică doar la prima inițializare, când volumul e gol. Schimbarea parolei în comandă nu schimbă parola unei baze deja create.
  • -p 127.0.0.1:5432:5432 expune portul doar local. -p 5432:5432 îl poate expune pe toate interfețele, iar Docker poate ocoli regulile firewall-ului.
  • --shm-size: memoria partajată implicită a containerelor (64 MB) poate fi prea mică pentru interogări paralele.
  • Configurația se poate da prin argumente (postgres -c shared_buffers=1GB) sau montând un postgresql.conf propriu.

Pentru medii de test, un container nou pornit în câteva secunde, cu o versiune identică producției, este ideal: testezi o migrare, un upgrade sau o restaurare fără să atingi serverele reale. Backup-ul se face la fel ca pe un server normal, cu docker exec pg17 pg_dump ..., nu prin copierea fișierelor volumului cât serverul rulează.

Ce urmărește intervievatorul: Containerele sunt mediul obișnuit de test și dezvoltare. Intervievatorul verifică dacă știi de volume, de versiunea fixă și de faptul că variabilele de inițializare se aplică o singură dată.

87 Junior

Scrie un docker-compose.yml cu o aplicație și PostgreSQL în care aplicația pornește doar când baza de date este gata.

Răspuns scurt: Definești serviciul db cu imaginea postgres, un volum și un healthcheck care rulează pg_isready, iar serviciul aplicației are depends_on cu condition: service_healthy. Aplicația se conectează la gazda db, numele serviciului din rețeaua Compose.

depends_on simplu așteaptă doar ca containerul bazei de date să pornească, nu ca PostgreSQL să accepte conexiuni. La prima pornire, inițializarea poate dura câteva secunde, iar aplicația ar da eroare. Soluția este un healthcheck.

YAML
services:
  db:
    image: postgres:17.6
    environment:
      POSTGRES_DB: magazin
      POSTGRES_USER: app
      POSTGRES_PASSWORD_FILE: /run/secrets/db_parola
    secrets:
      - db_parola
    volumes:
      - pgdata:/var/lib/postgresql/data
      - ./init:/docker-entrypoint-initdb.d:ro     # scripturi SQL rulate la prima inițializare
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U app -d magazin"]
      interval: 5s
      timeout: 3s
      retries: 10
      start_period: 10s
    restart: unless-stopped

  app:
    build: .
    environment:
      DATABASE_URL: postgresql://app@db:5432/magazin
    depends_on:
      db:
        condition: service_healthy
    ports:
      - "8080:8080"

volumes:
  pgdata:

secrets:
  db_parola:
    file: ./secrete/db_parola.txt

Explicații:

  • În rețeaua creată de Compose, serviciile se găsesc după nume: aplicația se conectează la gazda db, nu la localhost.
  • Portul bazei de date nu este publicat pe gazdă, deci baza de date e accesibilă doar din rețeaua internă a proiectului.
  • POSTGRES_PASSWORD_FILE citește parola dintr-un secret, nu o lasă în fișierul YAML.
  • pg_isready verifică dacă serverul acceptă conexiuni; pentru o verificare mai strictă poți rula o interogare reală cu psql -c 'SELECT 1'.

Chiar și cu healthcheck, aplicația trebuie să știe să reîncerce conectarea: baza de date poate reporni oricând. Comenzile utile: docker compose up -d, docker compose ps (arată starea healthy), docker compose logs db, iar docker compose down -v șterge și volumul, deci și datele.

Ce urmărește intervievatorul: Este un exercițiu practic frecvent. Intervievatorul verifică healthcheck-ul cu pg_isready, condition: service_healthy și faptul că știi că down -v șterge datele.

88 Junior

Care sunt diferențele dintre Amazon RDS for PostgreSQL și un PostgreSQL instalat de tine pe EC2?

Răspuns scurt: RDS preia instalarea, patch-urile, backup-urile automate cu PITR, Multi-AZ și monitorizarea de bază, dar nu ai acces la sistemul de operare, nici la superuser real și poți folosi doar extensiile și setările permise. Pe EC2 ai control total, dar răspunzi tu de tot: backup, replicare, failover, securitate și actualizări.

Amazon RDS for PostgreSQL este un serviciu gestionat. AWS se ocupă de:

  • instalare și actualizări de versiune minoră (într-o fereastră de mentenanță aleasă de tine);
  • backup automat zilnic, cu retenție de până la 35 de zile și restaurare la un moment anume (PITR), plus snapshot-uri manuale;
  • Multi-AZ: o replică sincronă în altă zonă, cu failover automat;
  • replici de citire, monitorizare (CloudWatch, Performance Insights / Database Insights), criptare cu KMS;
  • scalarea discului, uneori fără oprire.

Limitări:

  • nu ai acces SSH la server și nici rol de superuser real; ai rds_superuser, cu drepturi largi, dar nu totale;
  • doar extensiile aprobate de AWS (lista este lungă: PostGIS, pg_stat_statements, pg_cron, pgaudit și altele);
  • configurația se face prin parameter groups, nu prin postgresql.conf;
  • nu poți folosi orice unealtă de backup sau de replicare fizică externă.

PostgreSQL pe EC2 îți dă control total: orice versiune, orice extensie, orice configurație, Patroni, pgBackRest. Dar tu răspunzi de sistemul de operare, discuri, backup, replicare, failover, monitorizare și securitate, adică de o mare parte din munca unui DBA.

Cum alegi:

  • Echipă mică, fără DBA dedicat: RDS este alegerea potrivită, EC2 este riscant.
  • Extensii sau setări speciale: pe RDS ești limitat, pe EC2 ai control complet.
  • Cost: RDS costă mai mult pe resursă, EC2 mai puțin, dar adaugi timpul de muncă al echipei.
  • Controlul asupra upgrade-urilor: parțial pe RDS, complet pe EC2.

Chiar și pe RDS rămân multe sarcini de DBA: proiectarea schemei, indecși, optimizarea interogărilor, roluri și drepturi, alegerea parametrilor, monitorizarea, planificarea capacității și testarea restaurării.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi ce preia cloud-ul și ce rămâne responsabilitatea ta. Mulți candidați cred greșit că RDS elimină nevoia de DBA.

89 Junior

Cum funcționează backup-urile și restaurarea în Amazon RDS?

Răspuns scurt: RDS face zilnic un snapshot automat al volumului și arhivează tranzacțiile continuu, ceea ce permite restaurarea la orice moment din perioada de retenție (1–35 de zile). Poți face și snapshot-uri manuale, păstrate până le ștergi. Orice restaurare creează o instanță nouă, nu suprascrie instanța existentă.

Backup-uri automate

  • Se activează prin perioada de retenție (BackupRetentionPeriod, între 1 și 35 de zile; 0 le dezactivează).
  • Zilnic, în fereastra de backup aleasă, RDS face un snapshot al volumului. Primul snapshot este complet, următoarele sunt incrementale la nivel de bloc.
  • În plus, RDS încarcă log-urile de tranzacții (WAL) în S3 la câteva minute, ceea ce permite restaurarea la un moment anume, de obicei până la ultimele 5 minute.

Snapshot-uri manuale

  • Le creezi tu, de exemplu înainte de o migrare riscantă, și rămân până le ștergi, chiar și după ștergerea instanței.
  • Se pot copia în altă regiune sau partaja cu alt cont AWS, pentru recuperare după dezastru.
BASH
aws rds create-db-snapshot \
  --db-instance-identifier magazin-prod \
  --db-snapshot-identifier magazin-inainte-de-migrare-2026-11-04

aws rds restore-db-instance-to-point-in-time \
  --source-db-instance-identifier magazin-prod \
  --target-db-instance-identifier magazin-recuperare \
  --restore-time 2026-11-04T12:31:00Z \
  --db-instance-class db.r7g.large --db-subnet-group-name privat

Ce trebuie reținut:

  • Restaurarea creează mereu o instanță nouă, cu alt endpoint. Pentru a o folosi în locul celei vechi, schimbi configurația aplicației sau redenumești instanțele.
  • Instanța restaurată primește parameter group-ul și security group-urile pe care le specifici; altfel le primește pe cele implicite, iar aplicația poate să nu se poată conecta.
  • Datele unui volum restaurat din snapshot se încarcă din S3 la prima accesare (lazy loading), deci primele interogări pot fi lente.
  • La ștergerea instanței, backup-urile automate se pierd dacă nu păstrezi un snapshot final.
  • Pentru retenție mai lungă sau centralizată, se folosește AWS Backup.

Ca și pe un server propriu, restaurarea trebuie testată: o restaurare periodică într-o instanță temporară, cu verificarea datelor și a duratei, apoi ștergerea instanței.

Ce urmărește intervievatorul: Se verifică dacă știi cum se face recuperarea în cloud și ce capcane are. Faptul că restaurarea creează o instanță nouă și că backup-urile automate dispar la ștergere sunt detalii importante.

90 Mid

Care e diferența dintre RDS Multi-AZ și o replică de citire (read replica)? Ce sunt parameter groups?

Răspuns scurt: Multi-AZ ține o replică sincronă în altă zonă, folosită pentru failover automat, nu pentru citire (în varianta clasică). O read replica este asincronă, poate fi citită și poate sta în altă regiune, dar promovarea ei este manuală. Parameter groups sunt seturi de parametri PostgreSQL aplicate instanțelor, în locul fișierului postgresql.conf.

Multi-AZ (instanță): RDS ține o instanță de rezervă în altă zonă de disponibilitate, cu replicare sincronă la nivel de stocare. Dacă primarul cade, sau la anumite operații de mentenanță, endpoint-ul DNS este mutat pe rezervă, de obicei în 1–2 minute. Rezerva nu poate fi folosită pentru citire. Scopul este disponibilitatea.

Multi-AZ DB cluster: o variantă mai nouă, cu un primar și două replici în zone diferite, care pot fi citite printr-un endpoint separat, cu failover mai rapid.

Read replica: replicare asincronă, folosită pentru a muta citirile (rapoarte, API-uri de citire) de pe primar. Poate fi în aceeași regiune sau în altă regiune (recuperare după dezastru). Se poate promova manual în instanță independentă, dar promovarea rupe legătura și nu este un failover automat. Poate avea lag, deci aplicația trebuie să-l tolereze.

Pe scurt, Multi-AZ (instanță) înseamnă replicare sincronă, fără citiri, cu failover automat, în aceeași regiune. Read replica înseamnă replicare asincronă, cu citiri, cu promovare manuală, și poate sta și în altă regiune.

Parameter groups: configurația PostgreSQL pe RDS se face printr-un grup de parametri atașat instanței. Grupul implicit nu se poate modifica, deci creezi unul propriu:

BASH
aws rds create-db-parameter-group --db-parameter-group-name pg17-magazin \
  --db-parameter-group-family postgres17 --description "Magazin prod"
aws rds modify-db-parameter-group --db-parameter-group-name pg17-magazin \
  --parameters "ParameterName=log_min_duration_statement,ParameterValue=500,ApplyMethod=immediate" \
               "ParameterName=shared_preload_libraries,ParameterValue='pg_stat_statements,pg_cron',ApplyMethod=pending-reboot"

Parametrii dinamici se aplică imediat; cei statici (ca shared_preload_libraries) cer o repornire, iar instanța apare cu starea pending-reboot. Multe valori implicite pe RDS sunt formule în funcție de memoria instanței (de exemplu shared_buffers = {DBInstanceClassMemory/32768}, unde unitatea este pagina de 8 kB). Gestionează parameter groups prin infrastructură ca cod (Terraform), ca toate mediile să fie identice.

Ce urmărește intervievatorul: Confuzia dintre Multi-AZ și read replicas este foarte frecventă. Intervievatorul verifică dacă știi scopul fiecăreia și cum se configurează parametrii pe RDS.

91 Mid

Ce setări de Linux contează pentru un server dedicat PostgreSQL?

Răspuns scurt: Gestionarea memoriei (vm.overcommit_memory, swappiness, huge pages, dezactivarea transparent huge pages), sistemul de fișiere și opțiunile de montare (ext4 sau xfs, noatime), discuri separate pentru date și WAL, limitele de fișiere deschise și sincronizarea orei. Toate se aplică prin fișiere de configurare, verificate după repornire.

PostgreSQL se bazează mult pe sistemul de operare, deci câteva setări au efect vizibil:

Memorie

INI
# /etc/sysctl.d/30-postgresql.conf
vm.overcommit_memory = 2         # alocările imposibile eșuează cu eroare, nu cu OOM killer
vm.overcommit_ratio = 80
vm.swappiness = 1                # evită mutarea memoriei PostgreSQL în swap
vm.dirty_background_bytes = 268435456   # scrieri în fundal mai devreme, vârfuri mai mici
vm.nr_hugepages = 4300           # calculat pentru shared_buffers
  • Huge pages (pagini de 2 MB): pentru shared_buffers de zeci de GB reduc consumul de memorie al tabelelor de pagini și cresc performanța. Setezi huge_pages = on în PostgreSQL (implicit este try). Numărul necesar îl afli cu postgres -D $PGDATA -C shared_memory_size_in_huge_pages (PostgreSQL 15+).
  • Transparent Huge Pages (THP): recomandarea obișnuită pentru baze de date este dezactivarea lor (never), pentru că pot produce pauze și consum imprevizibil de CPU.

Discuri și sistem de fișiere

  • ext4 sau xfs, montate cu noatime, ca fiecare citire să nu genereze o scriere de metadate;
  • WAL-ul pe un disc separat de date, dacă scrierile sunt intense;
  • pe SSD sau NVMe, planificatorul I/O none sau mq-deadline;
  • niciodată fsync = off sau sisteme de fișiere care mint despre fsync (anumite configurații de rețea sau cache-uri de controler fără baterie).

Alte setări

  • limitele de fișiere deschise pentru utilizatorul postgres (LimitNOFILE în unitatea systemd);
  • sincronizarea orei cu chrony, importantă pentru loguri, replicare și PITR;
  • profilul tuned potrivit (de exemplu throughput-performance) pe RHEL;
  • dezactivarea economisirii de energie a CPU-ului pe servere fizice, care poate adăuga latență.

Fiecare schimbare se aplică prin fișiere de configurare (nu doar cu comenzi temporare), se verifică după repornire și, ideal, se gestionează cu Ansible sau alte unelte de automatizare, ca toate serverele din cluster să fie identice.

Ce urmărește intervievatorul: Intervievatorul verifică dacă vezi serverul de baze de date ca întreg, nu doar PostgreSQL. Huge pages, THP și overcommit sunt subiectele care apar cel mai des.

92 Senior

Ai rula PostgreSQL de producție în containere sau în Kubernetes? Ce condiții ai pune?

Răspuns scurt: Se poate, dar doar cu un operator matur (CloudNativePG, Crunchy PGO, Zalando), stocare persistentă performantă, backup și PITR configurate, failover testat și o echipă care cunoaște atât Kubernetes, cât și PostgreSQL. Altfel, un serviciu gestionat sau mașini virtuale dedicate sunt alegeri mai sigure.

Containerele în sine nu sunt problema: PostgreSQL rulează bine într-un container. Dificultatea apare la orchestrare, unde Kubernetes a fost gândit inițial pentru aplicații fără stare, care pot fi oprite și mutate oricând. O bază de date are nevoie de stocare stabilă, de o ordine strictă la failover și de un singur primar garantat.

Argumente pentru:

  • un mod unic de lucru pentru toată infrastructura (deploy, monitorizare, configurație declarativă);
  • operatori care automatizează multe sarcini: replici, failover, backup cu PITR, upgrade-uri minore, pooling;
  • medii de test identice cu producția, create și șterse ușor.

Condiții pe care le-aș pune:

  • Un operator matur, nu un StatefulSet scris de mână: CloudNativePG, Crunchy Postgres for Kubernetes, Zalando Postgres Operator sau StackGres. Operatorul trebuie să gestioneze corect alegerea primarului și să prevină split-brain-ul.
  • Stocare persistentă performantă și testată: volume de bloc locale sau de rețea cu latență mică, IOPS garantat, snapshot-uri. Stocarea de tip NFS lentă este o rețetă pentru probleme.
  • Resurse garantate: requests egale cu limits pentru CPU și memorie (clasa QoS Guaranteed), noduri dedicate prin taints, reguli de anti-afinitate ca replicile să nu stea pe același nod sau în aceeași zonă.
  • PodDisruptionBudgets și o procedură clară pentru actualizarea nodurilor, ca un upgrade de cluster Kubernetes să nu oprească primarul fără switchover.
  • Backup în afara clusterului (stocare de obiecte), restaurare testată periodic, inclusiv recrearea întregului cluster din backup.
  • Monitorizare completă a PostgreSQL, nu doar a pod-urilor.
  • Competență în echipă: la 3 noaptea, cineva trebuie să înțeleagă și Kubernetes, și PostgreSQL. Dacă acea persoană nu există, complexitatea crește riscul.

Pentru o echipă mică, un serviciu gestionat (RDS, Cloud SQL, Azure Database) este adesea alegerea mai sigură. Pentru o platformă internă cu zeci de baze de date și o echipă dedicată, un operator bun pe Kubernetes poate fi o alegere foarte bună.

Ce urmărește intervievatorul: Este o întrebare de judecată, cu argumente valide în ambele sensuri. Intervievatorul evaluează dacă pui condiții concrete și dacă iei în calcul competențele echipei.

93 Senior

Cum muți o bază de date PostgreSQL de 800 GB de pe un server propriu în Amazon RDS, cu întrerupere minimă?

Răspuns scurt: Pregătești instanța RDS (versiune, parameter group, rețea, extensii), copiezi schema și rolurile, sincronizezi datele cu replicare logică nativă sau cu AWS DMS, validezi, faci repetiții și comuți într-o fereastră scurtă după ce replicarea este la zi. Păstrezi serverul vechi ca variantă de revenire.

Replicarea fizică nu este posibilă către RDS (nu ai acces la fișierele instanței), deci variantele sunt dump/restore (ore de întrerupere pentru 800 GB) sau replicare logică.

1. Evaluare. Versiunea sursă și cea țintă, extensiile folosite și dacă sunt disponibile pe RDS, funcții care cer superuser real, tabele fără cheie primară, obiecte mari, dimensiunea și volumul de modificări pe zi, latența rețelei între centrul de date și AWS (VPN sau Direct Connect).

2. Pregătirea țintei. Instanța RDS dimensionată după măsurători, Multi-AZ, parameter group propriu (inclusiv setările de replicare logică, dacă RDS va fi la rândul ei sursă pentru revenire), subnet-uri private, security groups, criptare, backup-uri automate activate. Migrezi rolurile (pg_dumpall --globals-only, adaptat, pentru că pe RDS nu poți crea superuseri) și schema (pg_dump --schema-only), fără indecșii secundari dacă vrei o încărcare inițială mai rapidă.

3. Sincronizarea.

  • Replicare logică nativă: pe sursă wal_level = logical, o publicație pentru toate tabelele, apoi pe RDS un abonament. Încărcarea inițială copiază tabelele, apoi modificările curg continuu.
  • AWS DMS: alternativă gestionată, utilă când sursa este mai veche sau ai nevoie de transformări; are propriile limitări de tipuri de date și trebuie testată atent.

În timpul sincronizării urmărești WAL-ul reținut de slot pe sursă, ca discul să nu se umple.

4. Validare. Număr de rânduri și sume de control pe tabelele principale, testele aplicației pe RDS (în citire), compararea planurilor de execuție după ANALYZE pentru interogările principale din pg_stat_statements.

5. Repetiție completă pe un mediu de test, cu cronometrarea comutării.

6. Comutarea. Îngheți DDL-ul, oprești scrierile (mentenanță sau PAUSE în PgBouncer), aștepți ca abonamentul să fie la zi, setezi secvențele pe RDS, muți conexiunile aplicației la endpoint-ul RDS, verifici. De obicei sunt câteva minute.

7. Revenire. Pregătești replicare logică inversă, de la RDS spre serverul vechi, ca datele noi să poată fi duse înapoi dacă apare o problemă gravă în primele zile.

8. După migrare. Ștergi publicația și slotul de pe sursă, activezi monitorizarea (Performance Insights / Database Insights, CloudWatch), testezi o restaurare PITR pe RDS și actualizezi documentația.

Ce urmărește intervievatorul: Migrarea în cloud este un proiect frecvent pentru DBA. Intervievatorul verifică dacă știi că replicarea fizică nu e posibilă către RDS și dacă planifici validarea, repetiția și revenirea.

Comportamentale și HR

94 Junior

De ce vrei să lucrezi ca Database Administrator?

Răspuns scurt: Leagă motivația de ceva concret: îți place ordinea, să înțelegi cum funcționează sistemele în profunzime și responsabilitatea pentru datele de care depinde o firmă. Arată cu un exemplu că ai investigat deja ceva din pasiune, de exemplu de ce o interogare era lentă.

Intervievatorul nu caută un răspuns perfect, ci unul sincer și coerent cu ce ai făcut până acum. Evită răspunsurile generale („IT-ul are viitor”, „se câștigă bine”) și mai ales ideea că DBA este un rol „mai liniștit decât programarea”: un DBA răspunde de incidente și are de multe ori cea mai mare responsabilitate din echipă.

O structură bună are trei părți:

  • Ce te atrage la meserie. De exemplu: îți place să înțelegi lucrurile până la capăt, să găsești cauza reală a unei probleme, să ai sisteme bine organizate și documentate.
  • O dovadă concretă. Un moment în care ai făcut deja ceva similar: ai optimizat un raport din Excel care dura o oră, ai construit acasă un laborator cu două servere PostgreSQL și replicare, ai citit planul unei interogări și ai înțeles de ce lipsea un index.
  • Legătura cu firma. Ce știi despre ei: ce baze de date folosesc, ce fel de date administrează, de ce te interesează domeniul lor.

Exemplu de răspuns:

„Am lucrat trei ani în contabilitate, cu rapoarte mari, și am ajuns să învăț SQL ca să-mi iau singură datele. Cel mai mult mi-a plăcut momentul în care am înțeles de ce o interogare dura zece minute și am redus-o la câteva secunde cu un index. Am continuat cu PostgreSQL și mi-am construit un laborator în Docker, cu replicare, backup și restaurare la un moment anume, pe care l-am documentat pe GitHub. Mă atrage responsabilitatea de a avea grijă ca datele să fie corecte și sigure. Știu că lucrați cu PostgreSQL în cloud pentru o aplicație folosită de mii de clienți, iar asta este exact direcția în care vreau să cresc.”

Dacă vii din altă meserie, prezintă experiența ca avantaj: rigoarea din contabilitate, calmul din suportul tehnic sau înțelegerea proceselor de business sunt foarte valoroase pentru un DBA.

Ce urmărește intervievatorul: Intervievatorul verifică motivația și dacă înțelegi ce presupune rolul. Un exemplu concret valorează mai mult decât orice declarație de entuziasm.

95 Junior

Povestește despre un proiect sau un laborator cu baze de date pe care l-ai construit singur.

Răspuns scurt: Alege un proiect pe care îl cunoști în detaliu și descrie problema, ce ai construit (schema, indecși, backup, replicare), o dificultate reală și cum ai rezolvat-o, plus ce ai face diferit acum. Ai pregătit linkul spre GitHub și poți arăta comenzile.

Pentru un junior fără experiență profesională ca DBA, laboratorul personal este principala dovadă de competență. Felul în care vorbești despre el contează la fel de mult ca proiectul în sine.

Structură recomandată (STAR adaptat):

  • Contextul: ce ai vrut să înveți sau să demonstrezi.
  • Ce ai construit: componentele concrete.
  • O problemă reală: ce nu a mers și cum ai investigat.
  • Rezultatul și ce ai învățat, inclusiv ce ai face altfel.

Exemplu:

„Am vrut să înțeleg cum se recuperează datele după o greșeală, așa că am construit un laborator în Docker Compose: un primar PostgreSQL 17 și o replică cu streaming replication, plus pgBackRest care face backup într-un container MinIO, compatibil S3. Am încărcat o bază de date de magazin cu câteva milioane de comenzi generate cu un script. Apoi am simulat un DELETE fără WHERE și am restaurat baza, pe un al treilea container, la momentul dinaintea ștergerii.

Prima încercare a eșuat: restaurarea se oprea cu o eroare că lipsea un segment de WAL. Am descoperit că archive_command dădea erori de permisiuni de două zile și eu nu observasem, pentru că nu aveam nicio alertă. Am reparat permisiunile, am adăugat un script care verifică pg_stat_archiver și trimite un mesaj dacă arhivarea eșuează și am documentat tot în README.

Am învățat că un backup fără test de restaurare și fără monitorizare a arhivării nu valorează aproape nimic. Acum aș adăuga Patroni pentru failover automat și un test de restaurare care rulează zilnic.”

Fii gata pentru întrebări de detaliu („De ce pgBackRest și nu pg_dump?”, „Cât a durat restaurarea?”, „Ce ar fi trebuit să se întâmple dacă pica primarul?”). Intervievatorii verifică des dacă proiectul este într-adevăr al tău.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă experiență practică și capacitatea de a învăța din greșeli. Povestea unei probleme reale și a rezolvării ei convinge mai mult decât un proiect „perfect”.

96 Junior

Firma folosește Oracle sau SQL Server, iar tu ai învățat PostgreSQL. Cum te pregătești să lucrezi cu un sistem nou?

Răspuns scurt: Explici că principiile sunt aceleași (SQL, indecși, tranzacții, backup, replicare, roluri) și descrii un plan concret: documentația oficială, un mediu de test gratuit (Oracle Free, SQL Server Developer), o tabelă de echivalențe între sisteme și exerciții pe sarcinile principale ale rolului.

Este o întrebare frecventă în România, unde multe firme mari, bănci și companii de telecom folosesc Oracle sau SQL Server. Răspunsul bun arată încredere fără să minimizeze diferențele.

1. Ce se transferă direct. SQL-ul standard, modelarea datelor, indecșii B-tree și planurile de execuție, tranzacțiile și nivelurile de izolare, principiile de backup și recuperare la un moment anume, replicarea, rolurile și drepturile, monitorizarea și metoda de depanare.

2. Ce diferă și trebuie învățat. Câteva exemple pe care le poți menționa:

  • Jurnalul de tranzacții: WAL în PostgreSQL, redo log și archive log în Oracle, transaction log în SQL Server.
  • Backup fizic: pg_basebackup și pgBackRest, RMAN în Oracle, BACKUP DATABASE și BACKUP LOG în SQL Server.
  • Replicare și disponibilitate: streaming replication și Patroni, Data Guard și RAC în Oracle, Always On Availability Groups în SQL Server.
  • Limbajul procedural: PL/pgSQL, PL/SQL în Oracle, T-SQL în SQL Server.
  • Versiunile vechi ale rândurilor: în tabel, curățate de VACUUM, în undo tablespace la Oracle, în tempdb la SQL Server (cu snapshot isolation).

3. Planul concret.

  • instalez gratuit Oracle Database Free sau SQL Server Developer Edition într-un container;
  • refac laboratorul pe care l-am construit pentru PostgreSQL: schemă, indecși, backup, restaurare, replicare;
  • urmez documentația oficială și, eventual, un traseu de certificare de nivel introductiv;
  • îmi fac o tabelă de echivalențe ca cea de mai sus, pe care o completez pe măsură ce învăț;
  • la job, cer să lucrez la început alături de un coleg cu experiență pe sistemul respectiv.

Exemplu de formulare: „Am învățat PostgreSQL în profunzime, inclusiv MVCC, WAL și recuperarea la un moment anume. Știu că Oracle are alte nume și alte unelte, ca RMAN și Data Guard, dar problemele pe care le rezolvă sunt aceleași. Am început deja să instalez Oracle Free și să refac pașii de backup și restaurare.”

Ce urmărește intervievatorul: Intervievatorul verifică adaptabilitatea și dacă înțelegi conceptele dincolo de un produs anume. Un plan concret și câteva echivalențe corecte fac răspunsul credibil.

97 Mid

Spune-ne despre o greșeală pe care ai făcut-o în producție. Ce s-a întâmplat și ce ai schimbat după?

Răspuns scurt: Alege o greșeală reală, cu impact, dar nu catastrofală. Descrie ce ai făcut, cum ai descoperit problema, cum ai limitat efectele și ai comunicat, iar apoi ce ai schimbat în proces ca să nu se repete. Asumă-ți partea ta fără să dai vina pe alții.

Toți cei care au lucrat cu baze de date în producție au greșit cel puțin o dată. Intervievatorul nu verifică dacă ai greșit, ci cum reacționezi: onestitate, calm, comunicare și învățare.

Ce să eviți:

  • „Nu am făcut nicio greșeală importantă”: nu este credibil;
  • o greșeală falsă de tipul „lucrez prea mult”;
  • vina pusă pe colegi, pe unelte sau pe management;
  • o poveste fără lecție și fără schimbare.

Structură:

  • Contextul și greșeala, pe scurt.
  • Cum ai descoperit-o și cât de repede.
  • Ce ai făcut imediat: ai limitat efectele, ai anunțat echipa.
  • Rezolvarea.
  • Ce ai schimbat în proces sau în unelte.

Exemplu:

„Am creat un index pe un tabel de comenzi de aproximativ 200 de milioane de rânduri, în timpul zilei, fără CONCURRENTLY. Comanda a luat un lock care a blocat scrierile în tabel, iar în câteva zeci de secunde aplicația de comenzi a început să dea timeout. Am văzut alertele, am găsit în pg_stat_activity că sesiunile așteptau după lock-ul meu și am anulat imediat comanda. Am anunțat pe canalul de incidente ce s-a întâmplat și că problema era rezolvată. Impactul a fost de aproximativ două minute de comenzi eșuate, pe care aplicația le-a reîncercat automat.

După incident am scris un postmortem fără vinovați. Am introdus trei schimbări: toate operațiile pe tabele mari trec printr-o listă de verificare, migrările rulează cu lock_timeout setat, iar în pipeline există o verificare care respinge CREATE INDEX fără CONCURRENTLY pe tabelele mari. De atunci nu s-a mai repetat.”

Un detaliu bun este momentul în care ai anunțat: echipele apreciază oamenii care spun repede „eu am cauzat asta, mă ocup”.

Ce urmărește intervievatorul: Intervievatorul evaluează responsabilitatea și maturitatea. Contează cât de repede ai recunoscut greșeala și ce ai schimbat în proces, nu cât de mică a fost.

98 Mid

Un programator senior îți cere acces de scriere direct în baza de producție ca să repare „rapid” niște date. Cum procedezi?

Răspuns scurt: Nu refuzi din principiu și nici nu dai accesul pe loc. Afli problema și urgența, propui o cale sigură (script revizuit, rulat într-o tranzacție, cu backup sau tabel de rezervă și verificare), cu acces temporar și auditat dacă e nevoie, apoi discuți o soluție permanentă care să nu mai ceară intervenții manuale.

Situația testează echilibrul dintre protecția datelor și colaborarea cu echipa. Un DBA care spune mereu „nu” ajunge ocolit, iar unul care spune mereu „da” ajunge să explice un incident.

1. Înțelege problema. Ce date sunt greșite, câți clienți sunt afectați, de când, cât de urgent este? Uneori „urgent” înseamnă clienți care nu pot plăti acum, alteori un raport intern care poate aștepta până mâine.

2. Propune o cale sigură, chiar și pentru urgențe:

  • modificarea se scrie ca script SQL, nu se tastează direct în consolă;
  • scriptul este revizuit de încă o persoană (chiar și rapid, pe chat);
  • înainte de modificare se salvează rândurile afectate;
  • rularea se face într-o tranzacție, cu verificarea numărului de rânduri înainte de COMMIT.
SQL
BEGIN;
CREATE TABLE backup_fix.comenzi_20261104 AS
  SELECT * FROM comenzi WHERE status = 'eronat' AND creat_la >= '2026-11-03';
UPDATE comenzi SET status = 'platita'
WHERE status = 'eronat' AND creat_la >= '2026-11-03' AND plata_id IS NOT NULL;
-- UPDATE 1832: corespunde cu numărul estimat? Abia apoi:
COMMIT;

3. Dacă e nevoie de acces, îl dai temporar și limitat: un rol cu drepturi doar pe tabelele necesare, cu expirare (VALID UNTIL), cu jurnalizarea operațiilor (pgaudit) și retras după intervenție. Sau rulezi tu scriptul împreună cu el.

4. Rezolvă cauza. Dacă astfel de reparații se repetă, este nevoie de o funcționalitate de administrare în aplicație, de o validare mai bună sau de corectarea bug-ului care produce datele greșite.

5. Respectă regulile firmei. În multe firme (bănci, plăți, date medicale), modificările în producție au un proces formal de aprobare. Îl urmezi și explici calm de ce există.

Tonul contează: „Hai să o facem împreună, în siguranță, în 15 minute” funcționează mult mai bine decât „nu am voie”.

Ce urmărește intervievatorul: Intervievatorul verifică judecata, comunicarea și protecția datelor. Răspunsul ideal oferă o soluție rapidă, dar sigură, și se gândește la cauza care a produs cererea.

99 Senior

Ești de gardă și primarul bazei de date a căzut la 3 noaptea. Failover-ul automat nu a pornit. Cum gestionezi incidentul, tehnic și ca și comunicare?

Răspuns scurt: Confirmi rapid impactul, deschizi incidentul și anunți, apoi stabilizezi: verifici starea replicilor și de ce nu a pornit failover-ul, alegi replica cea mai la zi, previi split-brain-ul izolând vechiul primar, promovezi și muți traficul. Comunici regulat stadiul, iar după incident scrii un postmortem fără vinovați.

Un incident major se gestionează pe două fronturi deodată: rezolvarea tehnică și coordonarea oamenilor. Cu cât incidentul e mai mare, cu atât contează mai mult să nu lucrezi singur și în tăcere.

1. Primele minute: confirmă și anunță.

  • Confirmi că problema e reală (alerte, pg_isready, eroarea din aplicație).
  • Deschizi incidentul în canalul stabilit, cu un mesaj scurt: ce se vede, impactul estimat, cine se ocupă, când revii cu informații.
  • Dacă impactul e mare, chemi ajutor conform procedurii de escaladare. Un coleg poate prelua comunicarea, ca tu să te concentrezi pe partea tehnică.

2. Diagnostic rapid.

  • Primarul este oprit sau doar inaccesibil prin rețea? Un primar „căzut”, dar încă activ, este cel mai periculos scenariu pentru split-brain.
  • De ce nu a pornit failover-ul? Patroni a pierdut legătura cu etcd, replica era prea în urmă (maximum_lag_on_failover), clusterul era în modul mentenanță (patronictl list)?
  • Starea replicilor: care are cel mai mare LSN aplicat?

3. Stabilizare.

  • Izolezi vechiul primar (îl oprești, îi tai traficul în security group sau firewall), ca să fii sigur că nu mai acceptă scrieri.
  • Promovezi replica cea mai la zi (patronictl failover sau pg_promote()).
  • Muți traficul: verifici că PgBouncer și HAProxy indică noul primar.
  • Verifici că aplicația scrie și citește normal și că erorile au dispărut.

4. Comunicare continuă. Actualizări la intervale fixe (de exemplu la 15–30 de minute), chiar dacă nu ai noutăți. La final: ce s-a întâmplat, cât a durat, dacă s-au pierdut date (cu replicare asincronă pot exista câteva tranzacții pierdute, care trebuie spuse deschis).

5. După incident.

  • Refaci redundanța: vechiul primar devine replică (pg_rewind sau reconstruire).
  • Postmortem fără vinovați, în câteva zile: cronologie, cauza principală și factorii care au contribuit, ce a mers bine, acțiuni concrete cu responsabili (de exemplu un test lunar de failover, alerte pe starea Patroni).

Un detaliu important pentru un senior: decizia de a promova manual, cu risc de pierdere de date, se ia împreună cu persoana care are autoritate de business, dacă procedura o cere. La 3 noaptea, o procedură scrisă dinainte te scutește de dezbateri.

Ce urmărește intervievatorul: Intervievatorul evaluează calmul, metoda și leadership-ul în criză. Comunicarea și prevenirea split-brain-ului contează la fel de mult ca pașii tehnici.

100 Senior

Cum convingi echipele de dezvoltare să adopte practici mai bune pentru baza de date, fără să devii un blocaj?

Răspuns scurt: Transformi regulile în unelte și automatizări (verificări în pipeline, șabloane de migrări, dashboard-uri cu interogările lente), oferi ajutor devreme, în faza de proiectare, explici costul real al problemelor cu date și construiești încredere prin rezultate, nu prin interdicții.

Într-o firmă cu multe echipe, un DBA care revizuiește manual fiecare migrare devine rapid un blocaj: echipele așteaptă, se frustrează și încep să-l ocolească. Un DBA senior își mută efortul spre unelte, educație și standarde clare.

1. Automatizează regulile.

  • verificări în pipeline-ul de CI pentru migrări: CREATE INDEX fără CONCURRENTLY pe tabele mari, ALTER TABLE fără lock_timeout, tipuri nepotrivite (float pentru bani, timestamp fără fus orar), lipsa indexului pe chei străine; unelte ca squawk analizează automat migrările SQL;
  • șabloane și biblioteci comune pentru migrări sigure;
  • medii de test cu volume realiste, ca problemele de performanță să apară înainte de producție.

2. Fă problemele vizibile.

  • un dashboard pe echipă cu cele mai costisitoare interogări din pg_stat_statements, cu numele aplicației (application_name);
  • un raport periodic scurt: „aceste trei interogări consumă 40% din CPU-ul bazei de date”;
  • costurile cloud atribuite fiecărei echipe, pentru că oamenii reacționează la costuri.

3. Intră devreme în proiecte. O discuție de 30 de minute despre schemă în faza de proiectare evită o migrare dureroasă peste un an. Ore de consultanță deschise („office hours”) în care oricine poate veni cu o întrebare.

4. Educă și dă autonomie. Sesiuni scurte despre citirea planurilor de execuție, indecși, tranzacții și migrări sigure. O documentație internă cu „cum facem X” și exemple. Un programator care știe să citească EXPLAIN nu mai are nevoie de tine pentru fiecare interogare.

5. Câștigă încredere prin rezultate. Când ajuți o echipă să reducă o pagină de la 4 secunde la 200 ms, povestea circulă mai bine decât orice regulă. Fii partener la incidente, nu judecător după ele.

6. Păstrează puține reguli stricte, pentru ce este cu adevărat periculos (acces în producție, migrări pe tabele critice, date personale), și explică de ce există fiecare.

Intervievatorii apreciază un exemplu concret: o regulă introdusă, cum ai convins echipele și ce efect măsurabil a avut.

Ce urmărește intervievatorul: Pentru un senior, influența contează la fel de mult ca tehnica. Intervievatorul caută automatizare, educație și empatie față de echipele de dezvoltare, nu un control rigid.

Întrebări de interviu pe tehnologii

Pregătire de interviu pentru alte meserii

Exerciții rezolvate pentru Database Administrator (PostgreSQL)

← 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 Database Administrator (PostgreSQL), 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 Database Administrator (PostgreSQL)

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.