...
Erori explicate

Erori System Design explicate: ce înseamnă și cum le repari

Mesajele de eroare System Design pe care le primești cel mai des, fiecare explicat pe înțeles: ce înseamnă, de ce apare, cod greșit lângă cod corect și cum o repari. Înveți de la zero cu Curs System Design: primele 10 lecții sunt gratuite.

Repară tu, direct în pagină: la fiecare eroare ai codul care o produce, în același mediu de lucru ca în lecțiile cursului.

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

  • 100erori
  • 9capitole
  • 29ușor
  • 56mediu
  • 15greu
Erori explicate System Design

Aici găsești erorile și simptomele care apar când o aplicație crește: 502, 503 și 504 de la load balancer, 429 Too Many Requests, pool-uri de conexiuni epuizate, replici rămase în urmă, shard-uri dezechilibrate, cache-uri care cad, CDN-uri care servesc conținut vechi, cozi care cresc fără oprire, puncte unice de eșec și căderi în cascadă. Pentru fiecare afli ce înseamnă, cauzele tipice cu exemple de configurație sau cod greșit și corectat, variantele mesajului și cum previi problema.

Pagina e organizată pe capitole, de la HTTP și scalare până la baze de date, cache, cozi și fiabilitate. Caută mesajul exact sau simptomul pe care îl vezi, citește cauzele, apoi repară situația direct în pagină, în simulatorul de arhitectură din curs: diagrama pornește cu problema, iar verificările trec doar când arhitectura ta o rezolvă.

Erori HTTP la proxy și load balancer: 502, 503, 504

Ușor Repară tu 502 Bad Gateway Proxy-ul sau load balancer-ul din fața aplicației a primit un răspuns invalid de la server, de obicei pentru că procesul aplicației a căzut, a repornit sau nu ascultă pe portul configurat. Verifici întâi logurile aplicației și ale proxy-ului, apoi health check-ul care trebuie să scoată instanțele moarte din rotație. Explicația completă → Ușor Repară tu 503 Service Unavailable Serverul (sau load balancer-ul din fața lui) spune că nu poate trata cererea acum: e supraîncărcat, în mentenanță sau nu are nicio instanță sănătoasă. De obicei repari adăugând capacitate (mai multe instanțe, autoscalare) și verificând de ce instanțele sunt marcate nesănătoase. Explicația completă → Ușor Repară tu 504 Gateway Timeout Proxy-ul sau load balancer-ul a așteptat răspunsul serverului mai mult decât îi permite timeout-ul și a renunțat. Serverul nu e neapărat căzut, ci lent: de obicei din cauza bazei de date supraîncărcate, a unei interogări fără index sau a unui serviciu extern apelat sincron. Explicația completă → Mediu Repară tu upstream timed out (110: Connection timed out) while reading response header from upstream Linia din logul de erori nginx care stă în spatele unui 504: nginx a trimis cererea la server și nu a primit nici măcar antetele răspunsului în `proxy_read_timeout`. Caută ce face serverul atât de mult: o operație lungă ținută sincron (un apel extern, un raport) se mută într-un job asincron. Explicația completă → Mediu Repară tu no live upstreams while connecting to upstream nginx a marcat toate serverele din blocul `upstream` ca indisponibile și nu mai are unde trimite cererea, așa că răspunde 502. Apare tipic când există un singur server și acela a căzut sau a dat câteva erori la rând. Repari cu cel puțin două instanțe sănătoase și investighezi de ce au căzut. Explicația completă → Ușor Repară tu connect() failed (111: Connection refused) while connecting to upstream nginx a încercat să deschidă o conexiune spre server și a primit refuz imediat: la adresa și portul din configurație nu ascultă niciun proces. Verifică dacă aplicația rulează, pe ce port ascultă și dacă `proxy_pass` / upstream-ul indică exact acea adresă. Explicația completă → Mediu Repară tu ERR_TOO_MANY_REDIRECTS după activarea HTTPS la load balancer sau CDN TLS se termină la load balancer sau CDN, care trimite cererile mai departe prin HTTP; aplicația vede HTTP și redirecționează la HTTPS, iar cererea se întoarce tot ca HTTP: buclă infinită. Configurează aplicația să citească `X-Forwarded-Proto` de la proxy-ul de încredere sau fă redirecționarea doar la load balancer. Explicația completă → Mediu Repară tu upstream prematurely closed connection while reading response header from upstream Serverul din spatele nginx a închis conexiunea înainte să trimită răspunsul, deci clientul primește 502. Cel mai des procesul a căzut (excepție netratată, OOM kill) sau a închis o conexiune keep-alive pe care nginx tocmai o refolosea. Caută în logurile aplicației și în `dmesg` exact la momentul erorii. Explicația completă → Mediu Repară tu 499 Client Closed Request Codul 499 apare doar în logurile nginx: clientul (browserul, aplicația mobilă sau un alt serviciu) a închis conexiunea înainte ca serverul să răspundă, pentru că s-a săturat să aștepte. Problema reală e lentoarea: află de ce durează cererile atât de mult. Explicația completă → Mediu Repară tu Health checks failed (Target.FailedHealthChecks) Load balancer-ul a marcat instanța ca nesănătoasă pentru că nu a răspuns corect la verificarea periodică (cod greșit, timeout, endpoint inexistent) și nu-i mai trimite trafic. Verifică endpoint-ul de health, timpul de pornire al aplicației și dacă health check-ul depinde inutil de baza de date. Explicația completă → Greu Repară tu Error: socket hang up (ECONNRESET) Conexiunea TCP a fost închisă de partea cealaltă (serverul, load balancer-ul sau un proxy) în timp ce clientul aștepta răspunsul sau tocmai trimitea o cerere pe ea. Cel mai des e o conexiune keep-alive refolosită după ce load balancer-ul a închis-o; aliniază timeout-urile și reîncearcă doar cererile idempotente. Explicația completă →

Servere supraîncărcate, scalare și sesiuni

Mediu Repară tu Error: EMFILE: too many open files (serverul refuză conexiuni noi) Procesul a atins limita de descriptori de fișier, iar pe Linux fiecare socket (conexiune de la clienți, conexiune la bază sau la un API) consumă unul. Cauzele sunt fie o scurgere (conexiuni sau fișiere neînchise), fie o limită prea mică pentru numărul real de conexiuni. Repară scurgerea și reutilizează conexiunile, apoi ajustează `nofile` dacă e nevoie. Explicația completă → Mediu Repară tu OOMKilled (exit code 137): containerul e omorât pentru că depășește memoria Containerul a depășit limita de memorie, iar kernelul l-a oprit cu SIGKILL (137 = 128 + 9), fără ca aplicația să poată termina cererile în curs. Măsoară consumul real, lasă loc pentru memoria din afara heap-ului (`-XX:MaxRAMPercentage=75`), repară scurgerile și ajustează limita după date, nu după ghicit. Explicația completă → Ușor Repară tu Factura de cloud a crescut mult: servere supradimensionate, încărcate sub 15% Ai pornit mult mai multe instanțe decât cere traficul (de la un vârf trecut sau din precauție) și rulează la 10–15% încărcare, deci plătești de câteva ori mai mult decât e nevoie. Dimensionează după încărcarea măsurată la vârf, cu rezervă N+1, și folosește autoscalarea pentru vârfuri. Explicația completă → Ușor Repară tu Utilizatorii sunt delogați aleatoriu după ce ai adăugat al doilea server Sesiunile sunt ținute în memoria fiecărui server, iar load balancer-ul trimite cererile următoare la alt server, care nu cunoaște sesiunea, deci utilizatorul pare delogat sau coșul se golește. Mută sesiunile într-un loc comun (Redis) sau folosește tokenuri, ca serverele să fie stateless. Explicația completă → Ușor Repară tu Error: connect ECONNREFUSED 127.0.0.1:6379 Aplicația încearcă să se conecteze la Redis pe mașina locală (127.0.0.1, portul 6379), dar acolo nu rulează niciun Redis. Pe un singur calculator merge, pe mai multe servere nu: Redis trebuie să fie un serviciu separat, comun, iar aplicația primește adresa lui din configurație. Explicația completă → Mediu Repară tu Un server la 100% CPU, celelalte aproape libere (load balancer cu IP hash) Load balancer-ul cu IP hash trimite toți utilizatorii cu aceeași adresă IP la același server. Când mulți vin din spatele aceluiași NAT (o firmă, un operator mobil), un server primește o mare parte din trafic. Fă serverele stateless (sesiuni în Redis) și folosește round robin sau least connections. Explicația completă → Ușor Repară tu Server supraîncărcat: CPU 100% chiar pe cea mai mare mașină Ai mărit serverul de câteva ori (mai multe nuclee, mai multă memorie), dar traficul tot îl duce la 100% CPU, iar cererile încep să dureze secunde. Scalarea verticală are o limită și un preț care crește repede; treci la scalare orizontală: mai multe instanțe identice în spatele unui load balancer. Explicația completă → Mediu Repară tu Autoscalarea nu ține pasul cu vârful de trafic (instanțele ajung la maxim, cererile tot se pierd) Grupul de autoscalare a ajuns la numărul maxim de instanțe sau pornește instanțe noi prea încet, iar la vârf serverele rămân supraîncărcate. Ridică limita maximă la cât cere vârful real, scalează după o metrică care reacționează devreme și ține un minim care acoperă creșterea bruscă. Explicația completă → Ușor Repară tu Instanțele noi nu primesc trafic: clientul apelează direct un singur server Ai pornit mai multe instanțe, dar DNS-ul sau aplicația client indică adresa unui singur server, deci tot traficul ajunge acolo, iar celelalte stau nefolosite. Pune un load balancer în față și fă ca DNS-ul să indice load balancer-ul, nu un server anume. Explicația completă → Mediu Repară tu Load balancer-ul a ajuns la limită: latență mare și conexiuni refuzate înainte de servere Serverele din spate sunt relaxate, dar cererile tot se pierd sau durează mult, pentru că load balancer-ul însuși (sau proxy-ul nginx/HAProxy pe care îl rulezi tu) nu mai face față numărului de cereri sau conexiuni. Adaugă instanțe load balancer-ului (sau trece pe unul gestionat) și elimină-l ca punct unic de eșec. Explicația completă → Mediu Repară tu API gateway-ul răspunde cu 503 la vârf, deși serviciile din spate au rezervă API gateway-ul verifică tokenul, aplică reguli și rutează fiecare cerere, deci are propria capacitate. Când traficul o depășește, răspunde cu 503 sau 504 înainte ca cererile să ajungă la servicii. Mai adaugă instanțe gateway-ului și elimină-l ca SPOF. Explicația completă →

Rate limiting: 429 și cereri respinse

Ușor Repară tu 429 Too Many Requests Clientul a trimis mai multe cereri decât permite limita serverului într-un interval, iar rate limiter-ul le respinge pe cele în plus. Ca utilizator al unui API, încetinește și respectă `Retry-After`; ca proprietar, verifică dacă limita e potrivită pentru traficul legitim și dacă se aplică pe client, nu global. Explicația completă → Ușor Repară tu Un robot (scraper) trimite mii de cereri pe secundă și oprește site-ul Un scraper, un client cu bug sau un atac trimite mult mai multe cereri decât pot duce serverele, iar utilizatorii normali primesc 502/503. Fără un rate limiter, toate cererile ajung la servere. Pune limitarea în fața load balancer-ului, ca surplusul să fie respins ieftin, cu 429. Explicația completă → Mediu Repară tu Rate limiter-ul nu respinge nimic: cererile îl ocolesc direct spre load balancer Ai pus un rate limiter, dar o parte din trafic ajunge la load balancer sau la servere pe altă cale (adresa directă a load balancer-ului, un domeniu vechi, un IP public al serverelor), deci limitarea nu se aplică. Închide toate intrările care nu trec prin limitator. Explicația completă → Mediu Repară tu Rate limiter-ul a căzut și a oprit tot API-ul Toate cererile trec prin rate limiter, deci dacă rulează într-o singură instanță (sau depinde de un singur Redis), căderea lui oprește întregul API, deși serverele sunt sănătoase. Rulează limitatorul în mai multe instanțe și decide conștient ce se întâmplă când contorul nu e disponibil. Explicația completă → Mediu Repară tu Rate limit cu fereastră fixă lasă să treacă de două ori limita la schimbarea minutului Cu algoritmul fixed window, contorul se resetează la începutul fiecărei ferestre, deci un client poate trimite limita întreagă la sfârșitul unei ferestre și încă o dată la începutul următoarei. Folosește sliding window sau token bucket, care urmăresc rata reală. Explicația completă → Greu Repară tu 429 Too Many Requests de la API-ul unui furnizor extern (SMS, plăți, email) Furnizorul extern are o limită de cereri pe secundă pe contul tău, iar aplicația ta (adesea mai multe instanțe sau workeri împreună) o depășește. Pune un limitator comun în fața apelurilor, respectă `Retry-After`, folosește o coadă ca tampon și trimite în loturi unde se poate. Explicația completă →

Baza de date: conexiuni, lock-uri, interogări lente

Mediu Repară tu N+1 queries: o pagină face sute de interogări la baza de date Codul citește o listă (1 interogare), apoi, pentru fiecare element, încă o interogare pentru datele asociate (N interogări), de obicei din lazy loading-ul unui ORM. La 100 de elemente, pagina face 101 interogări și supraîncarcă baza. Încarcă datele asociate într-o singură interogare (JOIN, fetch join, `IN (...)`) sau în loturi. Explicația completă → Mediu Repară tu Paginarea devine tot mai lentă la pagini mari (LIMIT ... OFFSET 500000) Cu `LIMIT 20 OFFSET 500000`, baza citește și aruncă 500.000 de rânduri pentru a returna 20, deci fiecare pagină e mai lentă decât precedenta, iar roboții care parcurg toate paginile încarcă baza. Folosește paginare cu cursor (keyset): `WHERE id > :ultimul_id ORDER BY id LIMIT 20`, pe o coloană indexată. Explicația completă → Mediu Repară tu FATAL: sorry, too many clients already PostgreSQL a atins `max_connections` (implicit 100) și refuză conexiuni noi. Apare tipic după scalarea aplicației: fiecare instanță are propriul pool, iar suma lor depășește limita. Calculează instanțe × mărimea pool-ului, micșorează pool-urile și pune un pooler (PgBouncer) în față. Explicația completă → Mediu Repară tu ERROR 1040 (HY000): Too many connections MySQL a atins `max_connections` (implicit 151) și nu mai acceptă clienți. Cauzele tipice sunt prea multe instanțe cu pool-uri mari, conexiuni care nu se închid (leak) sau conexiuni inactive ținute ore întregi. Vezi cine le ține cu `SHOW PROCESSLIST`, micșorează pool-urile și folosește un proxy de conexiuni. Explicația completă → Mediu Repară tu HikariPool-1 - Connection is not available, request timed out after 30000ms. Toate conexiunile din pool-ul Hikari au fost ocupate 30 de secunde, iar cererea a renunțat. Fie pool-ul e prea mic pentru câte interogări rulează simultan, fie interogările (sau tranzacțiile) durează prea mult, fie o conexiune nu e eliberată. Calculează cu legea lui Little câte conexiuni îți trebuie și caută interogările lente. Explicația completă → Mediu Repară tu sqlalchemy.exc.TimeoutError: QueuePool limit of size 5 overflow 10 reached, connection timed out, timeout 30.00 Pool-ul SQLAlchemy (5 conexiuni + 10 suplimentare) a rămas fără conexiuni libere 30 de secunde. Cel mai des, sesiunile nu sunt închise (leak) sau o cerere ține conexiunea foarte mult. Folosește `with Session(...)` sau dependințe care închid sesiunea, apoi dimensionează pool-ul. Explicația completă → Greu Repară tu ERROR: deadlock detected Două (sau mai multe) tranzacții așteaptă una după alta lock-uri pe care le țin reciproc, așa că PostgreSQL anulează una dintre ele. Cauza tipică e ordinea diferită de blocare a acelorași rânduri. Ia lock-urile mereu în aceeași ordine, ține tranzacțiile scurte și reîncearcă tranzacția anulată. Explicația completă → Mediu Repară tu Lock wait timeout exceeded; try restarting transaction Tranzacția ta a așteptat mai mult de `innodb_lock_wait_timeout` (implicit 50 de secunde) un lock pe rânduri ținute de altă tranzacție. Găsește tranzacția care ține lock-ul (`INNODB_TRX`, `innodb_lock_waits`) și scurteaz-o: fără lucru lent sau tranzacții uitate deschise. Explicația completă → Ușor Repară tu Slow query: Seq Scan pe un tabel mare (index lipsă) Interogarea citește tot tabelul rând cu rând (`Seq Scan` în PostgreSQL, `type: ALL` în MySQL) pentru că nu există un index pe coloana din `WHERE`. Pe tabele mari, fiecare citire durează și încarcă baza. Rulează `EXPLAIN ANALYZE`, creează indexul potrivit și verifică din nou planul. Explicația completă → Ușor Repară tu Căutarea cu LIKE '%text%' încarcă baza de date la 100% Un `LIKE '%cuvant%'` cu wildcard la început nu poate folosi un index B-tree, deci fiecare căutare scanează tot tabelul. La trafic mare de căutări, baza principală ajunge la 100%. Mută căutarea full-text într-un motor de căutare (Elasticsearch, OpenSearch) sau folosește un index full-text / trigram. Explicația completă → Mediu Repară tu Baza de date primară la 100% CPU din cauza citirilor Majoritatea interogărilor sunt citiri, iar baza primară, singura care le servește, a ajuns la limită. Mută citirile pe replici de citire (read replicas) și pune un cache în față pentru datele citite des; primara rămâne pentru scrieri. Explicația completă → Greu Repară tu Baza primară saturată de scrieri, iar replicile nu ajută Scrierile ajung toate la o singură bază primară, iar replicile nu pot prelua scrieri (le primesc și ele, prin replicare). Când volumul de scrieri depășește o mașină, împarte datele pe shard-uri după o cheie bine aleasă (de exemplu `client_id`), fiecare shard cu primara lui. Explicația completă → Mediu Repară tu ERROR: canceling statement due to statement timeout PostgreSQL a oprit interogarea pentru că a rulat mai mult decât `statement_timeout`. Timeout-ul și-a făcut treaba: a protejat baza de o interogare prea lungă. Optimizează interogarea (index, mai puține date), mut-o pe o replică sau precalculează rezultatul; nu dezactiva timeout-ul global. Explicația completă →

Replicare, sharding și consistență

Greu Repară tu Duplicate entry for key 'PRIMARY': id-uri duplicate după sharding cu auto-increment Fiecare shard (sau fiecare bază dintr-un setup multi-primar) generează id-uri cu propriul `AUTO_INCREMENT`, deci comenzi diferite primesc același id, iar coliziunile apar la unirea datelor, la mutarea între shard-uri sau în sistemele care caută după id. Folosește id-uri unice global: UUID v7, Snowflake sau secvențe cu pas diferit pe fiecare shard. Explicația completă → Mediu Repară tu Replication lag: utilizatorul nu-și vede modificarea imediat după salvare (read-your-writes) Scrierea a mers la primară, dar citirea imediat următoare a ajuns la o replică ce nu a aplicat-o încă, deci utilizatorul vede datele vechi. Replicarea asincronă are mereu o întârziere. Trimite la primară citirile care trebuie să vadă scrieri proaspete (datele proprii, imediat după salvare). Explicația completă → Ușor Repară tu Replica_IO_Running: No (replica nu primește modificările de la primară) Replica nu mai primește (sau nu a primit niciodată) jurnalul de modificări de la primară, deci datele de pe ea rămân vechi, iar citirile trimise acolo arată informații depășite. Verifică direcția și configurarea replicării: replica trebuie să citească de la primară, cu adresa, utilizatorul și poziția corecte. Explicația completă → Greu Repară tu Split brain: două noduri primare după o partiție de rețea După o întrerupere de rețea între noduri, ambele părți ale clusterului s-au crezut singure și fiecare a promovat un primar care a acceptat scrieri, deci datele au divergent. Previi cu cvorum (majoritate dintr-un număr impar de noduri), fencing pentru fostul primar și tokenuri de epocă. Explicația completă → Greu Repară tu ProvisionedThroughputExceededException: The level of configured provisioned throughput for the table was exceeded. DynamoDB a limitat cererile pentru că au depășit capacitatea configurată, de multe ori nu a tabelei întregi, ci a unei singure partiții spre care merg prea multe cereri (hot partition). Alege o cheie de partiție cu multe valori distribuite uniform și împarte cheile fierbinți cu sufixe. Explicația completă → Mediu Repară tu Shard-uri fără cheie de sharding: fiecare interogare ajunge pe toate shard-urile (scatter-gather) Datele sunt împărțite pe mai multe shard-uri, dar fără o cheie clară după care să găsești shard-ul potrivit, așa că fiecare interogare trebuie trimisă la toate și rezultatele adunate. Alege o cheie de sharding prezentă în interogările frecvente (de exemplu `user_id`) și rutează după ea. Explicația completă → Mediu Repară tu Un shard la 100%, celelalte aproape libere: cheie de sharding după dată Cheia de sharding după dată (sau după un id crescător, pe intervale) trimite toate scrierile noi pe același shard, care devine fierbinte, în timp ce shard-urile cu date vechi stau aproape libere. Alege o cheie cu multe valori, accesate uniform (de exemplu `client_id` cu hash). Explicația completă → Mediu Repară tu UnavailableException: Cannot achieve consistency level ALL Ai cerut ca fiecare operație să fie confirmată de toate replicile (consistency level ALL sau „strong”), iar un nod e căzut, deci baza refuză operația. Folosește QUORUM (majoritatea replicilor): rămâi consistent la citire și scriere și tolerezi căderea unui nod din trei. Explicația completă → Mediu Repară tu Cannot achieve consistency level QUORUM (factor de replicare 2) Cu factorul de replicare 2, majoritatea (QUORUM) înseamnă tot 2 replici, deci căderea oricărui nod care ține o copie face operațiile imposibile. Mărește factorul de replicare la 3: QUORUM devine 2 din 3 și tolerează un nod căzut. Explicația completă → Mediu Repară tu Produsul șters din coș reapare la refresh (citiri vechi cu consistență eventuală) Baza distribuită confirmă scrierea după o singură replică și citește tot de la una singură (consistență eventuală), deci o citire poate ajunge la o replică ce nu a primit încă ștergerea. Pentru date unde utilizatorul observă imediat diferența, folosește cvorum la scriere și la citire. Explicația completă → Ușor Repară tu Baza primară a căzut și tot site-ul s-a oprit (fără failover) Serverele sunt redundante, dar baza de date are o singură instanță, deci căderea ei oprește toate scrierile și citirile care nu sunt în cache. Adaugă o replică de rezervă cu failover automat (Multi-AZ, Patroni, replica set), ca o copie să preia rolul primarei în câteva zeci de secunde. Explicația completă → Mediu Repară tu Același loc vândut de două ori (lost update / race condition la rezervări) Două cereri simultane citesc aceeași valoare (un loc liber), o verifică și o actualizează, fiecare fără să vadă scrierea celeilalte, deci locul e vândut de două ori. Folosește un UPDATE atomic cu condiție, blocarea rândului (`FOR UPDATE`) sau optimistic locking cu versiune. Explicația completă →

Cache: stampede, date vechi, memorie plină

Mediu Repară tu Clienții văd valori diferite la fiecare reîncărcare (cache local diferit pe fiecare server) Fiecare server ține datele într-un cache propriu, în memorie, cu expirare independentă, iar load balancer-ul trimite cererile alternativ la servere: după o modificare, clienții văd valori vechi sau noi de la o reîncărcare la alta. Folosește un cache comun (Redis) sau invalidează toate cache-urile locale printr-un mesaj pub/sub. Explicația completă → Greu Repară tu Cache stampede (thundering herd): baza cade când expiră o cheie populară Când o cheie foarte citită expiră, toate cererile din acel moment ratează cache-ul și merg simultan în bază să recalculeze aceeași valoare, iar baza se supraîncarcă. Lasă o singură cerere să recalculeze (lock / single-flight), reîmprospătează cheia înainte să expire și adaugă jitter la TTL. Explicația completă → Greu Repară tu Cache avalanche: baza de date cade când cache-ul repornește sau se golește Baza a fost dimensionată doar pentru ratările cache-ului; când cache-ul pică, e golit (flush, deploy) sau multe chei expiră deodată, toate citirile ajung în bază și o supraîncarcă. Dimensionează baza (replici) să supraviețuiască fără cache, încălzește cache-ul înainte de trafic și împrăștie expirările. Explicația completă → Mediu Repară tu Cache penetration: cereri pentru chei care nu există trec mereu de cache până în bază Cererile pentru date care nu există (id-uri inventate, produse șterse) ratează mereu cache-ul, pentru că nu s-a pus nimic acolo, și ajung toate în bază. Pune în cache și răspunsul negativ (cu TTL scurt), folosește un filtru Bloom pentru id-urile existente și limitează clienții care generează astfel de cereri. Explicația completă → Ușor Repară tu Date vechi în cache după actualizare (prețul vechi apare încă pe site) Ai modificat datele în bază, dar cache-ul încă ține valoarea veche și o servește până expiră. La orice scriere, invalidează (șterge) cheia din cache imediat după scrierea în bază și păstrează un TTL rezonabil ca plasă de siguranță. Explicația completă → Mediu Repară tu OOM command not allowed when used memory > 'maxmemory'. Redis a ajuns la limita `maxmemory` și, cu politica de evacuare curentă (`noeviction` sau `volatile-*` fără chei cu TTL), nu poate elibera loc, așa că refuză scrierile. Pentru un cache, alege o politică precum `allkeys-lru`, pune TTL pe chei și dimensionează memoria după calcul. Explicația completă → Ușor Repară tu Rata de hit a cache-ului e mică (sub 50%), iar baza e tot supraîncărcată Cache-ul există, dar majoritatea citirilor tot ajung în bază: TTL-ul e prea scurt, cheile sunt prea specifice (conțin parametri care se schimbă), cache-ul e prea mic sau se invalidează prea des. Măsoară rata de hit, mărește TTL-ul acolo unde datele permit și normalizează cheile. Explicația completă → Mediu Repară tu ERR max number of clients reached Redis a atins `maxclients` (implicit 10.000) și refuză conexiuni noi. Cauza obișnuită e suma pool-urilor tuturor instanțelor sau conexiuni deschise la fiecare cerere și neînchise. Calculează instanțe × pool, folosește pool-uri mici și închide conexiunile. Explicația completă → Greu Repară tu Hot key: o singură cheie Redis primește tot traficul și supraîncarcă un nod O cheie foarte populară (promoția zilei, contorul unui clip viral) stă pe un singur nod al cache-ului, deci tot traficul ei lovește acel nod, oricât de mare ar fi clusterul. Adaugă un cache local cu TTL scurt, copiază cheia pe mai multe chei cu sufix sau citește de pe replici. Explicația completă → Mediu Repară tu Write-behind: comenzi pierdute după căderea cache-ului Cu write-behind (write-back), scrierea e confirmată din cache și ajunge în bază mai târziu, grupată. Dacă nodul de cache cade înainte de salvare, modificările confirmate se pierd. Pentru date importante (comenzi, plăți), scrie sincron în bază (write-through sau cache-aside cu invalidare). Explicația completă → Mediu Repară tu READONLY You can't write against a read only replica. Aplicația trimite scrieri unui nod Redis care e replică: fie a fost configurată cu adresa replicii, fie a rămas conectată la fostul master după un failover. Conectează aplicația prin Sentinel, Redis Cluster sau endpoint-ul primar al serviciului gestionat, ca să urmeze automat masterul curent. Explicația completă →

CDN, fișiere statice și upload-uri

Ușor Repară tu Pozele încărcate dau 404 pe alt server sau dispar după deploy (salvate pe discul local) Fișierele încărcate de utilizatori sunt salvate pe discul serverului care a primit upload-ul: celelalte servere nu le au (404 la jumătate din cereri), iar la redeploy sau la înlocuirea serverului se pierd. Salvează-le într-un object storage comun (S3, GCS, Azure Blob) și servește-le prin CDN. Explicația completă → Ușor Repară tu 413 Request Entity Too Large Cererea are un corp mai mare decât acceptă serverul sau proxy-ul din față (la nginx, implicit 1 MB prin `client_max_body_size`). Pentru fișiere mari, soluția bună nu e să mărești limita, ci să lași clientul să încarce direct în object storage, cu un URL presemnat. Explicația completă → Ușor Repară tu Imaginile și fișierele CSS/JS se încarcă greu: sunt servite de serverul de aplicație, fără CDN Fiecare imagine, fișier CSS sau JS trece prin load balancer și prin serverul de aplicație, de la un singur centru de date, deci se încarcă lent pentru utilizatorii îndepărtați și ocupă serverele. Pune un CDN în fața lor: fișierele se servesc din noduri apropiate de utilizator, iar serverul vede doar ratările. Explicația completă → Mediu Repară tu X-Cache: Miss from cloudfront la aproape fiecare cerere (rata de hit a CDN-ului e mică) CDN-ul există, dar aproape fiecare cerere e o ratare și merge la origine: antetele `Cache-Control` lipsesc sau interzic cache-ul, URL-urile au parametri care se schimbă (timestamp, utm), sau TTL-ul e foarte scurt. Corectează antetele și cheile de cache, iar originea primește doar ratările reale. Explicația completă → Mediu Repară tu CDN-ul servește fișierele vechi după deploy (CSS/JS vechi, pagina stricată) După deploy, CDN-ul (și browserele) au încă în cache versiunea veche a fișierelor cu același nume, iar HTML-ul nou se combină cu JavaScript sau CSS vechi. Folosește nume de fișiere cu hash (cache busting) și TTL lung pentru ele, iar HTML-ul cu revalidare; purge-ul e doar o soluție de urgență. Explicația completă → Mediu Repară tu Access to font at 'https://cdn.magazin.ro/...' from origin 'https://magazin.ro' has been blocked by CORS policy: No 'Access-Control-Allow-Origin' header is present on the requested resource. Browserul a blocat fontul (sau fișierul cerut cu `fetch`) de pe domeniul CDN-ului pentru că răspunsul nu are antetul `Access-Control-Allow-Origin` pentru site-ul tău. Configurează CORS la origine (bucket / server), fă CDN-ul să transmită antetul `Origin` și să-l includă în cheia de cache, apoi invalidează răspunsurile vechi. Explicația completă → Mediu Repară tu could not extend file "base/16384/24576": No space left on device (fișiere salvate pe disc / în bază) Discul bazei de date (sau al serverului) s-a umplut, de obicei pentru că fișierele încărcate de utilizatori (poze, PDF-uri) sunt salvate în bază sau pe discul local. Mută fișierele într-un object storage și păstrează în bază doar metadatele (cheia fișierului, mărimea, proprietarul). Explicația completă →

Cozi de mesaje și procesare asincronă

Ușor Repară tu Coada crește continuu (consumer lag / backlog): mesajele se procesează cu ore întârziere Mesajele intră în coadă mai repede decât le pot procesa consumatorii, deci numărul lor (și vechimea celui mai vechi) crește fără oprire. Adaugă consumatori (workeri) sau fă procesarea mai rapidă, și scalează după lungimea cozii, nu după CPU. Explicația completă → Ușor Repară tu Mesajele stau în coadă și nu le procesează nimeni (niciun consumator conectat) Producătorul publică mesaje, dar niciun consumator nu e abonat la coadă (worker oprit, nume de coadă greșit, binding lipsă), deci mesajele se adună sau, într-un exchange fără coadă, se pierd. Pornește workerii și verifică că ascultă exact coada (sau topicul) în care publici. Explicația completă → Mediu Repară tu Același mesaj procesat de două ori (clientul primește două SMS-uri / e taxat de două ori) Cozile garantează de obicei livrarea „cel puțin o dată” (at-least-once): după un timeout, o eroare sau o reîncercare, același mesaj poate ajunge de două ori la consumator. Fă procesarea idempotentă: salvează id-ul mesajului procesat și ignoră duplicatele, sau folosește chei de idempotență la apelurile externe. Explicația completă → Mediu Repară tu Poison message: același mesaj eșuează la nesfârșit și blochează coada Un mesaj care nu poate fi procesat niciodată (date invalide, un bug) e reîncercat la infinit, consumă workeri și, în cozile ordonate, blochează mesajele din spatele lui. Limitează reîncercările și mută mesajul într-o dead letter queue (DLQ) după N eșecuri, apoi analizează-l separat. Explicația completă → Mediu Repară tu Mesaje pierdute: consumatorul confirmă (ack) înainte să termine procesarea Consumatorul spune brokerului „am primit” (ack, commit de offset, delete în SQS) înainte să termine lucrul. Dacă procesul cade între confirmare și finalizare, mesajul e pierdut definitiv. Confirmă doar după ce efectul e salvat și fă procesarea idempotentă, pentru eventualele relivrări. Explicația completă → Greu Repară tu Mesajele ajung în altă ordine decât au fost trimise (comanda apare plătită după ce a fost anulată) Cozile cu mai mulți consumatori, reîncercările și partițiile multiple nu păstrează ordinea globală, deci evenimentele aceleiași entități pot fi procesate invers. Păstrează ordinea acolo unde contează (cheie de partiție = id-ul entității, FIFO cu grup de mesaje) și adaugă versiuni, ca un eveniment vechi să fie ignorat. Explicația completă → Greu Repară tu CommitFailedException: Commit cannot be completed since the group has already rebalanced and assigned the partitions to another member. Consumatorul Kafka a lucrat prea mult între două apeluri `poll()` (peste `max.poll.interval.ms`), a fost scos din grup, iar partițiile lui au fost date altui consumator, deci commit-ul nu mai e acceptat și mesajele vor fi procesate din nou. Ia loturi mai mici, fă procesarea mai rapidă și consumatorul idempotent. Explicația completă → Mediu Repară tu SQS: același mesaj e procesat în paralel de doi workeri (visibility timeout prea scurt) SQS ascunde un mesaj primit doar pe durata visibility timeout-ului (implicit 30 de secunde). Dacă procesarea durează mai mult și mesajul nu e șters, el redevine vizibil și e preluat de alt worker, deci e procesat de două ori. Setează timeout-ul peste durata maximă a procesării sau prelungește-l din worker. Explicația completă → Mediu Repară tu Doar unul dintre servicii primește evenimentul (coadă partajată în loc de pub/sub) Ai pus mai multe servicii (email, stoc, facturi) să citească din aceeași coadă, dar o coadă dă fiecare mesaj unui singur consumator, deci fiecare serviciu vede doar o parte din comenzi. Pentru ca toate să primească fiecare eveniment, folosește pub/sub: un topic cu câte o coadă (sau abonare) pentru fiecare serviciu. Explicația completă → Ușor Repară tu Plasarea comenzii durează secunde: emailul de confirmare e trimis sincron, în cerere Cererea de plasare a comenzii așteaptă furnizorul de email (SMTP sau API), care răspunde în secunde, deci clientul așteaptă și el. Emailul nu trebuie să fie gata înainte de răspuns: publică un eveniment în coadă și lasă workerii să-l trimită. Explicația completă → Mediu Repară tu Brokerul de mesaje unic a căzut și comenzile nu se mai pot plasa Toate comenzile publică un eveniment în coadă, iar brokerul rulează într-o singură instanță: când cade, publicarea eșuează și comenzile dau erori. Rulează brokerul în cluster (de exemplu 3 noduri, cozi replicate) sau folosește un serviciu gestionat. Explicația completă →

SPOF, căderi în cascadă, securitate și monitorizare

Ușor Repară tu Single point of failure (SPOF): o singură componentă cade și oprește tot site-ul O componentă rulează într-un singur exemplar pe drumul tuturor cererilor (un server de aplicație, o bază fără standby, un singur load balancer), deci căderea ei oprește tot sistemul. Pune cel puțin două instanțe în spatele unui load balancer cu health check sau un standby cu failover automat. Explicația completă → Mediu Repară tu Disponibilitatea scrierilor e sub SLA-ul promis (99,95%) Ai promis clienților o disponibilitate (de exemplu 99,95%), dar arhitectura nu o poate atinge: disponibilitățile componentelor în serie se înmulțesc, iar o bază de date fără rezervă trage totul în jos. Adaugă redundanță pe componentele slabe, mai ales pe baza de date, și calculează disponibilitatea totală. Explicația completă → Mediu Repară tu Când pică un server, celelalte se supraîncarcă și cad și ele (fără capacitate N+1) Ai mai multe instanțe, dar fiecare rulează la 60–70%: când una cade, traficul ei se mută pe celelalte, care trec de 100% și încep să cadă la rândul lor. Dimensionează pentru N+1: restul instanțelor trebuie să ducă tot traficul fără una (sau fără o zonă întreagă). Explicația completă → Greu Repară tu Cădere în cascadă: un serviciu lent oprește și serviciile care depind de el O dependență devine lentă sau cade, iar serviciile care o apelează sincron își blochează thread-urile și conexiunile așteptând-o, apoi cad și ele, iar căderea se propagă în tot sistemul. Pune timeout-uri scurte, circuit breaker, bulkhead-uri și degradare grațioasă la fiecare apel spre altă componentă. Explicația completă → Mediu Repară tu CallNotPermittedException: CircuitBreaker 'plati' is OPEN and does not permit further calls Circuit breaker-ul din fața unei dependențe s-a deschis pentru că prea multe apeluri recente au eșuat sau au fost lente, deci respinge imediat apelurile noi o perioadă. Nu e cauza problemei, ci protecția: verifică dependența, tratează excepția cu un fallback și ajustează pragurile doar dacă sunt evident greșite. Explicația completă → Mediu Repară tu Un serviciu extern lent blochează toate thread-urile serverului (timeout prea mare) Fiecare cerere apelează sincron un serviciu extern; când acesta devine lent, thread-urile serverului stau blocate până la timeout (adesea 30–60 de secunde sau infinit), iar serverul nu mai poate servi nimic. Pune timeout-uri scurte, potrivite cu durata normală a apelului, plus circuit breaker și fallback. Explicația completă → Mediu Repară tu Retry storm: reîncercările fără backoff înmulțesc traficul și țin serviciul căzut La primele erori, toți clienții reîncearcă imediat, de mai multe ori, iar serviciul deja suprasolicitat primește de câteva ori mai mult trafic și nu-și mai poate reveni. Reîncearcă doar erorile temporare, cu backoff exponențial și jitter, cu un număr mic de încercări și un buget de reîncercări. Explicația completă → Mediu Repară tu Site-ul cade sau dă 502 la fiecare deploy La deploy, toate instanțele sunt oprite odată sau se opresc fără să termine cererile în curs, iar load balancer-ul le trimite încă trafic, deci utilizatorii primesc 502/503 câteva secunde sau minute. Folosește rolling sau blue-green deploy, readiness checks, drain la load balancer, graceful shutdown și migrări compatibile cu ambele versiuni. Explicația completă → Ușor Repară tu Aflăm de căderi de la clienți: sistemul nu are monitorizare Nicio componentă nu trimite metrici, loguri sau trace-uri spre un sistem de monitorizare, deci problemele (latență, erori, încărcare) se văd abia când se plâng clienții, iar cauza se ghicește. Colectează metrici și loguri de la fiecare componentă și urmărește semnalele de bază: latență, trafic, erori, saturație. Explicația completă → Ușor Repară tu Dashboard-ul arăta problema de o oră, dar nimeni nu s-a uitat (monitorizare fără alerte) Metricile și dashboard-urile există, dar nimeni nu e anunțat când ceva iese din normal, deci problemele se văd doar dacă cineva se uită întâmplător. Configurează alerte pe simptome vizibile pentru utilizatori (rata de erori, latența p99, vechimea cozilor), trimise unei persoane de gardă. Explicația completă → Ușor Repară tu Not secure: site-ul e servit prin HTTP, fără HTTPS Browserul afișează „Not secure” (Nesecurizat) pentru că pagina vine prin HTTP necriptat: parolele, cookie-urile și datele de plată circulă în clar prin rețea. Activează HTTPS la marginea sistemului (load balancer sau CDN), cu un certificat valid reînnoit automat, și redirecționează tot traficul HTTP spre HTTPS. Explicația completă → Ușor Repară tu NET::ERR_CERT_DATE_INVALID: certificatul TLS a expirat și site-ul nu mai poate fi accesat Certificatul TLS al site-ului a expirat (sau, mai rar, ceasul dispozitivului e greșit), iar browserele blochează accesul cu un avertisment de securitate. Reînnoiește certificatul, reîncarcă serverul web și automatizează reînnoirea, cu alertă înainte de expirare. Explicația completă → Mediu Repară tu API-ul răspunde oricui: cererile nu sunt autentificate la API gateway Endpoint-urile API sunt accesibile fără token, deci oricine (inclusiv roboți) poate citi sau modifica date doar știind URL-ul. Verifică autentificarea centralizat, la API gateway (JWT, chei API, OAuth), și autorizarea pe fiecare resursă în aplicație. Explicația completă → Ușor Repară tu Datele sensibile sunt necriptate pe disc și în backup-uri Baza de date și backup-urile ei sunt stocate necriptat, deci oricine ajunge la un disc, un snapshot sau o arhivă de backup (un bucket public, un laptop pierdut) citește direct datele. Activează criptarea la stocare (encryption at rest) pentru bază, snapshot-uri și backup-uri, cu chei gestionate separat. Explicația completă → Mediu Repară tu Baza de date e accesibilă direct din internet (portul 5432 / 3306 deschis) Baza de date are adresă publică și portul deschis spre oricine, iar unii clienți (o aplicație desktop, un script, chiar frontend-ul) se conectează direct la ea. Scanerele automate o găsesc în câteva ore. Pune baza într-o rețea privată, permite conexiuni doar de la serverele de aplicație și expune datele printr-un API. Explicația completă → Mediu Repară tu Backup-ul există, dar restaurarea eșuează sau durează ore (RPO / RTO netestate) Backup-urile rulează de luni de zile, dar nimeni nu a încercat o restaurare: la incident, se descoperă arhive corupte, lipsă, prea vechi sau o restaurare care durează ore. Definește RPO (cât poți pierde) și RTO (cât poți sta oprit), folosește point-in-time recovery și testează restaurarea periodic. Explicația completă → Greu Repară tu Media latenței e mică, dar p99 e de secunde (tail latency): unii utilizatori așteaptă mult Media arată bine (80 ms), dar 1% din cereri durează secunde: cache miss-uri, pauze de garbage collection, cozi la pool-uri saturate sau o interogare lentă pentru anumite date. Măsoară percentile (p95, p99), nu medii, găsește cererile lente prin tracing și alertează pe p99. Explicația completă → Greu Repară tu Toate serverele au fost scoase din rotație deodată: health check-ul verifică baza de date Health check-ul fiecărui server verifică și baza de date (sau alt serviciu comun); când acea dependență are o problemă de câteva secunde, toate serverele raportează simultan „unhealthy”, iar load balancer-ul le scoate pe toate. Fă health check-ul / liveness-ul să verifice doar procesul și monitorizează separat dependențele. Explicația completă →

Erori explicate la alte tehnologii

← Toate erorile explicate

Tudor Andrei Dumitrescu
Cine coordonează paginile

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. Fiecare eroare de aici a fost reprodusă în editorul nostru: codul greșit chiar dă mesajul din titlu, iar reparația chiar funcționează.

Învață System Design de la zero, cu exerciții la fiecare lecție

Curs System Design: lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 10 lecții sunt gratuite.