...
Pregătire interviuri

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

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

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

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

La un interviu în care se verifică AWS, întrebările merg de obicei pe trei planuri: cât de bine cunoști serviciile de bază (IAM, EC2, S3, VPC, RDS, Lambda), dacă le poți configura corect și sigur (o politică IAM, un security group, o regulă de lifecycle, o comandă AWS CLI) și cum le combini într-o arhitectură care rezistă la căderi și nu costă mai mult decât trebuie. Multe interviuri includ un exercițiu de tip „desenează arhitectura” sau „unde e greșeala în această politică”, iar unele firme dau o temă practică cu CloudFormation, Terraform sau un mic API serverless.

Pentru un post de junior contează să explici clar conceptele (regiuni și zone, modelul responsabilității partajate, roluri față de utilizatori, subrețele publice și private) și să știi pașii concreți din consolă și din CLI. La nivel mid se așteaptă depanare (de ce nu ajunge traficul, de ce se repornesc instanțele, de ce o politică refuză accesul), securitate aplicată și infrastructure as code. Întrebările de senior verifică decizii de arhitectură: mai multe conturi, recuperare după dezastre, sisteme bazate pe evenimente, migrări și compromisul dintre cost și disponibilitate.

Folosește pagina ca pe un set de exerciții: citește întrebarea, răspunde cu voce tare sau schițează soluția pe hârtie, apoi compară cu răspunsul scurt și cu explicația detaliată. Unde se poate, refă exemplele într-un cont de test, cu un buget și alerte de facturare setate. Prețurile nu sunt menționate intenționat, pentru că diferă între regiuni și se schimbă; le verifici în AWS Pricing Calculator.

Fundamente: regiuni, cont, CLI

1 Junior

Ce înseamnă IaaS, PaaS și SaaS? Dă câte un exemplu de serviciu AWS pentru fiecare.

Răspuns scurt: Sunt niveluri de abstractizare: la IaaS primești infrastructură (de exemplu EC2), la PaaS o platformă pe care doar îți urci codul (de exemplu Elastic Beanstalk), iar la SaaS un produs gata de folosit (de exemplu Amazon WorkMail).

Diferența dintre modele este cât gestionezi tu și cât gestionează furnizorul.

  • IaaS (Infrastructure as a Service): primești mașini virtuale, rețea și discuri. Tu instalezi sistemul de operare, patch-urile, runtime-ul și aplicația. Exemple AWS: EC2, EBS, VPC.
  • PaaS (Platform as a Service): furnizorul se ocupă de servere, sistem de operare și runtime, tu aduci codul și configurația. Exemple: Elastic Beanstalk, App Runner, iar într-un sens larg și RDS sau Lambda, unde nu mai vezi serverul deloc.
  • SaaS (Software as a Service): folosești o aplicație completă, fără să administrezi nimic tehnic. Exemple AWS: Amazon WorkMail, Amazon Chime; în afara AWS, Gmail sau Slack.

Granițele nu sunt rigide. Lambda e adesea numit FaaS (Function as a Service) sau serverless, iar RDS este un serviciu gestionat care stă între IaaS și PaaS.

La interviu merită legat modelul de compromisuri: cu cât urci spre SaaS, cu atât ai mai puțină muncă operațională, dar și mai puțin control (nu alegi versiunea kernelului, nu instalezi agenți proprii). Alegerea depinde de ce vrea echipa să controleze și de cât efort de operare își permite.

Ce urmărește intervievatorul: Verifică dacă înțelegi împărțirea muncii între tine și furnizor, nu doar acronimele. Greșeala tipică: exemple fără legătură cu ce gestionezi efectiv în fiecare model.

2 Junior

Firma ta lansează o aplicație pentru clienți din România. Cum alegi regiunea AWS în care o rulezi?

Răspuns scurt: Te uiți la patru criterii: cerințele legale și de conformitate privind datele, latența față de utilizatori, disponibilitatea serviciilor de care ai nevoie în regiunea respectivă și prețul, care diferă de la o regiune la alta.

O regiune este o zonă geografică separată, cu propriile zone de disponibilitate. Alegerea ei e o decizie greu de schimbat ulterior, așa că se cântărește de la început.

  • Conformitate: dacă procesezi date personale ale cetățenilor UE, echipa juridică poate cere ca datele să rămână în UE. Atunci alegi o regiune europeană, de exemplu eu-central-1 (Frankfurt) sau eu-south-2 (Spania), în funcție de ce servicii îți trebuie.
  • Latența: o regiune apropiată geografic de utilizatori reduce timpul de răspuns. Poți măsura latența reală din rețeaua clienților înainte să decizi.
  • Servicii disponibile: nu toate serviciile și nu toate tipurile de instanțe apar simultan în toate regiunile. Verifici lista serviciilor pe regiune pentru tot ce ai în arhitectură.
  • Cost: prețurile aceluiași serviciu variază între regiuni. Compari în AWS Pricing Calculator.

Contează și unde e restul infrastructurii: transferul de date între regiuni se taxează și adaugă latență, deci e bine ca aplicația și baza de date să fie în aceeași regiune. Pentru conținut static servit global, CloudFront reduce latența indiferent de regiunea de bază.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă că știi mai mult decât „aleg regiunea cea mai apropiată”. Candidații uită de conformitate și de disponibilitatea serviciilor.

3 Junior

Care servicii AWS sunt globale, care sunt regionale și care sunt legate de o zonă de disponibilitate? Dă exemple.

Răspuns scurt: IAM, Route 53 și CloudFront sunt globale; S3 (bucketul stă într-o regiune), Lambda, DynamoDB și VPC sunt regionale; o instanță EC2, un volum EBS și o subrețea trăiesc într-o singură zonă de disponibilitate.

Contează să știi unde „trăiește” fiecare resursă, pentru că de asta depind disponibilitatea și locul în care o cauți în consolă.

  • Globale: IAM (utilizatorii și rolurile sunt valabile în toate regiunile), Route 53, CloudFront, AWS Organizations.
  • Regionale: S3, Lambda, DynamoDB, SQS, SNS, VPC, RDS ca serviciu. Numele bucketurilor S3 sunt unice global, de aceea consola S3 pare globală, dar fiecare bucket are datele într-o regiune aleasă la creare.
  • Zonale: o instanță EC2, un volum EBS, o subrețea, un NAT gateway. Un volum EBS se poate atașa doar unei instanțe din aceeași zonă.

Consecința practică: dacă o zonă are probleme, resursele zonale din ea sunt afectate, iar serviciile regionale gestionate (S3, DynamoDB, SQS) sunt construite de AWS să reziste la căderea unei zone. Pentru resursele tale zonale, reziliența o faci tu: instanțe în cel puțin două zone, subrețele în fiecare zonă, RDS Multi-AZ.

O greșeală frecventă la început: creezi o instanță în eu-west-1, apoi o cauți în consolă în altă regiune și crezi că a dispărut.

Ce urmărește intervievatorul: Verifică dacă înțelegi domeniul de defectare al fiecărei resurse. Mulți cred că S3 este global pentru că numele bucketului este unic global.

Eroarea, în practică:IllegalLocationConstraintExceptionInvalidAMIID.NotFound: image id does not exist

4 Junior

Ai creat un cont AWS nou. Ce faci cu utilizatorul root și de ce?

Răspuns scurt: Activezi MFA pe root, nu creezi chei de acces pentru el, setezi date de contact și facturare corecte, apoi creezi identități separate pentru munca de zi cu zi și folosești root doar pentru puținele operații care îl cer.

Utilizatorul root este identitatea creată cu adresa de email a contului. Are acces complet și nu poate fi restricționat prin politici IAM obișnuite (doar prin SCP-uri, dacă contul e membru într-o organizație AWS Organizations). Dacă e compromis, atacatorul controlează tot, inclusiv facturarea și închiderea contului.

Pașii recomandați imediat după creare:

  • activezi MFA pe root, ideal o cheie hardware sau o aplicație de autentificare;
  • ștergi sau nu creezi niciodată chei de acces pentru root;
  • folosești o parolă lungă, unică, păstrată într-un manager de parole;
  • creezi un utilizator administrativ prin IAM Identity Center sau un utilizator IAM cu drepturi de administrator și lucrezi de acolo;
  • configurezi un buget și alerte de facturare.

Puține operații cer root: schimbarea setărilor contului (email, plan de suport), închiderea contului, restaurarea permisiunilor IAM când un administrator s-a blocat singur, anumite setări de facturare. Pentru orice altceva, root rămâne nefolosit.

Bonus la interviu: menționezi că pornești CloudTrail și alerte pe autentificările root, ca să afli imediat dacă cineva îl folosește.

Ce urmărește intervievatorul: E o întrebare de igienă de securitate. Greșeala tipică: candidatul spune că lucrează zilnic cu root „pentru că e contul lui”.

5 Junior

În modelul responsabilității partajate, cine aplică patch-urile de sistem de operare pentru o instanță EC2, pentru o bază de date RDS și pentru o funcție Lambda?

Răspuns scurt: Pe EC2 tu aplici patch-urile sistemului de operare; pe RDS, AWS face patch-urile de sistem și de motor, iar tu alegi fereastra de mentenanță; pe Lambda, AWS gestionează sistemul și runtime-ul, iar tu răspunzi de cod și de dependențele lui.

Ideea generală: AWS răspunde de securitatea cloud-ului (centre de date, hardware, rețea fizică, hypervisor), iar clientul de securitatea în cloud (date, identități, configurație). Linia se mută în funcție de cât de gestionat este serviciul.

  • EC2 (IaaS): AWS se oprește la hypervisor. Tu ai sistemul de operare, patch-urile, firewall-ul din sistem, aplicația, security groups și criptarea datelor.
  • RDS (gestionat): AWS aplică patch-urile sistemului de operare și actualizările minore ale motorului, în fereastra de mentenanță pe care o configurezi. Tu răspunzi de utilizatorii bazei de date, de parametri, de accesul în rețea, de criptare și de backup-urile pe care le păstrezi.
  • Lambda (serverless): AWS gestionează serverele, sistemul și runtime-ul (de exemplu Python 3.12). Tu răspunzi de cod, de bibliotecile incluse în pachet, de permisiunile rolului de execuție și de migrarea la un runtime nou când cel vechi ajunge la sfârșitul suportului.

Ce rămâne mereu la tine, indiferent de serviciu: datele, IAM, configurarea accesului public și criptarea. Majoritatea incidentelor de securitate în cloud vin din această zonă, nu din infrastructura AWS.

Ce urmărește intervievatorul: Verifică dacă poți aplica modelul pe servicii concrete, nu doar recita definiția. Greșeala tipică: „pe RDS nu am nicio responsabilitate de securitate”.

6 Junior

Cum configurezi AWS CLI pe laptop și de unde își ia CLI-ul credențialele când rulezi o comandă?

Răspuns scurt: Rulezi aws configure (sau aws configure sso), care scrie în ~/.aws/credentials și ~/.aws/config. La rulare, CLI caută credențialele într-o ordine fixă: opțiunile din linia de comandă, variabilele de mediu, fișierele de profil, apoi credențialele din container sau din metadatele instanței EC2.

aws configure îți cere access key, secret key, regiunea implicită și formatul de ieșire și le salvează în profilul default. Cu aws configure --profile dev creezi profiluri separate, pe care le alegi cu --profile dev sau AWS_PROFILE=dev.

Ordinea simplificată în care CLI caută credențialele:

  • opțiunile din comandă (--profile, --region);
  • variabilele de mediu AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, AWS_SESSION_TOKEN;
  • profilul din ~/.aws/credentials și ~/.aws/config, inclusiv profiluri SSO sau cu role_arn pentru assume role;
  • credențialele furnizate containerului (ECS, EKS);
  • metadatele instanței EC2, adică rolul atașat instanței.
BASH
aws configure sso          # recomandat pentru oameni
aws sts get-caller-identity --profile dev

aws sts get-caller-identity e prima comandă de depanare: îți spune ce identitate folosești efectiv. Multe erori AccessDenied vin din faptul că o variabilă de mediu uitată are prioritate față de profilul la care te gândeai.

Pentru oameni se recomandă IAM Identity Center cu credențiale temporare, nu chei de acces permanente. Pentru servere și funcții, roluri, nu chei.

Ce urmărește intervievatorul: Verifică dacă ai lucrat efectiv cu CLI. Greșeala tipică: nu știi de ce o comandă rulează cu alt cont decât te așteptai.

Eroarea, în practică:Unable to locate credentialsYou must specify a region

7 Junior

Ce face comanda de mai jos și ce afișează?

BASH
aws ec2 describe-instances \
  --filters Name=instance-state-name,Values=running \
  --query 'Reservations[].Instances[].[InstanceId,InstanceType,Tags[?Key==`Name`].Value|[0]]' \
  --output table

Răspuns scurt: Listează instanțele EC2 pornite din regiunea curentă și afișează un tabel cu ID-ul, tipul și valoarea tag-ului Name pentru fiecare. --filters filtrează pe server, iar --query (JMESPath) selectează câmpurile pe client.

Răspunsul describe-instances are structura Reservations → Instances, pentru că instanțele pornite împreună sunt grupate într-o rezervare. De aceea expresia începe cu Reservations[].Instances[], care aplatizează toate instanțele într-o singură listă.

  • --filters Name=instance-state-name,Values=running este aplicat de API-ul AWS, deci primești doar instanțele pornite.
  • --query folosește JMESPath și rulează local, pe JSON-ul primit. [InstanceId,InstanceType,...] construiește pentru fiecare instanță o listă cu trei valori.
  • partea cu Tags[?Key=='Name'].Value | [0] (scrisă în comandă cu literal JMESPath între backticks, echivalent) filtrează lista de tag-uri după cheie și ia prima valoare. Dacă instanța nu are tag Name, apare None.
  • --output table formatează rezultatul ca tabel; alternativele sunt json, text (bun pentru scripturi bash) și yaml.

Diferența dintre filtru și query contează la volume mari: filtrul reduce ce trimite AWS, query-ul doar ce afișezi. Pentru scripturi, combinația --query ... --output text îți dă valori pe care le poți trece direct în xargs sau într-o buclă, fără jq.

Comanda lucrează doar în regiunea configurată; pentru alte regiuni adaugi --region.

Ce urmărește intervievatorul: Verifică familiaritatea cu CLI-ul și cu structura răspunsurilor AWS. Mulți uită nivelul Reservations și nu înțeleg de ce query-ul lor întoarce liste goale.

8 Mid

Ce sunt edge locations și Local Zones și prin ce diferă de zonele de disponibilitate?

Răspuns scurt: Edge locations sunt puncte de prezență pentru CloudFront, Route 53 și WAF, unde nu rulezi instanțe. Local Zones extind o regiune într-un oraș, cu servicii de calcul limitate. Zonele de disponibilitate sunt centrele de bază ale regiunii.

O zonă de disponibilitate (AZ) este unul sau mai multe centre de date cu alimentare, răcire și rețea independente, legate de celelalte zone ale regiunii prin rețea cu latență mică. Acolo rulezi infrastructura principală: EC2, RDS, subrețele.

Edge locations sunt mult mai numeroase și împrăștiate în multe orașe. Nu rulezi instanțe acolo. Le folosesc serviciile de margine:

  • CloudFront le folosește pentru cache-ul de conținut și pentru terminarea conexiunilor TLS aproape de utilizator;
  • Route 53 răspunde la interogări DNS din ele;
  • AWS WAF și Shield filtrează traficul la margine;
  • CloudFront Functions și Lambda@Edge rulează cod mic acolo.

Local Zones sunt extensii ale unei regiuni-părinte, plasate în orașe mari, unde poți rula EC2, EBS și câteva alte servicii cu latență foarte mică pentru utilizatorii locali. Le activezi explicit și le folosești pentru cazuri ca editare video, jocuri sau aplicații de timp real.

Mai există Wavelength (calcul în rețelele operatorilor 5G) și Outposts (hardware AWS în centrul tău de date), pentru cazuri speciale.

Răspunsul bun leagă fiecare de un caz de utilizare: CloudFront pentru un site cu public global, Local Zones când latența de câteva milisecunde contează.

Ce urmărește intervievatorul: Verifică dacă știi infrastructura globală dincolo de regiuni și AZ. Greșeala tipică: confuzia între edge location și AZ.

9 Mid

Un script care face multe apeluri la API-ul AWS primește intermitent erori ThrottlingException sau RequestLimitExceeded. De ce se întâmplă și cum le rezolvi?

Răspuns scurt: API-urile AWS au limite de rată pe cont și regiune. Rezolvi cu retry cu exponential backoff și jitter (SDK-urile îl au deja, îl configurezi), cu mai puține apeluri (paginare, operații batch, cache) și, dacă e nevoie reală, ceri o creștere de cotă din Service Quotas.

AWS protejează serviciile limitând câte cereri pe secundă accepți pe un API, per cont și regiune. Când depășești, primești erori de throttling (HTTP 400 sau 429 cu coduri ca Throttling, ThrottlingException, RequestLimitExceeded). Sunt erori tranzitorii: cererea poate reuși dacă o repeți puțin mai târziu.

Soluții, în ordinea în care le-aș aplica:

  • Retry cu exponential backoff și jitter: aștepți din ce în ce mai mult între încercări, cu o componentă aleatoare ca să nu reîncerce toți clienții în același moment. SDK-urile AWS fac asta automat; în boto3 alegi modul adaptive sau standard și numărul de încercări.
  • Mai puține apeluri: folosești filtre pe server, paginare corectă, operații batch (de exemplu describe-instances cu mai multe ID-uri), cache pentru date care se schimbă rar.
  • Paralelism controlat: limitezi numărul de fire care cheamă același API.
PYTHON
import boto3
from botocore.config import Config
ec2 = boto3.client("ec2", config=Config(retries={"mode": "adaptive", "max_attempts": 10}))

Separat de throttling există service quotas (de exemplu numărul de vCPU On-Demand sau de VPC-uri pe regiune). Le vezi și ceri creșteri în consola Service Quotas. Merită verificate înainte de o lansare sau de teste de încărcare, nu în timpul lor.

Ce urmărește intervievatorul: Verifică experiența cu automatizări reale. Candidații slabi propun doar „pun un sleep”, fără backoff sau reducerea apelurilor.

IAM și securitate

10 Junior

Descrie structura unei politici IAM. Ce înseamnă fiecare câmp dintr-un statement?

Răspuns scurt: O politică e un document JSON cu Version și o listă Statement. Fiecare statement are Effect (Allow sau Deny), Action (operațiile API), Resource (ARN-urile vizate) și, opțional, Condition; politicile atașate resurselor au în plus Principal.

Exemplu de politică bazată pe identitate:

JSON
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "CitireRapoarte",
      "Effect": "Allow",
      "Action": ["s3:GetObject"],
      "Resource": "arn:aws:s3:::firma-rapoarte/*",
      "Condition": {"Bool": {"aws:SecureTransport": "true"}}
    }
  ]
}
  • Version: versiunea limbajului de politici; folosești mereu 2012-10-17, altfel variabilele de politică nu funcționează.
  • Sid: un identificator opțional, util pentru citire.
  • Effect: Allow sau Deny.
  • Action: operații de forma serviciu:Operatie; acceptă wildcard, de exemplu s3:Get*. Există și NotAction.
  • Resource: ARN-urile pe care se aplică; unele acțiuni nu suportă resurse specifice și cer "*".
  • Condition: condiții suplimentare (IP sursă, tag-uri, MFA, regiune).
  • Principal: cine primește permisiunea; apare doar în politicile bazate pe resursă (bucket policy, trust policy a unui rol, politica unei cozi SQS), pentru că acolo trebuie spus cui i se dă accesul.

Politicile bazate pe identitate se atașează utilizatorilor, grupurilor sau rolurilor, iar principalul este implicit identitatea respectivă.

Ce urmărește intervievatorul: Verifică dacă poți citi și scrie o politică fără să copiezi din documentație. Greșeala tipică: pui Principal într-o politică de identitate.

Eroarea, în practică:AccessDenied: not authorized s3:ListBucketUnauthorizedOperation (EC2)

11 Junior

Politica de mai jos ar trebui să permită listarea și descărcarea fișierelor din bucketul firma-facturi, dar aws s3 ls s3://firma-facturi dă AccessDenied. Unde e bug-ul?

JSON
{
  "Version": "2012-10-17",
  "Statement": [{
    "Effect": "Allow",
    "Action": ["s3:ListBucket", "s3:GetObject"],
    "Resource": "arn:aws:s3:::firma-facturi/*"
  }]
}

Răspuns scurt: s3:ListBucket se aplică bucketului (arn:aws:s3:::firma-facturi), nu obiectelor, iar s3:GetObject se aplică obiectelor (arn:aws:s3:::firma-facturi/*). Politica dă ListBucket pe un ARN de obiect, deci nu se potrivește nimic și listarea e refuzată.

În S3 există două tipuri de resurse cu ARN-uri diferite: bucketul și obiectele din el. Fiecare acțiune S3 lucrează pe unul dintre ele, iar documentația „Actions, resources, and condition keys” spune exact pe care.

  • s3:ListBucket, s3:GetBucketLocation, s3:GetBucketPolicy lucrează pe bucket: arn:aws:s3:::firma-facturi.
  • s3:GetObject, s3:PutObject, s3:DeleteObject lucrează pe obiecte: arn:aws:s3:::firma-facturi/*.

Varianta corectă separă statement-urile:

JSON
{
  "Version": "2012-10-17",
  "Statement": [
    {"Effect": "Allow", "Action": "s3:ListBucket",
     "Resource": "arn:aws:s3:::firma-facturi"},
    {"Effect": "Allow", "Action": "s3:GetObject",
     "Resource": "arn:aws:s3:::firma-facturi/*"}
  ]
}

Cu politica greșită, descărcarea unui fișier cu cheia cunoscută ar funcționa, doar listarea ar eșua, ceea ce face bug-ul derutant.

Dacă vrei să limitezi listarea la un „folder”, adaugi o condiție pe prefix: "Condition": {"StringLike": {"s3:prefix": ["2026/*"]}}. Condiția s3:prefix are sens doar pe ListBucket, deci încă un motiv să ții statement-urile separate.

Ce urmărește intervievatorul: E un bug clasic din viața reală. Verifică dacă știi că acțiunile au tipuri de resurse diferite și dacă poți depana o politică pas cu pas.

Eroarea, în practică:AccessDenied: not authorized s3:ListBucket

12 Junior

La ce folosesc grupurile IAM și ce limitări au?

Răspuns scurt: Grupurile îți permit să atașezi politici o singură dată pentru mai mulți utilizatori, de exemplu „Dezvoltatori” sau „Contabilitate”. Un grup conține doar utilizatori IAM, nu poate conține alte grupuri și nu poate fi folosit ca Principal într-o politică.

Fără grupuri, ai atașa aceleași politici la fiecare utilizator, iar când se schimbă rolul cuiva ar trebui să cauți și să modifici politicile una câte una. Cu grupuri, permisiunile țin de funcție: muți un om din grupul „Stagiari” în „Dezvoltatori” și permisiunile se schimbă automat.

Bune practici:

  • atașezi politicile la grupuri, nu direct la utilizatori;
  • un utilizator poate fi în mai multe grupuri, iar permisiunile se adună (cu excepția deny-urilor explicite, care câștigă oricum);
  • numești grupurile după funcție, nu după persoane.

Limitări de știut:

  • grupurile nu se pot imbrica: nu poți pune „Backend” în „Dezvoltatori”;
  • un grup nu este o identitate: nu se poate autentifica și nu poate apărea ca Principal într-o bucket policy sau trust policy; acolo pui ARN-ul unui utilizator, al unui rol sau al unui cont;
  • grupurile conțin doar utilizatori IAM, nu roluri.

În organizațiile mai mari, utilizatorii IAM și grupurile lor sunt adesea înlocuiți de IAM Identity Center, unde grupurile vin din directorul firmei (de exemplu Microsoft Entra ID sau Google Workspace) și primesc acces prin permission sets.

Ce urmărește intervievatorul: Verifică dacă știi organizarea permisiunilor la nivel de echipă. Greșeala tipică: crezi că poți da acces unui grup într-o bucket policy.

13 Junior

Ce diferență este între politicile gestionate de AWS, politicile gestionate de client și politicile inline? Când o alegi pe fiecare?

Răspuns scurt: AWS managed sunt scrise și actualizate de AWS, customer managed sunt create de tine și reutilizabile, inline sunt lipite de o singură identitate. Pentru least privilege folosești customer managed; inline doar pentru excepții legate strict de o identitate.

  • AWS managed policies: le scrie și le întreține AWS, de exemplu AmazonS3ReadOnlyAccess, PowerUserAccess, AWSLambdaBasicExecutionRole. Avantaj: sunt rapide și se actualizează când apar acțiuni noi. Dezavantaj: sunt generale, adesea mai largi decât îți trebuie, iar o actualizare a lor îți poate extinde permisiunile fără să schimbi nimic.
  • Customer managed policies: le creezi tu în cont, le atașezi la oricâte identități, au versiuni (poți reveni la una anterioară). Sunt potrivite pentru permisiuni pe măsură: „citire din bucketul X, scriere în coada Y”.
  • Inline policies: sunt încorporate direct într-un singur utilizator, grup sau rol. Nu le poți reutiliza și nu apar ca obiect separat. Se folosesc când vrei ca politica să nu poată fi atașată din greșeală altcuiva și să fie ștearsă împreună cu identitatea.

O abordare tipică: pornești cu o politică AWS managed ca să faci ceva să funcționeze, apoi, cu ajutorul IAM Access Analyzer sau al informațiilor „last accessed”, o înlocuiești cu o politică customer managed care conține doar ce se folosește efectiv.

În IaC (CloudFormation, Terraform), politicile customer managed se versionează în Git împreună cu restul infrastructurii, ceea ce face review-ul permisiunilor mult mai simplu.

Ce urmărește intervievatorul: Verifică dacă știi compromisurile, nu doar tipurile. Mulți candidați atașează AdministratorAccess sau politici largi „ca să meargă”.

Eroarea, în practică:AccessDenied: not authorized s3:ListBucketPolicy does not exist or is not attachable

14 Junior

Ce sunt cheile de acces IAM și cum ar trebui gestionate?

Răspuns scurt: O pereche access key ID și secret key pentru apeluri programatice ale unui utilizator IAM. Nu le pui în cod sau Git, le rotești, le ștergi pe cele nefolosite și, unde se poate, le înlocuiești cu roluri și credențiale temporare.

Cheile de acces sunt credențiale pe termen lung: rămân valabile până le dezactivezi. Asta le face periculoase: o cheie publicată din greșeală într-un depozit Git public poate fi găsită repede de scanere automate și folosită, de exemplu, pentru a porni instanțe de minare.

Reguli de lucru:

  • nu le scrii în cod, în fișiere de configurație din Git, în imagini Docker sau în user data;
  • un utilizator poate avea maximum două chei active, ca să poți face rotația fără întrerupere: creezi cheia nouă, schimbi aplicația, verifici, dezactivezi și apoi ștergi cheia veche;
  • verifici în credential report sau în consola IAM când a fost folosită ultima dată fiecare cheie și le ștergi pe cele nefolosite;
  • adaugi un scanner de secrete în pipeline sau în hook-urile Git.

Cel mai bine e să nu ai chei deloc:

  • pe EC2, ECS, Lambda folosești roluri IAM, iar SDK-ul ia singur credențiale temporare;
  • pentru oameni folosești IAM Identity Center (aws configure sso);
  • pentru CI/CD (de exemplu GitHub Actions) folosești federație OIDC cu un rol, nu chei salvate ca secrete.

Credențialele temporare expiră singure, deci o scurgere are un impact limitat în timp.

Ce urmărește intervievatorul: Verifică maturitatea în securitate. Răspunsul slab se oprește la „le țin secrete”, fără roluri, rotație sau credențiale temporare.

Eroarea, în practică:InvalidClientTokenId: security token is invalidInvalidAccessKeyId: Access Key Id does not exist

15 Junior

Cum funcționează MFA în AWS și cum obligi un utilizator IAM să folosească MFA înainte să poată face orice altceva decât să-și configureze dispozitivul?

Răspuns scurt: MFA adaugă un al doilea factor (cod TOTP, cheie FIDO) la autentificare. Ca să-l impui, atașezi o politică cu Deny pe toate acțiunile, cu excepția celor de configurare MFA, atunci când aws:MultiFactorAuthPresent nu este true.

La autentificarea în consolă, MFA cere pe lângă parolă un cod generat de o aplicație sau o cheie de securitate. Pentru apelurile programatice, cheile de acces nu au MFA în ele, așa că obții credențiale temporare cu aws sts get-session-token --serial-number ... --token-code ..., iar sesiunea rezultată are contextul MFA.

Politica tipică de impunere:

JSON
{
  "Version": "2012-10-17",
  "Statement": [{
    "Sid": "BlocheazaFaraMFA",
    "Effect": "Deny",
    "NotAction": [
      "iam:CreateVirtualMFADevice",
      "iam:EnableMFADevice",
      "iam:ListMFADevices",
      "iam:GetUser",
      "iam:ChangePassword",
      "sts:GetSessionToken"
    ],
    "Resource": "*",
    "Condition": {"BoolIfExists": {"aws:MultiFactorAuthPresent": "false"}}
  }]
}

De ce BoolIfExists și nu Bool: când cererea vine cu chei de acces pe termen lung, cheia aws:MultiFactorAuthPresent lipsește din context. Cu Bool, condiția n-ar fi evaluată ca adevărată și deny-ul nu s-ar aplica. BoolIfExists tratează lipsa cheii ca „fără MFA”.

NotAction lasă utilizatorului exact acțiunile de care are nevoie ca să-și activeze MFA. Versiunea completă din documentația AWS limitează și resursele la propriul utilizator (${aws:username}).

Ce urmărește intervievatorul: Verifică dacă știi să combini Deny cu condiții. Capcana pe care o caută intervievatorul este diferența dintre Bool și BoolIfExists.

16 Mid

Un utilizator are în grupul lui o politică ce permite s3:* pe toate resursele, iar pe bucketul arhiva există o bucket policy cu Deny pentru s3:DeleteObject. Poate șterge un obiect din arhiva? Explică logica de evaluare IAM.

Răspuns scurt: Nu. Un Deny explicit oriunde în politicile relevante câștigă mereu, indiferent câte Allow există. Logica e: implicit totul e refuzat, un Allow deschide accesul, iar un Deny explicit îl închide definitiv.

Pentru o cerere în același cont, AWS adună toate politicile relevante: cele ale identității, politica resursei, permission boundary, politica de sesiune și SCP-urile din AWS Organizations. Apoi aplică regulile:

  • Implicit deny: dacă nimic nu permite acțiunea, ea e refuzată.
  • Explicit deny: dacă oricare politică are un Deny care se potrivește, cererea e refuzată. Nu se mai uită la Allow-uri.
  • Allow: dacă nu există deny și cel puțin o politică permite, cererea trece, cu condiția ca limitele (SCP, permission boundary, politica de sesiune) să permită și ele acțiunea.

Deci în exemplu, s3:* din politica grupului e anulat de deny-ul din bucket policy pentru DeleteObject. Utilizatorul poate citi și scrie, dar nu poate șterge.

Nuanțe utile:

  • SCP-urile și permission boundaries nu dau permisiuni, doar le plafonează. O acțiune trebuie permisă și de politica identității, și de plafon.
  • Pentru acces cross-account, e nevoie de Allow de ambele părți: în politica identității din contul sursă și în politica resursei din contul țintă.
  • În același cont, pentru majoritatea serviciilor, un Allow fie în politica identității, fie în politica resursei e suficient.

La depanare folosești IAM Policy Simulator sau mesajele de eroare, care la multe servicii spun acum ce tip de politică a refuzat cererea.

Ce urmărește intervievatorul: Verifică dacă înțelegi ordinea de evaluare, nu doar „deny câștigă”. Candidații uită de SCP și permission boundaries, care nu acordă permisiuni.

Eroarea, în practică:AccessDenied: with an explicit deny

17 Mid

Prin ce diferă politica de încredere (trust policy) a unui rol de politica lui de permisiuni? Scrie o trust policy care lasă instanțele EC2 să preia rolul.

Răspuns scurt: Trust policy spune cine poate prelua rolul (cine poate apela sts:AssumeRole), iar politica de permisiuni spune ce poate face cel care l-a preluat. Pentru EC2, principalul de încredere este serviciul ec2.amazonaws.com.

Un rol IAM nu are parolă sau chei permanente. Cine îl preia primește de la STS credențiale temporare (access key, secret key, session token) cu o durată limitată. Rolul are două politici cu funcții diferite:

  • Trust policy (politică bazată pe resursă, atașată rolului): definește principalii care pot face sts:AssumeRole. Poate fi un serviciu AWS, un alt cont, un utilizator anume sau un furnizor de identitate federat.
  • Politica de permisiuni: definește acțiunile permise cu credențialele rolului.

Trust policy pentru EC2:

JSON
{
  "Version": "2012-10-17",
  "Statement": [{
    "Effect": "Allow",
    "Principal": {"Service": "ec2.amazonaws.com"},
    "Action": "sts:AssumeRole"
  }]
}

Pe EC2 rolul nu se atașează direct, ci printr-un instance profile; consola îl creează automat, iar în CLI sau IaC îl creezi explicit.

Pentru acces între conturi, trust policy are "Principal": {"AWS": "arn:aws:iam::111122223333:root"}, care deleagă decizia contului respectiv: acolo, o identitate are nevoie și de permisiunea sts:AssumeRole pe ARN-ul rolului. Pentru furnizori terți se adaugă o condiție pe sts:ExternalId, ca protecție împotriva problemei „confused deputy”.

O eroare frecventă: rolul are permisiunile corecte, dar trust policy nu include principalul care încearcă să-l preia, iar eroarea apare la AssumeRole, nu la apelul S3.

Ce urmărește intervievatorul: Verifică dacă înțelegi rolurile ca mecanism, nu doar „le atașezi la EC2”. Mulți nu știu că există două politici distincte.

Eroarea, în practică:AccessDenied: not authorized sts:AssumeRoleThe role defined for the function cannot be assumed

18 Mid

Scrie o politică prin care dezvoltatorii pot porni și opri doar instanțele EC2 care au tag-ul Echipa egal cu tag-ul Echipa al propriului utilizator.

Răspuns scurt: Folosești ABAC (attribute-based access control): un Allow pe ec2:StartInstances și ec2:StopInstances cu condiția ca aws:ResourceTag/Echipa să fie egal cu ${aws:PrincipalTag/Echipa}.

JSON
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": ["ec2:StartInstances", "ec2:StopInstances"],
      "Resource": "arn:aws:ec2:*:*:instance/*",
      "Condition": {
        "StringEquals": {"aws:ResourceTag/Echipa": "${aws:PrincipalTag/Echipa}"}
      }
    },
    {
      "Effect": "Allow",
      "Action": "ec2:DescribeInstances",
      "Resource": "*"
    }
  ]
}

Cum funcționează: ${aws:PrincipalTag/Echipa} e o variabilă de politică, înlocuită la evaluare cu tag-ul utilizatorului sau al sesiunii de rol. Un utilizator cu Echipa=plati poate opri doar instanțele cu Echipa=plati. Când apare o echipă nouă, nu modifici politica, doar etichetezi oamenii și resursele.

DescribeInstances e separat pentru că operațiile de tip Describe nu suportă restricții la nivel de resursă și cer "Resource": "*".

Ca ABAC să fie sigur, trebuie să împiedici oamenii să-și mute singuri resursele în altă echipă: adaugi un Deny pe ec2:CreateTags și ec2:DeleteTags pentru cheia Echipa (condiția aws:TagKeys) și nu le dai drept să-și modifice propriile tag-uri IAM.

Comparat cu RBAC (o politică per echipă), ABAC scalează mai bine când ai multe echipe și resurse create dinamic.

Ce urmărește intervievatorul: Verifică dacă știi condiții și variabile de politică. Greșeala tipică: uiți că oamenii își pot modifica tag-urile și ocolesc restricția.

19 Mid

Moștenești un cont în care aplicațiile folosesc politici cu "Action": "*". Cum ajungi la privilegiul minim fără să strici producția?

Răspuns scurt: Afli ce folosesc efectiv aplicațiile (IAM Access Analyzer, „last accessed”, CloudTrail), generezi politici restrânse pe baza activității reale, le testezi în staging sau cu Policy Simulator, le aplici treptat și monitorizezi erorile AccessDenied după fiecare schimbare.

Privilegiul minim înseamnă că fiecare identitate are doar permisiunile de care are nevoie, nimic în plus. În practică, la un cont existent nu poți ghici ce folosesc aplicațiile, așa că pornești de la date.

Pașii:

  • Inventar: listezi rolurile și utilizatorii, cu politicile lor; credential report îți arată și cheile vechi sau nefolosite.
  • Ce se folosește: tab-ul „Last accessed” din IAM arată serviciile (și pentru unele servicii acțiunile) folosite recent. IAM Access Analyzer poate genera o politică pe baza activității din CloudTrail pentru un rol, pe o perioadă aleasă.
  • Politica nouă: pornești de la cea generată, restrângi resursele la ARN-uri concrete și adaugi condiții unde are sens.
  • Testare: verifici în IAM Policy Simulator acțiunile critice și rulezi aplicația în staging cu noua politică.
  • Lansare treptată: aplici rol cu rol, nu pe toate odată, și urmărești în CloudTrail sau în logurile aplicației erorile AccessDenied. Păstrezi versiunea anterioară a politicii ca să poți reveni rapid.
  • Prevenție: permission boundaries pentru rolurile create de echipe, SCP-uri care interzic acțiuni periculoase, review de politici în pipeline-ul de IaC.

Atenție la acțiunile folosite rar, de exemplu un job lunar: perioada de observare trebuie să le prindă.

Ce urmărește intervievatorul: Verifică dacă abordezi securitatea pragmatic, fără să rupi producția. Candidații slabi propun să ștergi * direct și „vedem ce crapă”.

Eroarea, în practică:UnauthorizedOperation (EC2)

20 Senior

O aplicație din contul A trebuie să citească fișiere dintr-un bucket S3 din contul B. Ce variante ai și pe care o recomanzi?

Răspuns scurt: Fie o bucket policy în contul B care permite rolul aplicației din A, fie un rol în B preluat cu sts:AssumeRole. Pentru simplă citire ajunge bucket policy; rolul e mai bun pentru acces larg sau control centralizat în B.

Pentru accesul între conturi, cererea trebuie permisă de ambele părți: identitatea din A trebuie să aibă permisiunea în politica ei, iar resursa din B trebuie să accepte principalul din A.

Varianta 1: bucket policy. În contul B:

JSON
{
  "Effect": "Allow",
  "Principal": {"AWS": "arn:aws:iam::AAAAAAAAAAAA:role/app-rapoarte"},
  "Action": ["s3:GetObject"],
  "Resource": "arn:aws:s3:::b-rapoarte/*"
}

Plus s3:ListBucket pe ARN-ul bucketului, dacă aplicația listează. Rolul din A are la rândul lui o politică ce permite aceleași acțiuni pe acest bucket. Avantaj: aplicația folosește direct credențialele ei.

Varianta 2: rol în contul B. Creezi în B un rol cu permisiuni pe bucket și trust policy care acceptă rolul din A. Aplicația face AssumeRole, primește credențiale din B și lucrează ca identitate a contului B. Avantaje: contul B controlează complet permisiunile, obiectele scrise aparțin contului B, iar rolul poate acoperi mai multe servicii.

Detalii care contează:

  • dacă obiectele sunt criptate cu o cheie KMS gestionată de client, politica cheii din B trebuie să permită kms:Decrypt principalului din A;
  • cu Object Ownership pe „Bucket owner enforced”, ACL-urile nu mai contează, totul trece prin politici;
  • pentru multe conturi, condiția aws:PrincipalOrgID în bucket policy permite accesul întregii organizații fără să listezi fiecare cont.

Ce urmărește intervievatorul: Verifică dacă înțelegi că accesul cross-account cere permisiuni pe ambele părți. Candidații uită adesea de politica cheii KMS.

Eroarea, în practică:AccessDenied: not authorized sts:AssumeRole

21 Senior

De ce ar împărți o firmă infrastructura în mai multe conturi AWS și ce rol au SCP-urile din AWS Organizations?

Răspuns scurt: Contul e cea mai puternică graniță de izolare din AWS: separă securitatea, cotele și facturarea între medii și echipe. SCP-urile (service control policies) pun un plafon de permisiuni pe conturile din organizație, pe care nici administratorii acelor conturi nu îl pot depăși.

Motive pentru mai multe conturi:

  • Izolarea impactului: o greșeală sau un incident de securitate în contul de dezvoltare nu atinge producția.
  • Permisiuni mai simple: în loc de politici complicate care separă resursele prin tag-uri, dai unei echipe acces de administrator în contul ei de sandbox.
  • Cote separate: limitele de serviciu sunt pe cont și regiune, deci un test de încărcare nu consumă cotele producției.
  • Facturare clară: costurile pe cont se văd direct, fără să depinzi de tag-uri perfecte.
  • Conformitate: datele sensibile stau în conturi cu reguli mai stricte și audit separat.

Structura tipică: un cont de management (doar pentru organizație și facturare), conturi pentru loguri și audit, conturi de securitate, apoi conturi pe medii și pe aplicații, grupate în unități organizaționale (OU). AWS Control Tower automatizează această structură.

SCP-urile se atașează la organizație, la OU sau la cont. Ele nu dau permisiuni, ci definesc maximul posibil. Exemple uzuale:

  • interzic folosirea regiunilor în afara celor aprobate (condiție pe aws:RequestedRegion, cu excepții pentru serviciile globale);
  • interzic oprirea CloudTrail sau ștergerea logurilor de audit;
  • interzic părăsirea organizației.

SCP-urile nu se aplică contului de management, motiv pentru care acolo nu rulezi aplicații.

Ce urmărește intervievatorul: Verifică gândirea de arhitectură la scară de organizație. Greșeala tipică: crezi că un SCP poate acorda permisiuni.

22 Senior

Cum ar trebui să se autentifice oamenii și pipeline-urile CI/CD în AWS, fără utilizatori IAM cu chei permanente?

Răspuns scurt: Oamenii se autentifică prin IAM Identity Center, legat de directorul firmei, și primesc credențiale temporare prin permission sets. Pipeline-urile folosesc federație OIDC (de exemplu GitHub Actions) ca să preia un rol IAM cu credențiale de scurtă durată.

Utilizatorii IAM cu parole și chei permanente sunt greu de administrat la scară: plecarea unui angajat înseamnă curățenie în fiecare cont, iar cheile scapă în fișiere și scripturi.

Pentru oameni: IAM Identity Center. Conectezi furnizorul de identitate al firmei (Microsoft Entra ID, Okta, Google Workspace) sau folosești directorul intern al serviciului. Definești permission sets (de exemplu „Developer” sau „ReadOnly”) și le atribui grupurilor pe conturi. Utilizatorul intră printr-un portal sau cu aws configure sso și primește credențiale temporare. Dezactivarea contului în directorul firmei taie accesul peste tot.

Pentru CI/CD: OIDC. Creezi în IAM un furnizor de identitate OIDC pentru token.actions.githubusercontent.com și un rol cu trust policy care acceptă tokenul doar de la depozitul și branch-ul potrivit:

JSON
"Condition": {
  "StringEquals": {
    "token.actions.githubusercontent.com:aud": "sts.amazonaws.com",
    "token.actions.githubusercontent.com:sub": "repo:firma/api:ref:refs/heads/main"
  }
}

În workflow, acțiunea aws-actions/configure-aws-credentials schimbă tokenul OIDC pe credențiale temporare prin AssumeRoleWithWebIdentity. Nu există niciun secret de rotit.

Greșeala periculoasă este o condiție sub prea largă, de exemplu repo:firma/*, care lasă orice depozit sau branch să preia rolul de deploy în producție.

Ce urmărește intervievatorul: Verifică dacă știi practicile moderne de identitate. Un senior ar trebui să menționeze riscul unei condiții sub prea permisive.

Eroarea, în practică:ExpiredToken: security token is expired

EC2: instanțe, AMI, stocare, costuri

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

Ce este o AMI și ce conține? Poți porni o instanță în eu-west-1 dintr-o AMI creată în eu-central-1?

Răspuns scurt: O AMI (Amazon Machine Image) e șablonul din care pornește o instanță: snapshot-urile volumelor (inclusiv sistemul de operare), maparea dispozitivelor de bloc și permisiunile de lansare. AMI-urile sunt regionale, deci în altă regiune trebuie întâi să o copiezi cu copy-image.

O AMI conține:

  • unul sau mai multe snapshot-uri EBS (volumul rădăcină cu sistemul de operare și, opțional, volume de date);
  • block device mapping: ce volume se atașează la pornire, cu ce dimensiune și tip;
  • permisiunile de lansare: privată, partajată cu anumite conturi sau publică;
  • metadate: arhitectura (x86_64 sau arm64), tipul de virtualizare, ID-ul.

Surse de AMI-uri: cele oficiale AWS (Amazon Linux 2023, Ubuntu, Windows Server), AWS Marketplace (imagini cu software preinstalat, uneori cu licență plătită) și AMI-uri proprii, create dintr-o instanță configurată.

AMI-ul are un ID diferit în fiecare regiune, chiar și pentru aceeași imagine oficială. De aceea în scripturi nu scrii un ID fix, ci îl iei din parametrii publici SSM, de exemplu /aws/service/ami-amazon-linux-latest/al2023-ami-kernel-default-x86_64.

Pentru a folosi propria AMI în altă regiune: aws ec2 copy-image --source-region eu-central-1 --source-image-id ami-... --region eu-west-1 --name app-v12. Copia primește un ID nou.

Un mod de lucru matur este imaginea „coaptă” (golden AMI): construiești imaginea cu aplicația și dependențele (de exemplu cu EC2 Image Builder sau Packer), astfel încât instanțele noi pornesc repede și identic, în loc să instaleze totul la pornire.

Ce urmărește intervievatorul: Verifică dacă înțelegi ce pornește de fapt o instanță. Greșeala tipică: ID-uri de AMI scrise fix în cod, care nu funcționează în altă regiune.

Eroarea, în practică:InvalidAMIID.NotFound: image id does not existParameterNotFound (ssm get-parameter)

24 Junior

Ce înseamnă numele t3.micro, m7g.large sau c6i.xlarge? Cum alegi familia de instanțe?

Răspuns scurt: Litera e familia (t burstable, m general, c calcul, r memorie), cifra e generația, literele următoare sunt atribute (g = Graviton ARM, i = Intel, a = AMD), iar după punct vine mărimea. Alegi după raportul CPU/memorie necesar.

Exemple de familii:

  • t (t3, t4g): instanțe burstable, cu CPU de bază mic și credite de CPU pentru vârfuri; bune pentru aplicații cu trafic mic sau variabil, servere de dezvoltare.
  • m (m7i, m7g): echilibrate între CPU și memorie, alegerea implicită pentru aplicații web.
  • c (c7g, c6i): mai mult CPU raportat la memorie, pentru procesare intensivă, servere de build, encoding.
  • r și x: multă memorie, pentru baze de date în memorie, cache-uri mari, analiză.
  • i și d: stocare locală NVMe rapidă.
  • g, p, inf, trn: acceleratoare pentru grafică și machine learning.

Sufixele: g înseamnă procesor AWS Graviton (ARM), care are de obicei un raport preț-performanță mai bun, dar cere ca aplicația și imaginile să fie compilate pentru arm64. n înseamnă rețea îmbunătățită, d disc local.

La instanțele t e o capcană: dacă rulezi constant peste nivelul de bază, epuizezi creditele și CPU-ul e limitat (în modul standard) sau plătești suplimentar (în modul unlimited, implicit la t3). Metrica CPUCreditBalance din CloudWatch arată asta.

Cum alegi: pornești de la profilul real (CloudWatch, teste de încărcare), alegi o generație recentă și ajustezi mărimea după măsurători. AWS Compute Optimizer oferă recomandări pe baza utilizării.

Ce urmărește intervievatorul: Verifică dacă alegi instanța pe baza datelor, nu la întâmplare. Capcana clasică e comportamentul creditelor de CPU la familia t.

Eroarea, în practică:IncorrectInstanceState: not in the 'stopped' stateInvalid value for InstanceType

25 Junior

Cum funcționează o pereche de chei SSH pentru EC2 și ce faci dacă ai pierdut cheia privată a unei instanțe care rulează?

Răspuns scurt: AWS scrie cheia publică în authorized_keys la prima pornire, iar tu te autentifici cu cheia privată. Pierdută, nu se poate recupera: intri cu Session Manager sau EC2 Instance Connect și adaugi o cheie nouă, ori editezi volumul rădăcină de pe altă instanță.

La crearea unei perechi, AWS păstrează cheia publică și îți dă cheia privată o singură dată, ca fișier .pem. La lansare, agentul de inițializare (cloud-init pe Linux) scrie cheia publică pentru utilizatorul implicit al imaginii: ec2-user pe Amazon Linux, ubuntu pe Ubuntu.

BASH
chmod 400 cheie-app.pem
ssh -i cheie-app.pem ec2-user@<ip-public>

chmod 400 e necesar: clientul SSH refuză o cheie privată pe care o pot citi și alți utilizatori.

Dacă ai pierdut cheia privată:

  • dacă instanța are agentul SSM și un rol cu AmazonSSMManagedInstanceCore, intri cu Session Manager și adaugi o cheie publică nouă în authorized_keys;
  • cu EC2 Instance Connect (pe imaginile care îl suportă), consola trimite o cheie temporară pentru câteva zeci de secunde;
  • altfel: oprești instanța, detașezi volumul rădăcină, îl atașezi la o altă instanță, editezi fișierul, apoi îl muți înapoi.

În practică, multe echipe nu mai deschid portul 22 deloc: folosesc Session Manager, care nu cere chei SSH, nici port deschis, și înregistrează sesiunile în loguri. Schimbarea perechii de chei din consolă după lansare nu actualizează instanța: cheia se scrie doar la prima pornire.

Ce urmărește intervievatorul: Verifică experiența practică cu instanțe. Mulți cred că pot „descărca din nou” cheia privată din consolă.

Eroarea, în practică:InvalidKeyPair.NotFound: key pair does not existWARNING: UNPROTECTED PRIVATE KEY FILE!

26 Junior

Scrie regulile de security group pentru un server web public pe EC2 și explică de ce nu deschizi portul 22 pentru 0.0.0.0/0.

Răspuns scurt: Inbound: 80 și 443 de la 0.0.0.0/0 (și ::/0 pentru IPv6); SSH pe 22 doar de la IP-ul tău sau deloc, dacă folosești Session Manager. Outbound: implicit totul permis. Portul 22 deschis spre internet atrage scanări și încercări de autentificare automate continue.

Un security group e un firewall virtual atașat interfeței de rețea a instanței. Are doar reguli de tip allow și este stateful: dacă o cerere a intrat, răspunsul ei iese automat, fără regulă outbound separată.

Configurația pentru un server web public:

Inbound
  HTTP   TCP 80   0.0.0.0/0, ::/0
  HTTPS  TCP 443  0.0.0.0/0, ::/0
  SSH    TCP 22   203.0.113.25/32   (IP-ul biroului) sau deloc
Outbound
  Toate  0.0.0.0/0  (implicit)

De ce nu 22 pentru toată lumea: serverele cu SSH expus primesc încercări automate de autentificare la scurt timp după pornire. Chiar dacă folosești doar chei, orice vulnerabilitate a daemonului SSH sau o cheie scăpată devine exploatabilă de oriunde. Reduci suprafața de atac lăsând accesul doar de la o sursă cunoscută, prin VPN, sau eliminând complet SSH în favoarea Session Manager.

Pentru o arhitectură mai bună, instanța nici nu e publică: stă într-o subrețea privată, în spatele unui Application Load Balancer, iar SG-ul ei acceptă portul aplicației doar din SG-ul load balancerului.

Detalii: poți atașa mai multe SG-uri unei instanțe (regulile se adună), iar modificările se aplică imediat, fără repornire.

Ce urmărește intervievatorul: Verifică reflexele de securitate de bază. Greșeala tipică e un SG cu All traffic de la 0.0.0.0/0 „temporar”, care rămâne așa.

Eroarea, în practică:ssh: port 22: Connection timed outInvalidPermission.Duplicate: rule already exists

27 Junior

Scrie un script de user data care instalează și pornește nginx pe Amazon Linux 2023. Când rulează și cum depanezi dacă n-a mers?

Răspuns scurt: Un script bash care începe cu #!/bin/bash, instalează nginx cu dnf, îl activează cu systemctl enable --now nginx. Implicit rulează o singură dată, ca root, la prima pornire a instanței, iar ieșirea lui o găsești în /var/log/cloud-init-output.log.

BASH
#!/bin/bash
set -euxo pipefail
dnf update -y
dnf install -y nginx
echo "<h1>Server $(hostname -f)</h1>" > /usr/share/nginx/html/index.html
systemctl enable --now nginx

Cum funcționează: user data e trimis la lansare (din consolă, CLI, launch template), iar cloud-init îl execută ca root la prima pornire. La opriri și reporniri ulterioare nu mai rulează, decât dacă configurezi explicit cloud-init pentru asta. Modificarea user data cere oprirea instanței și nu are efect asupra unui script deja rulat.

set -euxo pipefail face scriptul să se oprească la prima eroare și să afișeze fiecare comandă, ceea ce ajută enorm la depanare.

Depanare:

  • /var/log/cloud-init-output.log conține ieșirea scriptului;
  • /var/log/cloud-init.log arată pașii cloud-init;
  • din instanță, curl cu token IMDSv2 la http://169.254.169.254/latest/user-data îți arată scriptul primit;
  • cauze frecvente: lipsa accesului la internet (subrețea privată fără NAT, deci dnf nu descarcă nimic), lipsa #!/bin/bash pe primul rând, terminații de linie Windows.

Nu pune parole sau chei în user data: oricine are ec2:DescribeInstanceAttribute sau acces la instanță le poate citi. Secretele le iei la rulare din Secrets Manager sau Parameter Store, folosind rolul instanței.

Ce urmărește intervievatorul: Verifică dacă ai automatizat configurarea unor instanțe. Candidații nu știu adesea că scriptul rulează doar la prima pornire.

Eroarea, în practică:Invalid BASE64 encoding of user data

28 Junior

Care e diferența dintre a opri (stop), a hiberna și a termina (terminate) o instanță EC2? Ce se pierde în fiecare caz?

Răspuns scurt: Stop oprește instanța, păstrează volumele EBS, pierde memoria, datele din instance store și IP-ul public dinamic. Hibernate salvează memoria pe volumul rădăcină EBS și o restaurează la pornire. Terminate șterge definitiv instanța și, implicit, volumul rădăcină.

  • Reboot: repornire a sistemului de operare pe aceeași gazdă fizică. Totul se păstrează, inclusiv IP-ul public și instance store.
  • Stop: instanța se oprește, nu mai plătești ore de calcul, dar plătești în continuare volumele EBS. La pornire, instanța poate ajunge pe altă gazdă fizică, de aceea datele din instance store se pierd. IP-ul public automat se schimbă; IP-ul privat și un Elastic IP asociat rămân.
  • Hibernate: ca stop, dar conținutul RAM este scris pe volumul rădăcină EBS, care trebuie să fie criptat și suficient de mare. La pornire, procesele își continuă execuția de unde au rămas. Trebuie activată la lansare și e suportată doar pe anumite tipuri de instanțe și sisteme.
  • Terminate: instanța e ștearsă definitiv. Volumele cu DeleteOnTermination=true (implicit volumul rădăcină) se șterg; volumele de date atașate ulterior rămân, implicit. Nu se poate anula.

Protecții utile: termination protection (DisableApiTermination) împiedică terminarea accidentală din consolă sau API, iar InstanceInitiatedShutdownBehavior decide dacă un shutdown din sistem oprește sau termină instanța.

Într-un Auto Scaling group, instanțele sunt considerate de unică folosință: ASG-ul le termină și le înlocuiește, deci datele importante nu trebuie ținute local.

Ce urmărește intervievatorul: Verifică dacă înțelegi ce date supraviețuiesc. Greșeala periculoasă e să ții date importante pe instance store.

Eroarea, în practică:IncorrectInstanceState: cannot be startedIncorrectInstanceState: not in the 'stopped' state

29 Junior

Prin ce diferă EBS, instance store și EFS? Dă un caz de utilizare pentru fiecare.

Răspuns scurt: EBS e un disc de rețea persistent, atașat unei instanțe dintr-o singură zonă; instance store e un disc local, foarte rapid, dar temporar; EFS e un sistem de fișiere NFS gestionat, folosit simultan de mai multe instanțe din mai multe zone.

  • EBS (Elastic Block Store): volum de bloc persistent, independent de ciclul de viață al instanței. Trăiește într-o zonă de disponibilitate și se atașează unei instanțe din aceeași zonă (cu excepția Multi-Attach pe io1/io2, pentru cazuri speciale). Tipuri: gp3 (SSD de uz general, la care IOPS și throughput se configurează separat de mărime), io2 (IOPS mari, garantate), st1 și sc1 (HDD pentru acces secvențial). Folosești EBS pentru volumul rădăcină, baze de date instalate pe EC2, orice date care trebuie să supraviețuiască unei opriri. Se salvează prin snapshot-uri.
  • Instance store: discuri fizice ale gazdei. Latență foarte mică și throughput mare, fără cost suplimentar, dar datele dispar la stop, hibernate, terminate sau la defectarea gazdei. Bun pentru cache, fișiere temporare, buffer-e, sau pentru sisteme care replică datele între noduri.
  • EFS (Elastic File System): sistem de fișiere de rețea (NFS), cu capacitate elastică, montat simultan de multe instanțe EC2, containere și funcții Lambda, din mai multe zone. Bun pentru fișiere partajate: conținut încărcat de utilizatori pe o aplicație cu mai multe servere, directoare home comune.

Pentru Windows sau sisteme de fișiere specializate există FSx. Pentru obiecte accesate prin HTTP (imagini, backup-uri), S3 rămâne de obicei alegerea mai simplă și mai ieftină.

Ce urmărește intervievatorul: Verifică dacă alegi stocarea potrivită pentru tipul de date. Confuzia frecventă: EBS partajat între instanțe din zone diferite.

Eroarea, în practică:InvalidVolume.ZoneMismatch

30 Junior

Ce este un Elastic IP și când îl folosești? Ce se întâmplă cu IP-ul public al unei instanțe la stop și start?

Răspuns scurt: Un Elastic IP e o adresă IPv4 publică statică, alocată contului tău, pe care o poți muta între instanțe. IP-ul public automat se schimbă la fiecare stop/start, pe când Elastic IP-ul rămâne. Toate adresele IPv4 publice se taxează, deci eliberezi Elastic IP-urile nefolosite.

O instanță dintr-o subrețea publică primește, dacă e configurat, un IP public din rezerva AWS. Acesta este legat de instanță cât timp rulează: la stop îl pierzi, la start primești altul. Pentru un server de test nu contează, dar pentru o înregistrare DNS sau o regulă de firewall la un partener, adresa schimbată strică totul.

Un Elastic IP:

  • este alocat contului, în regiune, până îl eliberezi;
  • îl asociezi unei instanțe sau unei interfețe de rețea și îl poți muta rapid la alta, de exemplu ca failover simplu;
  • rămâne la stop/start.

Din februarie 2024, AWS taxează toate adresele IPv4 publice, atașate sau nu, deci un Elastic IP alocat și uitat costă bani. Le verifici periodic și le eliberezi pe cele neasociate.

Când nu ai nevoie de Elastic IP: aplicațiile din spatele unui load balancer (DNS-ul pointează spre load balancer, nu spre instanțe), instanțele dintr-un Auto Scaling group, serverele din subrețele private. Dacă un partener cere IP-uri fixe pentru traficul tău de ieșire, le obții printr-un NAT gateway cu Elastic IP. Dacă cere IP-uri fixe de intrare, un Network Load Balancer cu Elastic IP-uri per zonă rezolvă cerința.

Pe termen lung, IPv6 elimină o parte din această problemă, dar nu toate serviciile și rețelele clienților îl suportă.

Ce urmărește intervievatorul: Verifică înțelegerea adreselor publice și a costurilor ascunse. Greșeala tipică: un Elastic IP pe fiecare instanță dintr-o aplicație cu load balancer.

Eroarea, în practică:Gateway.NotAttached: no internet gatewayInvalidIPAddress.InUse: Address is in use

31 Junior

Compară opțiunile de cumpărare EC2: On-Demand, Reserved Instances, Savings Plans și Spot. Pe care o alegi pentru ce tip de încărcare?

Răspuns scurt: On-Demand e plata pe timp de utilizare, fără angajament; Reserved Instances și Savings Plans dau reduceri pentru angajamente pe 1 sau 3 ani; Spot folosește capacitate nefolosită cu reduceri mari, dar AWS poate lua instanța cu un avertisment de două minute.

  • On-Demand: plătești pe secundă (pentru Linux, cu un minim de un minut) cât rulează instanța. Fără angajament. Potrivit pentru încărcări noi, imprevizibile sau de scurtă durată.
  • Reserved Instances: te angajezi pentru un anumit tip de instanță într-o regiune, pe 1 sau 3 ani, în schimbul unei reduceri. Variantele Convertible permit schimbarea familiei. Astăzi sunt folosite mai ales pentru RDS, ElastiCache sau OpenSearch, unde Savings Plans nu se aplică.
  • Savings Plans: te angajezi la o sumă cheltuită pe oră, pe 1 sau 3 ani. Compute Savings Plans se aplică automat pe EC2 indiferent de familie, regiune sau sistem, plus Fargate și Lambda. EC2 Instance Savings Plans sunt legate de o familie într-o regiune, cu reducere mai mare.
  • Spot: capacitate nefolosită, la reduceri mari față de On-Demand, dar instanța poate fi întreruptă când AWS are nevoie de capacitate, cu notificare de două minute. Potrivit pentru joburi tolerante la întrerupere: procesare în loturi, CI, randare, noduri suplimentare de worker.

O strategie obișnuită: acoperi consumul stabil, minim, cu Savings Plans, lași vârfurile pe On-Demand și muți ce se poate pe Spot, în Auto Scaling groups cu mai multe tipuri de instanțe pentru disponibilitate mai bună.

Nu te angaja înainte să ai câteva luni de date de utilizare: Cost Explorer îți face recomandări pe baza istoricului.

Ce urmărește intervievatorul: Verifică dacă poți potrivi modelul de plată cu tipul de încărcare. Greșeala tipică: Spot pentru o bază de date fără replicare.

32 Mid

Cum funcționează snapshot-urile EBS? Cum faci un backup consistent al unui volum cu o bază de date și cum automatizezi backup-urile?

Răspuns scurt: Snapshot-urile sunt incrementale (salvează doar blocurile schimbate) și sunt stocate durabil, regional. Pentru consistență, oprești scrierile sau aplicația (sau folosești snapshot-uri multi-volum cu VSS/fsfreeze), iar automatizarea o faci cu Data Lifecycle Manager sau AWS Backup.

Un snapshot EBS e o copie la un moment dat a unui volum, păstrată de AWS în S3 (nu o vezi ca bucket). Primul snapshot copiază toate blocurile folosite, următoarele doar blocurile modificate. Ștergerea unui snapshot vechi nu strică restul: AWS păstrează blocurile de care mai au nevoie snapshot-urile rămase.

Ce poți face cu un snapshot:

  • creezi un volum nou în orice zonă a regiunii (așa muți un volum între zone);
  • îl copiezi în altă regiune sau în alt cont, pentru recuperare după dezastre;
  • creezi o AMI din el.

Consistența: snapshot-ul surprinde blocurile de pe disc, nu ce e în memoria aplicației. Pentru o bază de date, ai variante:

  • folosești mecanismul de backup al bazei (pg_dump, backup fizic) sau un mod de backup care aduce fișierele într-o stare consistentă;
  • îngheți sistemul de fișiere (fsfreeze) pe durata inițierii snapshot-ului;
  • pentru mai multe volume ale aceleiași instanțe, folosești snapshot-uri multi-volum, inițiate în același moment;
  • pe Windows, snapshot-uri cu VSS prin SSM.

Automatizare: Amazon Data Lifecycle Manager creează și șterge snapshot-uri după tag-uri și program. AWS Backup centralizează politicile pentru EBS, RDS, DynamoDB, EFS și altele, cu retenție, copiere între regiuni și vault-uri protejate împotriva ștergerii.

Un volum restaurat din snapshot se încarcă leneș din S3, deci primele citiri sunt lente; Fast Snapshot Restore elimină latența, cu cost suplimentar.

Ce urmărește intervievatorul: Verifică dacă știi diferența dintre un snapshot de bloc și un backup consistent al aplicației. Mulți nu știu de inițializarea leneșă la restaurare.

33 Mid

Cum își ia o aplicație de pe EC2 credențialele rolului IAM atașat instanței? Ce este IMDSv2 și de ce ar trebui impus?

Răspuns scurt: SDK-ul cere credențiale temporare de la serviciul de metadate al instanței (IMDS), la 169.254.169.254, și le reîmprospătează singur. IMDSv2 cere întâi un token obținut cu o cerere PUT, ceea ce blochează majoritatea atacurilor de tip SSRF care încearcă să fure credențialele.

Când atașezi un rol printr-un instance profile, EC2 face assume role în numele instanței și expune credențialele temporare prin IMDS. SDK-urile AWS și CLI le caută acolo automat, la sfârșitul lanțului de furnizori de credențiale, și le reînnoiesc înainte să expire. Codul tău nu conține nicio cheie.

Cu IMDSv2, accesul arată așa:

BASH
TOKEN=$(curl -s -X PUT "http://169.254.169.254/latest/api/token" \
  -H "X-aws-ec2-metadata-token-ttl-seconds: 21600")
curl -s -H "X-aws-ec2-metadata-token: $TOKEN" \
  http://169.254.169.254/latest/meta-data/iam/security-credentials/

De ce contează: cu IMDSv1 era suficient un simplu GET. Dacă aplicația avea o vulnerabilitate SSRF (server-side request forgery, adică atacatorul o poate face să ceară un URL ales de el), atacatorul putea citi credențialele rolului. IMDSv2 cere un PUT cu un header special, pe care majoritatea vulnerabilităților SSRF nu îl pot produce, iar răspunsul are TTL de rețea (hop limit) 1 implicit, deci nu iese din instanță.

Ce faci în practică:

  • impui IMDSv2 (HttpTokens=required) în launch template și ca setare implicită de cont;
  • verifici că SDK-urile folosite sunt suficient de noi;
  • pentru containere pe EC2, cu hop limit 1 containerele în rețea bridge nu ajung la IMDS, ceea ce e adesea dorit; pe ECS folosești roluri pe task, pe EKS EKS Pod Identity sau IRSA.

Ce urmărește intervievatorul: Verifică înțelegerea mecanismului din spatele rolurilor de instanță și a unui vector de atac real. Mulți știu „atașez rolul”, dar nu și de unde vin cheile.

Eroarea, în practică:Invalid IAM Instance Profile name

Load balancing, Auto Scaling și Route 53

34 Junior

Ce face un Elastic Load Balancer și ce rol au target group-urile și health check-urile?

Răspuns scurt: Load balancerul primește traficul clienților și îl distribuie către țintele sănătoase din target groups (instanțe, IP-uri sau funcții Lambda). Health check-urile verifică periodic fiecare țintă, iar cele care nu răspund corect sunt scoase din rotație până își revin.

Un load balancer e un punct de intrare stabil (un nume DNS) în fața mai multor servere. Avantajele: niciun server nu e punct unic de cădere, poți adăuga sau scoate servere fără ca clientul să observe, iar TLS-ul se poate termina într-un singur loc.

Target group: grupul de ținte către care load balancerul trimite traficul, cu protocolul și portul lor. Un Application Load Balancer poate avea mai multe target groups, de exemplu unul pentru /api și unul pentru frontend.

Health check: load balancerul trimite periodic o cerere fiecărei ținte, de exemplu GET /health pe portul aplicației, și așteaptă un cod de succes (implicit 200). Parametrii importanți:

  • intervalul și timeout-ul;
  • pragul de sănătate (câte răspunsuri bune consecutive ca ținta să fie declarată sănătoasă) și pragul de nesănătate;
  • codurile acceptate.

Un endpoint de health bun verifică dacă aplicația poate servi cereri, dar nu depinde de toate serviciile externe: dacă /health pică atunci când un API terț e lent, load balancerul scoate toate țintele deodată, iar o problemă parțială devine o cădere totală.

Load balancerul e și el redundant: îl creezi în cel puțin două zone de disponibilitate, iar AWS îl scalează automat. Security group-ul țintelor trebuie să permită traficul de la load balancer pe portul aplicației și pe portul health check-ului.

Ce urmărește intervievatorul: Verifică dacă înțelegi componentele de bază. Capcana: un health check care testează dependențe externe și scoate toate țintele din serviciu.

Eroarea, în practică:Health checks failed with these codes: [404]ALB: 503 Service Temporarily Unavailable

35 Junior

Când alegi un Application Load Balancer și când un Network Load Balancer?

Răspuns scurt: ALB lucrează la nivelul 7 (HTTP/HTTPS, gRPC, WebSocket) și rutează după path, host, headere; e alegerea pentru aplicații web și API-uri. NLB lucrează la nivelul 4 (TCP, UDP, TLS), are latență foarte mică, IP-uri statice pe zonă și suportă protocoale non-HTTP.

Application Load Balancer (ALB):

  • înțelege HTTP: rutează după path (/api/*), host (admin.exemplu.ro), headere, metodă, parametri de query;
  • face redirect HTTP → HTTPS și poate răspunde direct cu un răspuns fix;
  • se integrează cu AWS WAF și cu autentificare prin Cognito sau OIDC;
  • ținte: instanțe, IP-uri, funcții Lambda;
  • adaugă headere ca X-Forwarded-For, pentru că aplicația vede conexiunea venind de la ALB.

Network Load Balancer (NLB):

  • lucrează cu conexiuni TCP, UDP și TLS, fără să interpreteze HTTP;
  • oferă un IP static per zonă (poți asocia Elastic IP-uri), util când clienții sau partenerii cer IP-uri fixe în firewall;
  • latență foarte mică și capacitate de a gestiona un număr foarte mare de conexiuni;
  • poate păstra IP-ul sursă al clientului;
  • e necesar pentru protocoale non-HTTP: baze de date, MQTT, jocuri pe UDP, servicii expuse prin PrivateLink.

Mai există Gateway Load Balancer, pentru a trece traficul prin appliance-uri de securitate (firewall-uri terțe), și Classic Load Balancer, generația veche, pe care nu îl mai alegi pentru proiecte noi.

Pentru o aplicație web obișnuită, alegerea implicită este ALB. NLB apare când ai nevoie de IP-uri fixe, de protocoale non-HTTP sau de un front pentru PrivateLink. Uneori se combină: NLB cu IP-uri fixe în fața unui ALB.

Ce urmărește intervievatorul: Verifică dacă îți poți argumenta alegerea după cerințe concrete. Greșeala tipică: NLB ales „pentru performanță” când ai nevoie de rutare pe path.

36 Junior

Ce este un Auto Scaling group? Explică parametrii min, desired și max și rolul launch template-ului.

Răspuns scurt: Un Auto Scaling group (ASG) menține un număr de instanțe EC2 identice, pornite dintr-un launch template, distribuite pe mai multe zone. Min și max sunt limitele, iar desired e numărul pe care ASG-ul îl menține acum și pe care politicile de scalare îl modifică.

Un ASG rezolvă două probleme: elasticitatea (mai multe instanțe la trafic mare, mai puține la trafic mic) și auto-vindecarea (o instanță defectă e înlocuită automat).

  • Min: numărul minim de instanțe, chiar și fără trafic. Pentru disponibilitate, cel puțin 2, în zone diferite.
  • Max: plafonul, care te protejează de costuri scăpate de sub control dacă o politică greșită sau un atac împinge scalarea.
  • Desired: câte instanțe trebuie să ruleze acum. Politicile de scalare îl modifică în intervalul [min, max]; îl poți seta și manual.

Launch template descrie cum arată o instanță nouă: AMI, tip, security groups, rolul IAM (instance profile), user data, volume, setări IMDS. Are versiuni, deci poți lansa o versiune nouă și o poți aplica treptat cu instance refresh. Launch configurations sunt vechea variantă și nu mai primesc funcționalități noi.

ASG-ul distribuie instanțele echilibrat pe subrețelele din zone diferite pe care i le dai. Dacă o zonă cade, pornește instanțe în celelalte.

Integrarea cu load balancerul se face atașând ASG-ul la un target group: instanțele noi se înregistrează automat, iar cele terminate se deînregistrează.

Ca să funcționeze, aplicația trebuie să fie stateless: o instanță poate dispărea oricând, deci sesiunile, fișierele încărcate și datele stau în servicii externe (RDS, S3, ElastiCache).

Ce urmărește intervievatorul: Verifică dacă înțelegi componentele de bază ale elasticității. Greșeala tipică: min = 1, ceea ce înseamnă întrerupere la fiecare înlocuire.

Eroarea, în practică:Desired capacity must be between min and max size

37 Mid

Ce tipuri de politici de scalare are Auto Scaling și pe care o alegi pentru o aplicație web?

Răspuns scurt: Target tracking menține o metrică la o țintă, step scaling reacționează în trepte la alarme, scheduled scaling lucrează la ore fixe, predictive scaling anticipează vârfurile din istoric. Pentru web, implicit target tracking, plus scheduled sau predictive pentru vârfuri cunoscute.

  • Target tracking: alegi o metrică și o valoare, de exemplu ASGAverageCPUUtilization = 50 sau ALBRequestCountPerTarget = 1000. Auto Scaling creează alarmele și ajustează capacitatea ca metrica să rămână în jurul țintei, ca un termostat. E cel mai simplu de configurat corect.
  • Step scaling: definești tu alarme CloudWatch și pași: dacă CPU e între 60 și 80%, adaugă 1 instanță; peste 80%, adaugă 3. Util când vrei reacții diferite la intensități diferite.
  • Simple scaling: o singură ajustare per alarmă, cu cooldown; varianta veche, rar folosită acum.
  • Scheduled scaling: modifici min/desired/max la ore fixe, de exemplu mai multe instanțe în zilele lucrătoare dimineața.
  • Predictive scaling: analizează istoricul și pornește capacitatea înainte de vârfurile recurente.

Alegerea metricii contează: CPU funcționează pentru aplicații limitate de procesor; pentru aplicații care așteaptă mult după baza de date, numărul de cereri pe țintă sau latența reflectă mai bine încărcarea. Pentru workeri care citesc dintr-o coadă, metrica potrivită e numărul de mesaje din coadă raportat la numărul de instanțe.

Setări de care depinde stabilitatea:

  • instance warmup: cât durează până ce o instanță nouă contribuie la metrică, ca să nu se adauge instanțe în exces;
  • scale-in mai lent decât scale-out, ca să nu oscileze capacitatea.

Instanțele trebuie să pornească repede: o AMI pregătită ajută mult față de un user data care instalează totul.

Ce urmărește intervievatorul: Verifică dacă ai configurat scalare în practică. Greșeala tipică: CPU ca metrică pentru o aplicație limitată de I/O.

38 Mid

Un Auto Scaling group atașat unui ALB termină și repornește instanțele în buclă imediat după lansare. Care sunt cauzele probabile și cum le rezolvi?

Răspuns scurt: Probabil instanțele pică health check-ul ELB înainte să pornească aplicația: grace period prea scurt, path sau port greșit, ori SG-ul nu permite traficul de la ALB. Motivul îl vezi în Activity-ul ASG-ului și în starea țintelor.

Un ASG poate folosi două tipuri de health check:

  • EC2: instanța e considerată nesănătoasă doar dacă e oprită sau pică verificările de sistem ale hypervisorului;
  • ELB: în plus, instanța e nesănătoasă dacă target group-ul o raportează așa.

Cu tipul ELB activ (recomandat, altfel o aplicație căzută pe o instanță funcțională nu e înlocuită), orice problemă cu health check-ul duce la terminare și înlocuire.

Cauze frecvente ale buclei:

  • Health check grace period prea mic: aplicația are nevoie de câteva minute să pornească (user data instalează pachete, JVM-ul pornește), dar ASG-ul începe verificarea înainte;
  • path sau port greșit: health check pe / când aplicația răspunde cu 302 sau 404 acolo, ori pe portul 80 când aplicația ascultă pe 8080;
  • security group: SG-ul instanței nu permite traficul de la SG-ul ALB-ului pe portul de health check;
  • aplicația chiar nu pornește: lipsă de acces la internet pentru user data, secret inaccesibil din cauza rolului, eroare în cod.

Cum depanezi:

  • în ASG, tab-ul Activity arată motivul fiecărei terminări;
  • în target group, coloana de stare a țintelor dă motive ca Target.Timeout sau Target.ResponseCodeMismatch;
  • suspenzi temporar procesele ReplaceUnhealthy sau Terminate ale ASG-ului, ca să poți intra pe instanță și să citești logurile;
  • verifici /var/log/cloud-init-output.log și logurile aplicației.

Ce urmărește intervievatorul: E o întrebare de depanare tipică pentru cineva care a lucrat cu ASG. Intervievatorul urmărește dacă știi unde să cauți motivul terminării.

Eroarea, în practică:Health checks failed with these codes: [404]

39 Mid

Aplicația ta ține sesiunile utilizatorilor în memoria serverului. De ce devine asta o problemă când pui un Auto Scaling group în spatele unui ALB, și ce soluții ai?

Răspuns scurt: Cererile aceluiași utilizator pot ajunge pe servere diferite, iar la scale-in sau la înlocuirea unei instanțe sesiunile din memoria ei se pierd. Sticky sessions ascund parțial problema; soluția corectă e o aplicație stateless, cu sesiunile în ElastiCache, DynamoDB sau în tokenuri semnate.

Într-un grup elastic, instanțele apar și dispar. Cu sesiunile în memoria locală:

  • dacă load balancerul trimite următoarea cerere pe alt server, utilizatorul pare delogat;
  • la scale-in, la un deploy sau la înlocuirea unei instanțe defecte, toți utilizatorii de pe instanța aceea își pierd sesiunea;
  • încărcarea se distribuie inegal.

Sticky sessions (afinitate de sesiune) pe ALB, prin cookie-ul generat de load balancer sau un cookie al aplicației, trimit un utilizator mereu la aceeași țintă. E un plasture: rezolvă primul punct, dar nu și pierderea sesiunilor când instanța dispare, și poate dezechilibra serverele.

Soluțiile corecte mută starea în afara serverului:

  • ElastiCache (Redis sau Valkey, ori Memcached) ca stocare de sesiuni, cu latență foarte mică;
  • DynamoDB cu TTL pe înregistrările de sesiune, fără servere de administrat;
  • tokenuri semnate (de exemplu JWT) păstrate de client, dacă aplicația poate lucra fără stare pe server; atenție la revocare și la dimensiunea tokenului.

Aceeași logică se aplică fișierelor încărcate de utilizatori (în S3, nu pe discul local) și joburilor programate (să nu ruleze pe fiecare instanță în paralel).

Odată ce aplicația e stateless, poți folosi Spot, poți face deploy-uri rolling fără grijă și poți scala agresiv.

Ce urmărește intervievatorul: Verifică dacă înțelegi de ce aplicațiile trebuie să fie stateless pentru scalare orizontală. Răspunsul slab se oprește la „activez sticky sessions”.

40 Mid

Vrei ca domeniul exemplu.ro (fără www) să ducă la un Application Load Balancer. De ce nu poți folosi un CNAME și ce faci în Route 53?

Răspuns scurt: Standardul DNS interzice un CNAME la vârful zonei (zone apex), unde există deja înregistrările SOA și NS. În Route 53 creezi o înregistrare de tip A (și AAAA) cu opțiunea Alias, care indică direct spre ALB și urmărește automat IP-urile lui.

Un load balancer nu are IP-uri fixe: AWS îi schimbă adresele pe măsură ce îl scalează, și îți dă doar un nume DNS de forma app-123.eu-central-1.elb.amazonaws.com. Pentru www.exemplu.ro ai putea pune un CNAME spre acest nume, dar pentru exemplu.ro nu, pentru că un CNAME nu poate coexista cu alte înregistrări pentru același nume.

Alias e o extensie Route 53: arată ca o înregistrare A/AAAA pentru client, dar Route 53 o rezolvă intern către ținta AWS (ALB, NLB, CloudFront, bucket S3 de site static, API Gateway, altă înregistrare din aceeași zonă). Avantaje:

  • funcționează la vârful zonei;
  • urmează automat schimbările de IP ale țintei;
  • interogările către alias-uri spre resurse AWS nu se taxează;
  • poate evalua sănătatea țintei (EvaluateTargetHealth).

Route 53 are și politici de rutare utile la interviu:

  • simple: un singur răspuns;
  • weighted: împarte traficul procentual, util pentru migrări sau canary;
  • latency: trimite utilizatorul la regiunea cu latența cea mai mică;
  • failover: primar și secundar, pe baza unui health check;
  • geolocation și geoproximity: după locația clientului.

Pentru HTTPS pe ALB, certificatul vine din ACM, în aceeași regiune cu load balancerul, cu validare prin înregistrări DNS pe care Route 53 le poate crea automat.

Ce urmărește intervievatorul: Verifică dacă știi diferența dintre CNAME și Alias. Mulți nu știu de restricția de la zone apex.

Eroarea, în practică:CNAME is not permitted at apex

41 Mid

Cum configurezi HTTPS pe un Application Load Balancer și cum află aplicația IP-ul real al clientului și faptul că cererea a venit pe HTTPS?

Răspuns scurt: Ceri un certificat gratuit din ACM pentru domeniu, îl atașezi la un listener HTTPS pe 443 și adaugi pe listenerul de pe portul 80 un redirect către HTTPS. Aplicația citește IP-ul clientului din X-Forwarded-For și protocolul original din X-Forwarded-Proto.

Pașii:

  • în ACM (AWS Certificate Manager) ceri un certificat public pentru exemplu.ro și *.exemplu.ro, cu validare DNS; certificatul se reînnoiește automat cât timp înregistrarea de validare rămâne;
  • certificatul trebuie să fie în aceeași regiune cu ALB-ul (pentru CloudFront, certificatul trebuie să fie în us-east-1);
  • creezi listener-ul HTTPS:443 cu certificatul și o politică de securitate TLS recentă, care exclude versiunile vechi de TLS;
  • listener-ul HTTP:80 primește o singură regulă: redirect 301 la HTTPS.

Între ALB și instanțe, traficul poate rămâne HTTP în interiorul VPC-ului, sau poate fi și el HTTPS dacă cerințele de conformitate cer criptare peste tot.

Pentru că ALB-ul termină conexiunea, aplicația vede ca sursă IP-ul privat al load balancerului. ALB-ul adaugă headere:

  • X-Forwarded-For: IP-ul clientului (dacă cererea a trecut prin mai multe proxy-uri, e o listă, iar ultima adresă adăugată de ALB e cea de încredere);
  • X-Forwarded-Proto: https sau http;
  • X-Forwarded-Port.

Aplicațiile web trebuie configurate să aibă încredere în aceste headere doar de la load balancer, de exemplu trust proxy în Express sau ForwardedHeaders în Spring Boot. Altfel generează linkuri http://, intră în bucle de redirect sau scriu în loguri IP-ul greșit.

Ce urmărește intervievatorul: Verifică experiența cu o configurare reală de producție. Bucla de redirect cauzată de ignorarea X-Forwarded-Proto e o problemă des întâlnită.

Eroarea, în practică:A certificate must be specified for HTTPS listeners

42 Senior

Cum faci deploy-ul unei versiuni noi pe un Auto Scaling group din spatele unui ALB fără să pierzi cereri în curs?

Răspuns scurt: Creezi o versiune nouă a launch template-ului și rulezi un instance refresh cu procent minim de instanțe sănătoase și warmup corect; deregistration delay lasă cererile în curs să se termine. Alternativ, faci blue-green cu două target groups și muți traficul prin ponderile listenerului.

Ce poate pierde cereri: instanța veche e terminată în timp ce încă procesează cereri, sau instanța nouă primește trafic înainte să fie pregătită.

Mecanismele care previn asta:

  • Deregistration delay (connection draining) pe target group: când o țintă e scoasă, ALB-ul nu îi mai trimite cereri noi, dar lasă cererile în curs să se termine, până la timpul configurat (implicit 300 de secunde). Îl ajustezi după durata reală a cererilor.
  • Health checks și warmup: instanța nouă primește trafic doar după ce trece verificările.
  • Lifecycle hooks pe ASG: la terminare, instanța trece printr-o stare de așteptare în care aplicația poate termina joburile din fundal sau trimite loguri.
  • Aplicația tratează SIGTERM și se oprește ordonat.

Strategii de deploy:

  • Instance refresh: ASG-ul înlocuiește instanțele în loturi, respectând MinHealthyPercentage. Poți folosi checkpoint-uri și rollback automat dacă alarmele CloudWatch intră în ALARM.
  • Blue-green cu două target groups: un ASG nou cu versiunea nouă, apoi muți traficul din listener cu ponderi (de exemplu 10%, apoi 50%, apoi 100%). Revenirea e doar o schimbare de ponderi. CodeDeploy automatizează acest flux.
  • Pentru containere (ECS), aceleași principii se aplică la nivel de task.

Atenție la schimbările de schemă ale bazei de date: în timpul tranziției rulează simultan două versiuni de cod, deci schema trebuie să fie compatibilă cu ambele.

Ce urmărește intervievatorul: Verifică experiența cu deploy-uri reale în producție. Un senior ar trebui să menționeze draining-ul, warmup-ul și rollback-ul automat.

Amazon S3

43 Junior

Explică modelul de date al Amazon S3: bucket, obiect, cheie. Există foldere în S3? Ce consistență oferă S3 la citire după scriere?

Răspuns scurt: Bucketul are nume unic global și stă într-o regiune; obiectul e conținut plus metadate, identificat de o cheie. Folderele sunt doar prefixe. Din decembrie 2020, S3 are consistență puternică la citire după scriere, suprascriere și ștergere.

S3 este stocare de obiecte, nu sistem de fișiere. Un obiect are:

  • cheia, adică numele complet, de exemplu poze/2026/profil.jpg;
  • conținutul (de la 0 octeți până la limita maximă pentru un obiect);
  • metadate: Content-Type, metadate personalizate x-amz-meta-*, tag-uri;
  • un ID de versiune, dacă versioning este activ.

Folderele din consolă sunt o iluzie construită din prefixe și delimitatorul /. aws s3 ls s3://bucket/poze/ cere de fapt API-ului obiectele cu prefixul poze/. Consecințe: nu poți „redenumi un folder” printr-o singură operație; trebuie să copiezi fiecare obiect cu cheia nouă și să-l ștergi pe cel vechi. Nici nu modifici o parte dintr-un obiect: îl rescrii complet.

Consistența: după un PUT reușit, orice GET sau LIST ulterior vede obiectul nou, inclusiv la suprascriere și ștergere. Înainte de decembrie 2020, suprascrierile și ștergerile erau eventual consistente, de aceea materiale mai vechi descriu alt comportament. Nu există însă blocări: două scrieri simultane pe aceeași cheie se rezolvă prin „ultima scriere câștigă”, iar pentru scrieri condiționate există headere ca If-None-Match.

Numele bucketului devine parte din URL, de aceea trebuie să fie unic global, cu litere mici, cifre, puncte și cratime.

Ce urmărește intervievatorul: Verifică dacă înțelegi că S3 nu e un disc. Greșeala tipică: tratezi S3 ca pe un sistem de fișiere cu foldere și modificări parțiale.

Eroarea, în practică:NoSuchBucket: The specified bucket does not existNoSuchKey: The specified key does not exist

44 Junior

Care sunt clasele de stocare S3 și cum alegi una pentru loguri accesate des în prima lună și aproape deloc apoi?

Răspuns scurt: Principalele clase: Standard, Intelligent-Tiering, Standard-IA, One Zone-IA, Glacier Instant Retrieval, Glacier Flexible Retrieval și Glacier Deep Archive. Pentru logurile din exemplu: Standard la început, apoi o regulă de lifecycle care le mută în Standard-IA sau Glacier și le șterge după perioada de retenție.

Clasele diferă prin costul de stocare, costul accesului, timpul de recuperare și numărul de zone în care se păstrează datele:

  • S3 Standard: acces frecvent, latență de milisecunde, date în cel puțin trei zone.
  • S3 Intelligent-Tiering: S3 mută automat obiectele între niveluri în funcție de acces, pentru o taxă mică de monitorizare per obiect. Bun când tiparul de acces e necunoscut.
  • Standard-IA (Infrequent Access): stocare mai ieftină, dar plătești la fiecare citire și ai o durată minimă de stocare taxată (30 de zile) și o dimensiune minimă taxabilă per obiect.
  • One Zone-IA: ca IA, dar într-o singură zonă; potrivit doar pentru date pe care le poți regenera.
  • Glacier Instant Retrieval: arhivă accesată rar, dar citită în milisecunde.
  • Glacier Flexible Retrieval: recuperare în minute până la ore, după opțiunea aleasă.
  • Glacier Deep Archive: cea mai ieftină stocare, recuperare în ore; pentru arhive păstrate ani de zile pentru conformitate.

Pentru loguri: scrierea se face în Standard, apoi o regulă de lifecycle le mută după 30 de zile în Standard-IA sau direct în Glacier, după 90 de zile în Deep Archive, iar la final le șterge.

Capcana: obiectele foarte mici și cele șterse repede pot costa mai mult în IA sau Glacier din cauza minimelor taxabile. Calculează cu Pricing Calculator înainte.

Ce urmărește intervievatorul: Verifică dacă știi compromisul dintre costul de stocare și costul accesului. Mulți uită de duratele minime și de taxele de recuperare.

Eroarea, în practică:InvalidObjectState: not valid for storage class'Days' in Transition must be >= 30 for STANDARD_IA

45 Junior

Un coleg a șters din greșeală un fișier important dintr-un bucket cu versioning activ. Ce s-a întâmplat de fapt și cum îl recuperezi?

Răspuns scurt: Cu versioning activ, un DELETE fără ID de versiune nu șterge datele: adaugă un delete marker ca versiune curentă. Recuperezi fișierul ștergând delete marker-ul (sau copiind versiunea anterioară peste cheie); versiunea veche redevine curentă.

Cu versioning, fiecare PUT pe aceeași cheie creează o versiune nouă cu ID propriu, iar versiunile vechi rămân. La o ștergere simplă:

  • S3 adaugă un delete marker, care devine versiunea curentă;
  • GET pe cheie întoarce 404, iar obiectul nu mai apare în listări obișnuite;
  • versiunile anterioare există în continuare și se taxează.

Recuperare:

BASH
aws s3api list-object-versions --bucket firma-docs --prefix contracte/c42.pdf
aws s3api delete-object --bucket firma-docs --key contracte/c42.pdf \
  --version-id <id-ul-delete-marker-ului>

După ce ștergi delete marker-ul, versiunea anterioară redevine curentă. În consolă, activezi „Show versions”, selectezi delete marker-ul și îl ștergi.

Atenție: un DELETE cu --version-id pe o versiune de date șterge definitiv acea versiune. Pentru protecție suplimentară există MFA Delete (cere MFA pentru ștergerea permanentă a versiunilor și pentru schimbarea stării de versioning) și Object Lock.

Alte detalii utile:

  • versioning, odată activat, nu mai poate fi dezactivat, doar suspendat;
  • versiunile vechi cresc costul, așa că se combină cu o regulă de lifecycle care expiră versiunile necurente după un număr de zile;
  • replicarea S3 cere versioning activ pe ambele bucketuri.

Ce urmărește intervievatorul: Verifică dacă înțelegi cum funcționează versioning, nu doar că există. Mulți cred că recuperarea cere un backup separat.

Eroarea, în practică:BucketNotEmptyMethodNotAllowed: method not allowed (delete marker)

46 Junior

Scrie o configurație de lifecycle pentru prefixul loguri/ care mută obiectele în Standard-IA după 30 de zile, în Glacier Flexible Retrieval după 90, le șterge după 365 și curăță versiunile vechi după 30 de zile.

Răspuns scurt: Creezi o regulă cu Filter pe prefix, două Transitions (STANDARD_IA la 30 de zile, GLACIER la 90), Expiration la 365 de zile și NoncurrentVersionExpiration la 30 de zile, apoi o aplici cu aws s3api put-bucket-lifecycle-configuration.

JSON
{
  "Rules": [{
    "ID": "loguri-retentie",
    "Status": "Enabled",
    "Filter": {"Prefix": "loguri/"},
    "Transitions": [
      {"Days": 30, "StorageClass": "STANDARD_IA"},
      {"Days": 90, "StorageClass": "GLACIER"}
    ],
    "Expiration": {"Days": 365},
    "NoncurrentVersionExpiration": {"NoncurrentDays": 30},
    "AbortIncompleteMultipartUpload": {"DaysAfterInitiation": 7}
  }]
}
BASH
aws s3api put-bucket-lifecycle-configuration \
  --bucket firma-loguri --lifecycle-configuration file://lifecycle.json

Explicații:

  • GLACIER este numele API pentru Glacier Flexible Retrieval; Deep Archive este DEEP_ARCHIVE, iar Glacier Instant Retrieval este GLACIER_IR.
  • Tranziția în STANDARD_IA cere ca obiectele să fi stat cel puțin 30 de zile în Standard, de aceea 30 e valoarea minimă acolo.
  • Pe un bucket cu versioning, Expiration nu șterge datele, ci adaugă un delete marker; versiunea devenită necurentă e ștearsă apoi de NoncurrentVersionExpiration. Fără a doua regulă, logurile „șterse” s-ar acumula la nesfârșit.
  • AbortIncompleteMultipartUpload curăță încărcările multipart neterminate, care altfel ocupă spațiu taxat fără să apară în listări.

Regulile de lifecycle rulează asincron, deci tranzițiile nu se întâmplă exact la ora calculată. Configurația înlocuiește complet regulile existente ale bucketului, așa că o citești întâi cu get-bucket-lifecycle-configuration.

Ce urmărește intervievatorul: Verifică dacă poți scrie o regulă reală și dacă știi interacțiunea cu versioning. Mulți uită de versiunile necurente și de încărcările multipart neterminate.

Eroarea, în practică:MalformedXML: XML not well-formed'Days' in Transition must be >= 30 for STANDARD_IA

47 Junior

Ce diferență este între aws s3 cp --recursive și aws s3 sync? Ce face opțiunea --delete și de ce e periculoasă?

Răspuns scurt: cp --recursive copiază toate fișierele de fiecare dată, pe când sync copiază doar ce lipsește sau s-a schimbat (după mărime și dată). sync --delete șterge din destinație fișierele care nu mai există în sursă, deci o sursă greșită poate goli destinația.

BASH
# copiază tot, chiar dacă fișierele există deja
aws s3 cp ./build s3://site-firma/ --recursive

# copiază doar diferențele
aws s3 sync ./build s3://site-firma/

# oglindește sursa: șterge din bucket ce nu mai e local
aws s3 sync ./build s3://site-firma/ --delete --dryrun

sync compară dimensiunea și momentul ultimei modificări pentru fiecare fișier și transferă doar ce diferă. Pentru deploy-ul unui site static sau pentru backup-uri incrementale e mult mai rapid decât cp.

--delete face destinația o oglindă exactă a sursei. E util la deploy (dispar fișierele vechi din build), dar periculos: dacă rulezi din directorul greșit, dacă ./build e gol pentru că build-ul a eșuat, sau dacă inversezi sursa cu destinația, poți șterge tot conținutul bucketului.

Protecții:

  • rulezi întâi cu --dryrun, care afișează ce ar face fără să execute;
  • în scripturi, verifici că directorul sursă nu e gol înainte de sync;
  • ții versioning activ pe bucket, ca ștergerile să fie reversibile;
  • dai pipeline-ului doar permisiunile necesare pe bucketul respectiv.

Alte opțiuni utile: --exclude și --include pentru filtre, --size-only când datele de modificare nu sunt de încredere (de exemplu după un checkout Git), --cache-control ca să setezi headerele pentru site-ul static.

Ce urmărește intervievatorul: Verifică experiența practică cu CLI-ul. Intervievatorul vrea să audă de --dryrun și de riscul sursei goale.

48 Junior

Ce trebuie să configurezi ca să găzduiești un site static în S3 și de ce, în producție, pui de obicei CloudFront în față?

Răspuns scurt: Activezi static website hosting, setezi index și pagina de eroare și permiți citirea publică prin bucket policy. În producție, bucketul rămâne privat, iar CloudFront servește site-ul cu HTTPS, cache și acces prin Origin Access Control.

Varianta simplă, direct din S3:

  • activezi Static website hosting pe bucket, cu index.html și eventual error.html;
  • dezactivezi Block Public Access pentru acel bucket;
  • adaugi o bucket policy care permite s3:GetObject pentru "Principal": "*" pe arn:aws:s3:::bucket/*.

Site-ul e disponibil la endpoint-ul de website al bucketului, dar acest endpoint servește doar HTTP, nu HTTPS, iar bucketul este public.

Varianta de producție, cu CloudFront:

  • bucketul rămâne privat, cu Block Public Access activ;
  • CloudFront folosește Origin Access Control (OAC) ca să citească din bucket, iar bucket policy permite doar distribuția respectivă, prin condiția AWS:SourceArn;
  • HTTPS pe domeniul tău, cu certificat ACM emis în us-east-1;
  • cache aproape de utilizatori, compresie, HTTP/2 și HTTP/3;
  • posibilitatea de a adăuga AWS WAF și headere de securitate.

Pentru aplicații single-page (React, Vue), configurezi pagina de eroare personalizată ca rutele necunoscute să întoarcă index.html cu 200.

La deploy, după aws s3 sync, fie invalidezi cache-ul CloudFront, fie (mai bine) folosești nume de fișiere cu hash pentru resurse și cache scurt doar pentru index.html.

Ce urmărește intervievatorul: Verifică dacă știi diferența dintre un demo și o configurație de producție. Greșeala tipică: bucket public cu website endpoint, fără HTTPS.

Eroarea, în practică:403 Forbidden (AccessDenied) pe site-ul S3AccessDenied: blocked by BlockPublicPolicy

49 Mid

Scrie o funcție Python care generează un URL presemnat pentru descărcarea unui fișier privat din S3, valabil 15 minute. Ce permisiuni are cine primește linkul și cât poate fi de lung termenul?

Răspuns scurt: Folosești generate_presigned_url('get_object', ...) din boto3 cu ExpiresIn=900. Linkul are exact permisiunile identității care l-a semnat, doar pentru acea operație și cheie; termenul maxim e de 7 zile cu SigV4, iar dacă semnezi cu credențiale temporare linkul nu poate trăi mai mult decât sesiunea lor.

PYTHON
import boto3
from botocore.config import Config

s3 = boto3.client("s3", region_name="eu-central-1",
                  config=Config(signature_version="s3v4"))

def link_descarcare(bucket: str, cheie: str, secunde: int = 900) -> str:
    return s3.generate_presigned_url(
        "get_object",
        Params={"Bucket": bucket, "Key": cheie,
                "ResponseContentDisposition": "attachment"},
        ExpiresIn=secunde,
    )

print(link_descarcare("firma-facturi", "2026/10/f-1001.pdf"))

Cum funcționează: semnarea se face local, fără apel la AWS. URL-ul conține identitatea semnatarului, data, durata și o semnătură. La folosire, S3 verifică semnătura și apoi evaluează permisiunile semnatarului din acel moment. Dacă rolul pierde s3:GetObject între timp, linkul nu mai funcționează.

Consecințe practice:

  • un URL generat fără eroare nu garantează că funcționează: dacă identitatea nu are permisiune sau cheia nu există, eroarea apare doar la accesare;
  • dacă semnezi cu un rol (Lambda, EC2), linkul expiră cel târziu odată cu credențialele temporare, chiar dacă ai cerut 7 zile;
  • oricine are linkul îl poate folosi până expiră, deci durata se ține scurtă.

Pentru încărcări directe din browser, generezi un URL presemnat pentru put_object sau un formular cu generate_presigned_post, care permite și condiții (dimensiune maximă, tip de conținut). Astfel fișierele mari nu mai trec prin serverul tău.

Ce urmărește intervievatorul: Verifică dacă înțelegi modelul de securitate al URL-urilor presemnate. Mulți cred că linkul are permisiuni proprii, independente de semnatar.

Eroarea, în practică:AccessDenied: Request has expired (URL presemnat)

50 Mid

Scrie o bucket policy care refuză orice cerere ce nu folosește HTTPS. Cum se combină bucket policy-urile cu Block Public Access și cu ACL-urile?

Răspuns scurt: Un Deny pe s3:* pentru "Principal": "*", pe bucket și obiecte, cu aws:SecureTransport egal cu false. Block Public Access blochează orice acces public peste politici, iar „Bucket owner enforced” dezactivează ACL-urile.

JSON
{
  "Version": "2012-10-17",
  "Statement": [{
    "Sid": "DoarHTTPS",
    "Effect": "Deny",
    "Principal": "*",
    "Action": "s3:*",
    "Resource": [
      "arn:aws:s3:::firma-date",
      "arn:aws:s3:::firma-date/*"
    ],
    "Condition": {"Bool": {"aws:SecureTransport": "false"}}
  }]
}

Fiind un Deny, se aplică tuturor, inclusiv administratorilor din cont, și nu poate fi anulat de niciun Allow. E o regulă cerută des în auditurile de conformitate. Poți adăuga și condiția s3:TlsVersion ca să impui o versiune minimă de TLS.

Straturile de control al accesului în S3:

  • Politicile IAM ale identităților din cont.
  • Bucket policy: politică bazată pe resursă, singurul loc în care dai acces altor conturi sau public.
  • ACL-uri: mecanismul vechi, per obiect. Pentru bucketurile noi, Object Ownership este implicit „Bucket owner enforced”, adică ACL-urile sunt dezactivate. AWS recomandă să rămână așa.
  • Block Public Access: patru setări, la nivel de bucket și de cont, care blochează sau ignoră politicile și ACL-urile publice. Sunt active implicit pe bucketurile noi. Chiar dacă cineva scrie o bucket policy cu "Principal": "*" și Allow, Block Public Access o refuză.

La nivel de cont, ții Block Public Access activ și faci excepții doar pentru bucketurile care chiar trebuie să fie publice, ideal niciunul, servind conținutul public prin CloudFront.

Ce urmărește intervievatorul: Verifică dacă știi să scrii politici defensive și să explici straturile de acces. Greșeala tipică: Bool cu true în loc de Deny cu false.

Eroarea, în practică:403 Forbidden (AccessDenied) pe site-ul S3AccessDenied: blocked by BlockPublicPolicy

51 Mid

Ce opțiuni de criptare ai în S3 și ce câștigi alegând SSE-KMS în loc de SSE-S3?

Răspuns scurt: SSE-S3 (implicit din ianuarie 2023), SSE-KMS, DSSE-KMS, SSE-C și criptare pe client. SSE-KMS adaugă control prin politica cheii, audit în CloudTrail pentru fiecare utilizare și posibilitatea de a revoca accesul.

Criptarea în repaus:

  • SSE-S3: S3 gestionează cheile complet. Din ianuarie 2023 se aplică automat tuturor obiectelor noi, fără cost suplimentar.
  • SSE-KMS: obiectul e criptat cu o cheie de date, protejată de o cheie din AWS KMS (cheia gestionată de AWS aws/s3 sau o cheie gestionată de client).
  • DSSE-KMS: două straturi de criptare, pentru cerințe de conformitate stricte.
  • SSE-C: tu trimiți cheia la fiecare cerere, iar S3 nu o păstrează. Dacă o pierzi, datele sunt pierdute.
  • Criptare pe client: criptezi înainte de upload, de exemplu cu AWS Encryption SDK; S3 vede doar date criptate.

Ce aduce SSE-KMS cu o cheie gestionată de client:

  • control separat: cine vrea să citească obiectul are nevoie și de s3:GetObject, și de kms:Decrypt pe cheie; un bucket expus din greșeală nu expune datele dacă politica cheii nu permite;
  • audit: fiecare utilizare a cheii apare în CloudTrail;
  • revocare: dezactivezi cheia sau schimbi politica ei și accesul se oprește;
  • rotație automată a materialului cheii.

Costuri și limite: fiecare criptare sau decriptare e un apel KMS, taxat și supus unor limite de rată. S3 Bucket Keys reduc mult numărul de apeluri, folosind o cheie la nivel de bucket derivată temporar din cheia KMS.

În tranzit se folosește HTTPS, impus prin bucket policy cu aws:SecureTransport.

Ce urmărește intervievatorul: Verifică dacă știi criptarea dincolo de „bifez encryption”. Diferențiatorul este că SSE-KMS adaugă un al doilea strat de control al accesului.

52 Mid

O aplicație încarcă fișiere video de câțiva GB în S3 și citește intens obiecte mici. Cum optimizezi performanța?

Răspuns scurt: Pentru fișiere mari folosești multipart upload în paralel (obligatoriu peste 5 GB, recomandat de la aproximativ 100 MB) și, pentru clienți îndepărtați, Transfer Acceleration. Pentru citiri, paralelizezi pe mai multe prefixe, folosești byte-range fetches și pui CloudFront sau un cache în față.

Încărcări mari:

  • Multipart upload împarte fișierul în părți care se încarcă în paralel și se pot reîncerca individual. Un singur PUT acceptă maximum 5 GB, deci peste această dimensiune multipart e obligatoriu. aws s3 cp și upload_file din boto3 îl folosesc automat peste un prag configurabil.
  • Încărcările multipart neterminate ocupă spațiu taxat; le curăți cu o regulă de lifecycle AbortIncompleteMultipartUpload.
  • S3 Transfer Acceleration trimite datele prin edge locations CloudFront și apoi pe rețeaua AWS, util când clienții sunt departe de regiunea bucketului.

Citiri multe:

  • S3 suportă cel puțin 3 500 de cereri de scriere și 5 500 de cereri de citire pe secundă per prefix, iar numărul de prefixe nu e limitat. Dacă distribui obiectele pe mai multe prefixe, capacitatea crește. S3 se adaptează treptat la creșteri bruște, timp în care pot apărea erori 503 Slow Down, pe care SDK-ul le reîncearcă.
  • Byte-range fetches: citești doar porțiunea necesară dintr-un obiect sau descarci un fișier mare în paralel, pe bucăți.
  • CloudFront pentru conținut citit de mulți utilizatori, ca să nu ajungă fiecare cerere la S3.
  • Pentru latență foarte mică pe date fierbinți, S3 Express One Zone oferă acces de ordinul milisecundelor într-o singură zonă.

Ține aplicația și bucketul în aceeași regiune: altfel plătești transfer între regiuni și adaugi latență.

Ce urmărește intervievatorul: Verifică experiența cu volume reale de date. Mulți nu știu că performanța S3 se scalează pe prefixe.

53 Senior

Cum protejezi datele dintr-un bucket S3 critic împotriva ștergerii accidentale, a unui atac ransomware și a căderii unei regiuni?

Răspuns scurt: Combini versioning cu MFA Delete sau Object Lock (WORM, în modul compliance pentru protecție absolută), replicare în altă regiune și, ideal, în alt cont cu acces separat, plus politici care refuză ștergerile și alerte pe evenimentele de ștergere.

Gândește în straturi, pentru că amenințările sunt diferite.

Ștergere accidentală:

  • versioning activ, cu lifecycle pentru versiunile vechi;
  • un Deny pe s3:DeleteObjectVersion și s3:PutBucketVersioning pentru toată lumea, cu excepția unui rol de administrare.

Ransomware sau credențiale compromise (atacatorul suprascrie sau șterge versiunile):

  • S3 Object Lock (model WORM, write once read many) cu retenție implicită pe bucket. În modul governance, utilizatorii cu o permisiune specială pot ocoli retenția; în modul compliance, nimeni, nici root-ul, nu poate șterge versiunea înainte de expirarea retenției. Object Lock se activează la crearea bucketului sau ulterior, cu versioning activ.
  • Legal hold pentru obiecte care trebuie păstrate fără termen.

Căderea unei regiuni sau compromiterea contului:

  • Cross-Region Replication (CRR) către un bucket din altă regiune; Same-Region Replication pentru o copie în alt cont, în aceeași regiune;
  • bucketul destinație într-un cont separat, cu alte credențiale și acces restrâns, cu Object Lock propriu;
  • Replication Time Control dacă ai nevoie de un timp de replicare garantat;
  • AWS Backup pentru S3, cu vault protejat prin Vault Lock.

Detectare:

  • CloudTrail data events pentru ștergeri, GuardDuty S3 Protection, alarme pe numărul de DeleteObject.

Un detaliu important: delete marker-ele se replică doar dacă activezi explicit opțiunea, iar ștergerea permanentă a unei versiuni din sursă nu se replică niciodată, ceea ce e tocmai protecția dorită.

Ce urmărește intervievatorul: Verifică gândirea în straturi pentru protecția datelor. Un senior separă clar eroarea umană, atacul și dezastrul regional.

VPC și rețelistică

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

Ai un VPC 10.0.0.0/16. Cum îl împarți în subrețele /24 pentru două zone și câte adrese poți folosi efectiv într-o subrețea /24 în AWS?

Răspuns scurt: Creezi, de exemplu, 10.0.1.0/24 și 10.0.2.0/24 publice și 10.0.11.0/24 și 10.0.12.0/24 private, câte una pe zonă. Un /24 are 256 de adrese, dar AWS rezervă 5 în fiecare subrețea, deci rămân 251 utilizabile.

Un VPC /16 are 65 536 de adrese. Fiecare subrețea primește un bloc din el și stă într-o singură zonă de disponibilitate. O schemă clară face rutarea și regulile de firewall ușor de citit:

10.0.1.0/24   public-a    eu-central-1a
10.0.2.0/24   public-b    eu-central-1b
10.0.11.0/24  app-a       eu-central-1a
10.0.12.0/24  app-b       eu-central-1b
10.0.21.0/24  date-a      eu-central-1a
10.0.22.0/24  date-b      eu-central-1b

Cele 5 adrese rezervate de AWS în 10.0.1.0/24:

  • 10.0.1.0: adresa rețelei;
  • 10.0.1.1: routerul VPC;
  • 10.0.1.2: rezervată pentru DNS (serverul DNS al AWS e la adresa de bază a VPC-ului plus 2);
  • 10.0.1.3: rezervată pentru utilizări viitoare;
  • 10.0.1.255: adresa de broadcast (AWS nu suportă broadcast, dar o rezervă).

Limitele: un VPC poate avea între /16 și /28; o subrețea cel puțin /28 (16 adrese, 11 utilizabile).

Planificare: lasă loc pentru creștere și pentru zone suplimentare. Serviciile care consumă multe IP-uri (pod-urile EKS cu rețeaua VPC CNI, Lambda în VPC, load balancere) pot epuiza subrețele mici. Alege și blocuri care nu se suprapun cu rețeaua biroului sau cu alte VPC-uri, altfel nu le vei putea conecta ulterior prin peering sau VPN.

Ce urmărește intervievatorul: Verifică dacă poți planifica adresarea concret. Detaliul cu cele 5 adrese rezervate deosebește pe cine a lucrat efectiv cu VPC.

Eroarea, în practică:InvalidSubnet.Range: The CIDR is invalidInvalidSubnet.Conflict

55 Junior

Scrie conținutul tabelei de rutare pentru o subrețea publică și pentru una privată dintr-un VPC 10.0.0.0/16. Ce face ca o subrețea să fie „publică”?

Răspuns scurt: Ambele au ruta 10.0.0.0/16 → local. Subrețeaua publică are în plus 0.0.0.0/0 → igw-..., iar cea privată 0.0.0.0/0 → nat-... (sau nicio rută implicită). O subrețea e publică exclusiv pentru că tabela ei de rutare trimite traficul spre internet la un Internet Gateway.

Tabelă publică (asociată cu public-a, public-b)
  Destinație     Țintă
  10.0.0.0/16    local
  0.0.0.0/0      igw-0abc...
  ::/0           igw-0abc...      (dacă folosești IPv6)

Tabelă privată pentru zona a (asociată cu app-a)
  10.0.0.0/16    local
  0.0.0.0/0      nat-0aaa...      (NAT gateway din public-a)
  pl-xxxx (S3)   vpce-0s3...      (gateway endpoint, opțional)

Cum se aleg rutele: routerul VPC folosește cea mai specifică potrivire (longest prefix match). Traficul spre 10.0.5.7 se potrivește cu /16 și rămâne local; orice altă destinație cade pe 0.0.0.0/0.

Ruta local există în orice tabelă, nu poate fi ștearsă și permite comunicarea între toate subrețelele VPC-ului. Ce poate comunica efectiv decid apoi security groups și NACL-urile.

O subrețea publică nu are nicio setare specială în afară de rută. Ca o instanță din ea să fie accesibilă din internet, îi mai trebuie un IP public sau un Elastic IP și un security group care permite traficul.

Fiecare subrețea e asociată cu exact o tabelă; dacă nu o asociezi explicit, folosește tabela principală a VPC-ului. Bună practică: lași tabela principală fără rută spre internet, ca o subrețea nouă să fie privată implicit.

Câte o tabelă privată pe zonă îți permite ca fiecare zonă să folosească NAT gateway-ul din propria zonă.

Ce urmărește intervievatorul: Verifică dacă înțelegi că „public” e o proprietate a rutării. Greșeala tipică: crezi că bifezi „public” la crearea subrețelei.

Eroarea, în practică:ssh: port 22: Connection timed outGateway.NotAttached: no internet gateway

56 Junior

Ai pornit o instanță într-o subrețea publică, dar nu ajunge la internet și nici tu la ea. Ce verifici, în ordine?

Răspuns scurt: Verifici IP-ul public, Internet Gateway-ul atașat, ruta 0.0.0.0/0 spre IGW în tabela subrețelei, security group-ul, NACL-ul (inclusiv porturile efemere), apoi serviciul și firewall-ul din sistemul de operare.

Lista de verificare, de la rețea spre instanță:

  • IP public: subrețeaua are „auto-assign public IPv4” activat sau ai asociat un Elastic IP? Fără IP public, Internet Gateway-ul nu are ce adresă să traducă, chiar dacă ruta există.
  • Internet Gateway: există și e atașat la VPC-ul corect. Un VPC are cel mult un IGW.
  • Tabela de rutare: subrețeaua e asociată cu tabela care conține 0.0.0.0/0 → igw, nu cu tabela principală fără rută.
  • Security group: inbound pentru portul pe care încerci (22, 80, 443) de la IP-ul tău; outbound, implicit totul permis, dar poate a fost restrâns.
  • Network ACL: dacă e unul personalizat, permite traficul și răspunsurile, adică porturile efemere 1024-65535 în sens invers.
  • Instanța: serviciul ascultă pe portul și pe interfața corectă (0.0.0.0, nu 127.0.0.1), firewall-ul din sistem nu blochează, sistemul a pornit corect (status checks, log-ul de consolă).

Pentru a nu ghici, folosești VPC Reachability Analyzer, care analizează configurația și îți spune exact ce componentă blochează drumul între sursă și destinație, sau VPC Flow Logs, unde vezi dacă pachetele ajung la interfață și sunt ACCEPT sau REJECT.

Un Internet Gateway face traducerea 1:1 între IP-ul privat al instanței și IP-ul ei public; nu e un NAT pentru mai multe instanțe private.

Ce urmărește intervievatorul: E o întrebare de depanare clasică. Intervievatorul urmărește o ordine logică și dacă știi că IP-ul public e necesar.

Eroarea, în practică:ssh: port 22: Connection timed out

57 Junior

Cum accesezi o instanță dintr-o subrețea privată? Compară un bastion host cu AWS Systems Manager Session Manager.

Răspuns scurt: Un bastion host e o instanță mică într-o subrețea publică, prin care faci SSH mai departe spre instanțele private. Session Manager oferă un shell prin agentul SSM, fără port deschis, fără chei SSH și cu sesiuni înregistrate, de aceea e varianta recomandată astăzi.

Bastion host (jump box):

  • instanță într-o subrețea publică, cu SSH permis doar de la IP-urile echipei;
  • instanțele private permit SSH doar din security group-ul bastionului;
  • te conectezi cu ssh -J ec2-user@bastion ec2-user@10.0.11.25, cu agent forwarding sau cu cheia pe laptop, nu copiată pe bastion.

Dezavantaje: o instanță expusă la internet, de întreținut și de actualizat, chei SSH de distribuit și de rotit, audit limitat.

Session Manager:

  • instanța rulează agentul SSM (preinstalat pe Amazon Linux și pe alte AMI-uri oficiale) și are un rol cu AmazonSSMManagedInstanceCore;
  • agentul inițiază o conexiune de ieșire spre serviciul SSM, deci nu ai nevoie de niciun port inbound deschis;
  • instanța privată ajunge la SSM printr-un NAT gateway sau prin VPC interface endpoints (ssm, ssmmessages, ec2messages), fără internet;
  • accesul se controlează prin IAM, sesiunile pot fi înregistrate în CloudWatch Logs sau S3;
  • suportă port forwarding, de exemplu ca să te conectezi local la o bază RDS privată.
BASH
aws ssm start-session --target i-0abc123

Mai există EC2 Instance Connect Endpoint, care permite SSH spre instanțe private fără bastion și fără IP public.

Pentru acces la baze de date sau aplicații interne din rețeaua biroului, alternativele sunt AWS Client VPN sau Site-to-Site VPN.

Ce urmărește intervievatorul: Verifică dacă știi practicile moderne de acces securizat. Răspunsul bun explică de ce Session Manager nu are nevoie de porturi deschise.

58 Mid

Ai adăugat pe subrețeaua serverelor web un Network ACL personalizat cu regulile de mai jos. Clienții nu primesc răspuns, deși security group-ul permite 443. Unde e problema?

Inbound:   100  TCP 443  0.0.0.0/0  ALLOW
           *    ALL      0.0.0.0/0  DENY
Outbound:  100  TCP 443  0.0.0.0/0  ALLOW
           *    ALL      0.0.0.0/0  DENY

Răspuns scurt: NACL-urile sunt stateless: răspunsul serverului pleacă de pe portul 443 spre portul efemer al clientului (de obicei între 1024 și 65535), iar regula outbound permite doar destinația 443. Trebuie adăugată o regulă outbound pentru TCP 1024-65535 către 0.0.0.0/0.

Regulile NACL se aplică pe port destinație. O conexiune HTTPS de la un client arată așa:

  • cererea: client:51234 → server:443; trece de regula inbound 100;
  • răspunsul: server:443 → client:51234; portul destinație este 51234, care nu se potrivește cu regula outbound 443, deci cade pe deny-ul final.

Security group-ul e stateful: ține evidența conexiunilor și lasă răspunsurile să iasă automat. NACL-ul nu ține nicio evidență și evaluează fiecare pachet independent.

Regulile corecte:

Inbound:   100  TCP 443         0.0.0.0/0  ALLOW
           110  TCP 1024-65535  0.0.0.0/0  ALLOW   (răspunsuri la conexiunile inițiate de server)
Outbound:  100  TCP 1024-65535  0.0.0.0/0  ALLOW   (răspunsuri către clienți)
           110  TCP 443         0.0.0.0/0  ALLOW   (serverul cheamă API-uri externe)

Alte reguli NACL de reținut:

  • se evaluează în ordinea numerelor, iar prima potrivire decide;
  • un NACL personalizat nou refuză totul implicit, pe când NACL-ul implicit al VPC-ului permite totul;
  • se aplică la nivel de subrețea, deci și traficului dintre instanțe din subrețele diferite;
  • pot conține reguli DENY, util pentru a bloca rapid un interval de IP-uri.

De aceea, în practică, multe echipe lasă NACL-urile pe implicit și lucrează cu security groups, folosind NACL-uri doar ca strat suplimentar de apărare.

Ce urmărește intervievatorul: Verifică înțelegerea concretă a diferenței stateful/stateless, nu doar definiția. Uitarea porturilor efemere e cea mai frecventă greșeală cu NACL-uri.

59 Mid

Ai trei niveluri: ALB, servere de aplicație și o bază de date RDS. Cum scrii security groups astfel încât fiecare nivel să accepte trafic doar de la nivelul din fața lui, fără să folosești adrese IP?

Răspuns scurt: Creezi câte un security group pe nivel și folosești ca sursă în reguli ID-ul altui security group: sg-app acceptă portul aplicației doar de la sg-alb, iar sg-db acceptă portul bazei de date doar de la sg-app. Regulile rămân valabile oricâte instanțe apar sau dispar.

sg-alb   Inbound  TCP 443   0.0.0.0/0
sg-app   Inbound  TCP 8080  sursă: sg-alb
sg-db    Inbound  TCP 5432  sursă: sg-app

O regulă cu sursa sg-app înseamnă „orice interfață de rețea care are atașat sg-app”. Când Auto Scaling pornește o instanță nouă cu sg-app, ea are imediat acces la baza de date; când e terminată, accesul dispare. Nu trebuie să ții liste de IP-uri sincronizate cu realitatea.

Avantaje față de reguli pe CIDR (de exemplu 10.0.11.0/24):

  • privilegiu minim real: nu orice resursă din subrețea, ci doar cele cu rolul potrivit;
  • funcționează în medii dinamice: ASG, ECS, Lambda în VPC;
  • se citește ca o diagramă de arhitectură.

În CloudFormation:

YAML
DbSecurityGroupIngress:
  Type: AWS::EC2::SecurityGroupIngress
  Properties:
    GroupId: !Ref DbSG
    IpProtocol: tcp
    FromPort: 5432
    ToPort: 5432
    SourceSecurityGroupId: !Ref AppSG

Regula separată (SecurityGroupIngress) evită dependențele circulare când două grupuri se referă unul la altul.

Restricții: referirea la un SG funcționează în același VPC și, cu anumite condiții, prin VPC peering în aceeași regiune. Nu funcționează pentru trafic care trece prin NAT sau prin IP-uri publice, unde sursa văzută nu mai are SG-ul inițial.

Ce urmărește intervievatorul: Verifică dacă știi să construiești segmentarea pe niveluri în mod idiomatic AWS. Candidații mai puțin experimentați folosesc CIDR-uri largi.

60 Mid

De ce se recomandă un NAT gateway în fiecare zonă de disponibilitate și cum reduci costul traficului prin NAT?

Răspuns scurt: NAT gateway e zonal: dacă zona lui cade, celelalte zone pierd ieșirea, iar traficul între zone se taxează. Costul îl reduci cu gateway endpoints gratuite pentru S3 și DynamoDB, interface endpoints și mai puțin trafic inutil.

NAT gateway permite instanțelor private să inițieze conexiuni spre internet (actualizări, API-uri externe), fără să poată fi contactate din internet. Stă într-o subrețea publică, are un Elastic IP și e gestionat de AWS, cu redundanță în interiorul zonei lui.

De ce unul pe zonă:

  • dacă toate subrețelele private folosesc un singur NAT din zona A și zona A are probleme, aplicațiile din zona B pierd ieșirea, deși ele funcționează;
  • traficul din zona B către NAT-ul din zona A trece între zone și plătești transfer suplimentar;
  • de aceea, fiecare zonă are tabela ei privată, cu ruta implicită spre NAT-ul din aceeași zonă.

Pentru un mediu de test se poate folosi un singur NAT, acceptând riscul.

Costul: un NAT gateway se taxează pe oră și pe fiecare GB procesat. Reduceri tipice:

  • gateway endpoints pentru S3 și DynamoDB: o rută în tabela privată, fără cost, iar traficul nu mai trece prin NAT;
  • interface endpoints (PrivateLink) pentru ECR, CloudWatch Logs, SSM, Secrets Manager: au și ele cost pe oră și pe GB, dar pot fi mai ieftine decât NAT la volume mari și țin traficul în rețeaua AWS;
  • imagini de container în ECR din aceeași regiune, cache pentru pachete, evitarea descărcărilor repetate la pornire;
  • VPC Flow Logs și Cost Explorer pentru a vedea ce resurse generează traficul.

Pentru IPv6, ieșirea fără intrare se face cu un egress-only internet gateway, fără costul de procesare al NAT-ului.

Ce urmărește intervievatorul: Verifică dacă înțelegi disponibilitatea zonală și costurile ascunse de rețea. Factura de NAT surprinde multe echipe.

61 Mid

Ce sunt VPC endpoints? Prin ce diferă un gateway endpoint de un interface endpoint?

Răspuns scurt: Permit acces la servicii AWS din VPC fără internet sau NAT. Gateway endpoints (S3, DynamoDB) sunt o rută în tabelă, fără cost; interface endpoints (PrivateLink) sunt interfețe cu IP privat, pentru multe servicii, taxate pe oră și pe date.

Gateway endpoint:

  • disponibil pentru S3 și DynamoDB;
  • adaugi endpoint-ul la una sau mai multe tabele de rutare, iar AWS inserează o rută cu un prefix list al serviciului ca destinație;
  • fără cost; traficul rămâne în rețeaua AWS;
  • funcționează doar pentru trafic din același VPC și din aceeași regiune; nu e accesibil din rețeaua de birou prin VPN.

Interface endpoint (AWS PrivateLink):

  • creează interfețe de rețea (ENI) cu IP-uri private în subrețelele alese, cu security group propriu;
  • disponibil pentru majoritatea serviciilor AWS (SQS, SNS, ECR, Secrets Manager, CloudWatch, STS, SSM) și pentru servicii ale altor conturi sau furnizori expuse prin PrivateLink;
  • cu Private DNS activat, numele obișnuit al serviciului (de exemplu sqs.eu-central-1.amazonaws.com) se rezolvă la IP-urile private, deci codul nu se schimbă;
  • poate fi folosit și din rețele conectate prin VPN sau Direct Connect;
  • se taxează pe oră, pe zonă și pe GB procesat.

Endpoint policies: ambele tipuri acceptă o politică care restrânge ce se poate face prin endpoint, de exemplu acces doar la bucketurile firmei. Combinat cu condiția aws:SourceVpce în bucket policy, obții un bucket accesibil doar din VPC-ul tău.

Pentru S3 există acum și interface endpoints, utile când accesezi S3 din rețeaua de birou; în interiorul VPC-ului, gateway endpoint rămâne alegerea implicită, fiind gratuit.

Ce urmărește intervievatorul: Verifică dacă știi conectivitatea privată la serviciile AWS. Mulți nu știu că gateway endpoint-ul pentru S3 e gratuit și reduce costul de NAT.

62 Mid

Cum folosești VPC Flow Logs și Reachability Analyzer ca să afli de ce o aplicație nu se poate conecta la un serviciu din alt subnet?

Răspuns scurt: Reachability Analyzer analizează configurația dintre sursă și destinație și numește componenta care blochează, fără trafic real. Flow Logs înregistrează traficul real pe interfețe, cu ACCEPT sau REJECT, și confirmă ce se întâmplă efectiv.

Reachability Analyzer e o analiză statică: alegi sursa (o instanță, o interfață, un Internet Gateway) și destinația, portul și protocolul. Rezultatul e „reachable” cu drumul complet sau „not reachable” cu componenta exactă care blochează, de exemplu „security group sg-0db... nu are regulă inbound pentru portul 5432 de la sursă”. E cel mai rapid mod de a verifica o configurație nouă.

VPC Flow Logs captează metadatele traficului IP pe VPC, subrețea sau interfață și le trimit în CloudWatch Logs, S3 sau Firehose. Un rând în formatul implicit arată astfel:

2 123456789012 eni-0a1b 10.0.11.25 10.0.21.40 49152 5432 6 10 840 1730368800 1730368860 REJECT OK

Câmpurile principale: interfața, IP sursă, IP destinație, port sursă, port destinație, protocol (6 = TCP), pachete, octeți, interval și acțiunea.

Cum interpretezi:

  • REJECT pe inbound la destinație: security group sau NACL al destinației;
  • ACCEPT pe inbound, dar REJECT pe răspuns: probabil un NACL care nu permite porturile efemere;
  • nicio înregistrare: traficul nu ajunge, problema e de rutare sau de DNS, ori aplicația se conectează la altă adresă.

Limitări: Flow Logs nu conțin conținutul pachetelor și nu înregistrează unele tipuri de trafic (de exemplu către serverul DNS al AWS sau către serviciul de metadate). Pentru analize, interogi logurile cu CloudWatch Logs Insights sau, din S3, cu Athena.

Dacă rețeaua e în regulă, verifici rezolvarea DNS și că serviciul ascultă pe interfața corectă.

Ce urmărește intervievatorul: Verifică dacă depanezi rețeaua cu unelte, nu prin încercări. Diferențierea dintre analiza configurației și traficul real e esențială.

63 Senior

Firma are 15 VPC-uri în mai multe conturi și o conexiune VPN cu biroul. Când folosești VPC peering și când un Transit Gateway?

Răspuns scurt: Peering e o legătură directă între două VPC-uri, fără cost pe oră, dar netranzitivă, deci devine greu de administrat la multe VPC-uri. Transit Gateway e un hub regional pentru VPC-uri și VPN-uri, potrivit aici.

VPC peering:

  • conexiune unu-la-unu între două VPC-uri, în același cont sau în conturi diferite, în aceeași regiune sau între regiuni;
  • nu e tranzitivă: dacă A e conectat cu B și B cu C, A nu ajunge la C prin B; nici nu poți folosi Internet Gateway-ul, NAT-ul sau VPN-ul VPC-ului vecin;
  • CIDR-urile nu se pot suprapune;
  • pentru N VPC-uri complet conectate ai nevoie de N(N-1)/2 conexiuni și rute în fiecare tabelă: pentru 15 VPC-uri, 105 conexiuni;
  • nu are cost pe oră, doar transferul de date; latență minimă.

Transit Gateway:

  • hub regional; atașezi VPC-uri, VPN-uri Site-to-Site, Direct Connect și alte Transit Gateway-uri (peering între regiuni);
  • tabele de rutare proprii, cu care segmentezi rețeaua: de exemplu producția nu vede dezvoltarea, dar ambele văd VPC-ul de servicii comune;
  • o singură conexiune VPN spre birou, partajată de toate VPC-urile;
  • partajat între conturi prin AWS RAM;
  • cost pe oră pe atașament și pe GB procesat.

Pentru scenariul din întrebare, Transit Gateway e alegerea naturală. Peering rămâne potrivit pentru câteva VPC-uri cu trafic mare între ele, unde costul procesării prin hub contează.

Alternative de știut: PrivateLink, când vrei să expui doar un serviciu, nu o rețea întreagă (rezolvă și CIDR-urile suprapuse), și VPC Lattice pentru comunicarea între servicii la nivel de aplicație.

Planificarea adreselor la nivel de organizație (de exemplu cu VPC IPAM) previne suprapunerile care blochează aceste conexiuni.

Ce urmărește intervievatorul: Verifică gândirea de rețea la scară. Netranzitivitatea peering-ului este punctul pe care intervievatorul îl caută.

64 Senior

Proiectează rețeaua unui VPC de producție pentru o aplicație web cu bază de date, care trebuie să reziste la căderea unei zone de disponibilitate.

Răspuns scurt: Trei niveluri de subrețele (public, aplicație, date) în cel puțin două zone, ALB în cele publice, aplicația și baza în cele private, NAT gateway pe zonă, VPC endpoints, security groups în lanț și Flow Logs active.

Adresare: un /16 dintr-un plan de adrese al organizației, fără suprapuneri cu alte VPC-uri sau cu biroul. Subrețele dimensionate cu rezervă, mai ales pentru nivelul de aplicație dacă rulezi containere.

Subrețele în 3 zone (minimum 2):

  • publice: ALB, NAT gateway-uri; nimic altceva;
  • aplicație (private): instanțe EC2 în ASG sau task-uri ECS, cu ieșire prin NAT-ul din aceeași zonă;
  • date (private, izolate): RDS Multi-AZ, ElastiCache; fără rută spre internet.

Rutare: o tabelă publică cu 0.0.0.0/0 → IGW; câte o tabelă privată pe zonă pentru aplicație, cu NAT-ul local; tabela de date doar cu ruta locală și gateway endpoints.

Securitate:

  • security groups în lanț: sg-alb → sg-app → sg-db;
  • NACL-uri implicite sau simple, eventual un NACL pe nivelul de date care permite doar subrețelele de aplicație;
  • AWS WAF pe ALB;
  • acces administrativ prin Session Manager, fără bastion și fără port 22.

Conectivitate privată: gateway endpoints pentru S3 și DynamoDB; interface endpoints pentru ECR, CloudWatch Logs, Secrets Manager și SSM dacă vrei ca nivelul de aplicație să nu depindă de NAT.

Observabilitate: Flow Logs în S3, alarme pe metricile NAT gateway și ALB.

Reziliență: la căderea unei zone, ALB-ul nu mai trimite trafic acolo, ASG-ul pornește instanțe în zonele rămase, RDS face failover, iar fiecare zonă are propriul NAT. Capacitatea trebuie dimensionată ca zonele rămase să ducă încărcarea.

Totul e descris în IaC, ca mediul să poată fi recreat identic.

Ce urmărește intervievatorul: Verifică dacă poți integra componentele de rețea într-o arhitectură coerentă. Un senior menționează și capacitatea rămasă după căderea unei zone.

Eroarea, în practică:At least two subnets in two different AZs

RDS, Aurora și DynamoDB

65 Junior

Ce motoare de baze de date oferă Amazon RDS și ce nu poți face pe RDS față de o bază instalată de tine pe EC2?

Răspuns scurt: RDS oferă PostgreSQL, MySQL, MariaDB, Oracle, SQL Server, Db2 și Aurora (compatibil MySQL sau PostgreSQL). Nu ai acces SSH sau root la server, nu poți instala orice extensie sau plugin, iar parametrii motorului îi schimbi doar prin parameter groups, nu editând fișiere de configurare.

RDS preia operațiile de rutină: provizionarea, patch-urile, backup-urile automate, failover-ul Multi-AZ, monitorizarea de bază, scalarea stocării. Tu lucrezi cu un endpoint DNS și cu un utilizator administrator al bazei.

Ce pierzi în schimb:

  • acces la sistemul de operare: nu te poți conecta prin SSH, nu instalezi agenți proprii pe server, nu citești direct fișierele de date;
  • privilegii complete: utilizatorul principal nu e superuser complet (de exemplu, pe PostgreSQL ai rolul rds_superuser, nu superuser); unele comenzi administrative sunt înlocuite de proceduri stocate RDS;
  • extensii și plugin-uri: doar cele din lista suportată pentru versiunea respectivă;
  • configurare: parametrii se schimbă prin parameter groups, iar unii cer repornire; opțiunile speciale (de exemplu la Oracle sau SQL Server) prin option groups;
  • versiuni: doar versiunile suportate de RDS, cu un calendar de retragere pe care trebuie să-l urmărești.

Pentru cazurile care cer acces la sistem, există RDS Custom (pentru Oracle și SQL Server), unde ai acces la gazdă, dar și mai multă responsabilitate.

Când ai alege totuși o bază pe EC2: o versiune sau extensie pe care RDS nu o suportă, un motor care nu există în RDS, cerințe de tuning la nivel de sistem de operare. În rest, munca operațională economisită de RDS depășește de obicei restricțiile.

Ce urmărește intervievatorul: Verifică dacă știi limitele unui serviciu gestionat, nu doar avantajele. Greșeala tipică: candidatul presupune că poate face SSH pe instanța RDS.

66 Junior

Ce este un DB subnet group și de ce pui o bază RDS în subrețele private, cu opțiunea „Publicly accessible” dezactivată?

Răspuns scurt: E lista de subrețele, din cel puțin două zone, în care RDS plasează instanța și standby-ul Multi-AZ. Baza stă în subrețele private, fără IP public, ca să fie accesibilă doar din aplicație, prin security group.

La crearea unei baze RDS alegi un DB subnet group. RDS plasează instanța principală într-una dintre subrețele și, pentru Multi-AZ, standby-ul într-o subrețea din altă zonă. De aceea grupul trebuie să conțină subrețele din cel puțin două zone, chiar dacă la început nu activezi Multi-AZ.

Publicly accessible:

  • activat: endpoint-ul DNS se rezolvă din internet la un IP public, iar dacă subrețeaua are rută spre Internet Gateway și security group-ul permite, oricine poate încerca să se conecteze;
  • dezactivat: endpoint-ul se rezolvă doar la IP-ul privat, accesibil din VPC sau din rețele conectate.

De ce privat:

  • o bază expusă e ținta scanărilor automate pentru porturile 3306 și 5432 și a încercărilor de ghicire a parolei;
  • o vulnerabilitate a motorului devine exploatabilă de oriunde;
  • nu ai niciun motiv legitim ca utilizatorii finali să vorbească direct cu baza.

Accesul corect: security group-ul bazei acceptă portul doar din security group-ul aplicației. Pentru administrare de pe laptop, folosești Session Manager cu port forwarding printr-o instanță din VPC, EC2 Instance Connect Endpoint sau VPN, nu un IP public pe bază.

BASH
aws ssm start-session --target i-0abc \
  --document-name AWS-StartPortForwardingSessionToRemoteHost \
  --parameters host=app.xxxx.eu-central-1.rds.amazonaws.com,portNumber=5432,localPortNumber=5432

Ce urmărește intervievatorul: Verifică reflexele de securitate pentru date. Greșeala tipică: „Publicly accessible” activat ca să se conecteze ușor cu un client de pe laptop.

Eroarea, în practică:DBSubnetGroupDoesNotCoverEnoughAZsDBSubnetGroupNotFoundFault: not found

67 Junior

Care e diferența dintre backup-urile automate RDS și snapshot-urile manuale? Ce înseamnă point-in-time recovery?

Răspuns scurt: Backup-urile automate, zilnice plus logurile de tranzacții, permit restaurarea la orice moment din retenție (până la 35 de zile). Snapshot-urile manuale rămân până le ștergi. Restaurarea creează mereu o instanță nouă.

Backup-uri automate:

  • RDS face un snapshot zilnic în fereastra de backup și salvează continuu logurile de tranzacții;
  • perioada de retenție se configurează între 1 și 35 de zile (0 dezactivează backup-urile automate, nerecomandat);
  • permit point-in-time recovery (PITR): restaurezi baza la orice secundă din perioada de retenție, de obicei până la câteva minute înainte de momentul curent;
  • se șterg când expiră retenția și, implicit, când ștergi baza, dacă nu alegi să le păstrezi.

Snapshot-uri manuale:

  • le creezi tu, de exemplu înaintea unei migrări de schemă sau a unei actualizări de versiune;
  • rămân până le ștergi explicit, indiferent de baza sursă;
  • se pot copia în alte regiuni și partaja cu alte conturi, pentru recuperare după dezastre.

Restaurarea, din oricare variantă, creează o instanță nouă, cu endpoint nou. Aplicația trebuie apoi îndreptată spre ea, fie schimbând configurația, fie printr-un nume DNS propriu în Route 53. Asta trebuie exersat înainte de un incident real.

Protecții suplimentare:

  • deletion protection, care împiedică ștergerea bazei până nu o dezactivezi explicit;
  • snapshot final la ștergere;
  • AWS Backup pentru politici centralizate și copii în alt cont sau altă regiune.

Un backup netestat nu e un backup: programează restaurări periodice într-un mediu de test și verifică datele.

Ce urmărește intervievatorul: Verifică dacă știi cum recuperezi efectiv date. Mulți nu știu că restaurarea creează o instanță nouă cu alt endpoint.

Eroarea, în practică:FinalDBSnapshotIdentifier is requiredInvalidDBInstanceState: not in the available state

68 Junior

Ce este DynamoDB? Explică partition key, sort key și când îl alegi în loc de o bază relațională.

Răspuns scurt: O bază NoSQL cheie-valoare, gestionată și serverless. Partition key decide partiția itemului, sort key ordonează itemii cu aceeași partition key. O alegi când tiparele de acces sunt cunoscute și vrei scalare fără administrare, nu pentru interogări ad-hoc.

Modelul de date:

  • tabelă cu itemi (rânduri), fiecare item fiind o colecție de atribute; în afară de cheie, itemii pot avea atribute diferite;
  • cheia primară poate fi simplă (doar partition key) sau compusă (partition key + sort key);
  • partition key (cheia de hash): valoarea ei e trecută printr-o funcție hash care decide partiția fizică; toți itemii cu aceeași valoare stau împreună;
  • sort key (cheia de interval): ordonează itemii din aceeași partiție și permite condiții ca begins_with, between, >;
  • un item are cel mult 400 KB.

Exemplu pentru comenzi: partition key client_id, sort key data_comanda. Poți cere eficient „comenzile clientului c42 din octombrie 2026”, dar nu „toate comenzile peste 500 lei” fără un index sau o scanare.

Când DynamoDB:

  • tipare de acces cunoscute, bazate pe cheie: sesiuni, coșuri de cumpărături, profiluri, evenimente IoT, contoare;
  • trafic foarte variabil sau foarte mare, cu latență previzibilă;
  • aplicații serverless, unde conexiunile persistente la o bază relațională sunt incomode.

Când o bază relațională:

  • interogări ad-hoc, rapoarte, join-uri între multe entități;
  • tranzacții complexe și constrângeri de integritate referențială;
  • un model de date care se schimbă des și nu are încă tipare de acces clare.

DynamoDB suportă și tranzacții (TransactWriteItems), dar modelarea pornește mereu de la întrebările pe care aplicația le pune datelor.

Ce urmărește intervievatorul: Verifică dacă înțelegi modelul de date NoSQL și compromisurile lui. Greșeala tipică: proiectezi tabela ca într-o bază relațională și ajungi să scanezi.

69 Mid

Ce se întâmplă exact la un failover RDS Multi-AZ și ce trebuie să facă aplicația ca să-l suporte fără intervenție manuală?

Răspuns scurt: RDS promovează standby-ul sincron din altă zonă și mută înregistrarea DNS a endpoint-ului pe el, de obicei în una-două minute. Aplicația trebuie să reîncerce conexiunile căzute, să nu păstreze în cache IP-ul rezolvat mai mult decât TTL-ul DNS și să trateze tranzacțiile întrerupte.

În varianta clasică Multi-AZ instance, RDS ține un standby în altă zonă, cu replicare sincronă la nivel de stocare: o tranzacție e confirmată doar după ce e scrisă în ambele locuri. Standby-ul nu primește trafic de citire.

Failover-ul se declanșează la căderea instanței primare, a zonei sau a stocării, la schimbarea tipului de instanță, la anumite operații de mentenanță sau manual (reboot --force-failover, util pentru testare). Pașii:

  • standby-ul devine primar;
  • înregistrarea DNS a endpoint-ului (același nume) se schimbă spre noul primar;
  • conexiunile existente sunt întrerupte.

Ce trebuie să facă aplicația:

  • retry la erorile de conexiune, cu backoff, inclusiv în pool-ul de conexiuni;
  • TTL DNS respectat: JVM-ul, de exemplu, poate păstra în cache rezolvările DNS; o setare networkaddress.cache.ttl prea mare face aplicația să încerce IP-ul vechi;
  • tranzacțiile în curs sunt pierdute și trebuie reluate, deci operațiile trebuie să fie idempotente sau reluabile;
  • pool-ul de conexiuni validează conexiunile înainte de folosire.

RDS Proxy ajută: păstrează conexiunile aplicației deschise spre proxy și se reconectează el la noul primar, reducând timpul de indisponibilitate văzut de aplicație. Pentru failover și mai rapid există Multi-AZ DB cluster (două standby-uri care pot servi citiri) și Aurora.

Testează failover-ul periodic într-un mediu care seamănă cu producția: altfel descoperi problemele de reconectare chiar în timpul unui incident.

Ce urmărește intervievatorul: Verifică dacă înțelegi mecanismul și impactul asupra aplicației. Greșeala tipică: „Multi-AZ înseamnă zero downtime” fără nicio pregătire în aplicație.

70 Mid

Prin ce diferă Amazon Aurora de un RDS PostgreSQL sau MySQL clasic? Când merită?

Răspuns scurt: Aurora e compatibil MySQL sau PostgreSQL, dar are stocare distribuită cu 6 copii în 3 zone, care crește automat, până la 15 replici cu întârziere mică și failover rapid. Merită la încărcări mari sau critice.

Arhitectura: la RDS clasic, fiecare instanță are propriul volum EBS, iar replicile primesc modificările prin replicarea motorului. La Aurora, calculul e separat de stocare. Toate instanțele unui cluster citesc din același volum distribuit, care păstrează 6 copii ale datelor în 3 zone de disponibilitate și tolerează pierderea unor copii fără impact asupra scrierilor.

Consecințe:

  • replici de citire (până la 15) cu întârziere de replicare mică, pentru că nu copiază datele, ci citesc din aceeași stocare;
  • failover rapid: o replică devine primar fără să aștepte copierea datelor;
  • stocarea crește automat, fără să o dimensionezi dinainte;
  • endpoint-uri separate: cluster endpoint pentru scrieri, reader endpoint care distribuie citirile pe replici;
  • funcționalități proprii: Aurora Serverless v2 (capacitate care se ajustează automat), Global Database (replicare între regiuni cu întârziere mică), clonare rapidă, backtrack (doar pentru varianta MySQL).

Când nu merită:

  • baze mici, cu trafic redus, unde costul minim al Aurora și modelul de taxare pe I/O (sau varianta I/O-Optimized) nu se justifică;
  • când ai nevoie de o extensie sau de o versiune pe care Aurora nu o suportă încă;
  • când vrei portabilitate perfectă: Aurora e compatibil la nivel de protocol și SQL, dar comportamentul de performanță și unele funcții diferă.

Decizia se ia măsurând: rulezi încărcarea reală pe ambele și compari performanța și costul în Pricing Calculator.

Ce urmărește intervievatorul: Verifică dacă știi ce aduce Aurora concret, nu doar „e mai rapid”. Un candidat bun explică separarea calculului de stocare.

71 Mid

Unde ții parola bazei de date pentru o aplicație care rulează pe EC2 sau Lambda și cum o rotești fără întrerupere?

Răspuns scurt: În Secrets Manager (sau Parameter Store ca SecureString), citită prin rolul IAM al aplicației. Secrets Manager rotește automat parola RDS, iar aplicația recitește secretul la eroare. Alternativ, autentificare IAM la bază, cu tokenuri temporare.

Ce nu faci: parola în codul sursă, în fișiere din Git, în user data sau în variabile de mediu Lambda în clar vizibile în consolă pentru oricine are acces de citire la funcție.

Secrets Manager:

  • secretul e criptat cu KMS, iar accesul se controlează prin IAM (secretsmanager:GetSecretValue doar pentru rolul aplicației);
  • RDS se poate integra direct: opțiunea „Manage master credentials in Secrets Manager” creează și rotește automat parola utilizatorului principal;
  • pentru utilizatorii aplicației, rotația rulează printr-o funcție Lambda; strategia alternating users păstrează doi utilizatori și schimbă alternativ parola unuia, astfel încât credențialele vechi rămân valabile până se termină rotația;
  • aplicația citește secretul la pornire și îl ține în cache; la o eroare de autentificare, îl recitește și reîncearcă. AWS oferă biblioteci de cache pentru mai multe limbaje.

Parameter Store (SecureString): mai simplu, bun pentru configurații și secrete fără rotație automată.

IAM database authentication (MySQL și PostgreSQL pe RDS și Aurora): aplicația cere un token de autentificare semnat cu credențialele rolului, valabil 15 minute, și îl folosește ca parolă prin TLS. Nu există nicio parolă de stocat. Are limitări de rată pentru conexiuni noi, deci se potrivește cu un pool de conexiuni sau cu RDS Proxy.

În plus, impui TLS la conexiune și dai utilizatorului aplicației doar drepturile necesare în bază, nu pe cele ale utilizatorului principal.

Ce urmărește intervievatorul: Verifică practicile de gestionare a secretelor. Răspunsul slab: „în variabile de mediu”, fără control al accesului sau rotație.

72 Mid

Codul de mai jos funcționează, dar devine lent și scump pe măsură ce tabela crește. De ce și cum îl rescrii?

PYTHON
import boto3
from boto3.dynamodb.conditions import Attr

tabela = boto3.resource("dynamodb").Table("Comenzi")

def comenzi_client(client_id):
    r = tabela.scan(FilterExpression=Attr("client_id").eq(client_id))
    return r["Items"]

Răspuns scurt: scan citește toată tabela și abia apoi filtrează, deci plătești pentru toți itemii, iar fără paginare pierzi rezultatele de după primul 1 MB. Cu client_id ca partition key folosești query cu paginare.

Problemele codului:

  • Scan parcurge fiecare item din tabelă. FilterExpression se aplică după citire, deci reduce doar ce primești, nu ce plătești. Costul și timpul cresc liniar cu tabela, nu cu numărul de comenzi ale clientului.
  • Paginarea lipsește: un singur apel întoarce cel mult 1 MB de date citite. Dacă există mai multe, răspunsul conține LastEvaluatedKey, iar codul de mai sus ignoră restul, deci întoarce rezultate incomplete fără eroare.

Varianta corectă, cu client_id ca partition key și data_comanda ca sort key:

PYTHON
from boto3.dynamodb.conditions import Key

def comenzi_client(client_id, luna=None):
    cond = Key("client_id").eq(client_id)
    if luna:
        cond = cond & Key("data_comanda").begins_with(luna)  # de ex. "2026-10"
    itemi, kwargs = [], {"KeyConditionExpression": cond}
    while True:
        r = tabela.query(**kwargs)
        itemi.extend(r["Items"])
        if "LastEvaluatedKey" not in r:
            return itemi
        kwargs["ExclusiveStartKey"] = r["LastEvaluatedKey"]

query merge direct la partiția clientului și citește doar itemii lui, în ordinea sort key-ului (ScanIndexForward=False pentru ordine descrescătoare).

Dacă client_id nu e cheia tabelei, creezi un global secondary index cu client_id ca partition key și interoghezi indexul cu IndexName.

scan rămâne potrivit pentru exporturi, migrări sau joburi rare; pentru tabele mari, cu scanare paralelă (Segment, TotalSegments) sau, mai bine, cu exportul în S3.

Ce urmărește intervievatorul: E o întrebare clasică de cod pentru DynamoDB. Intervievatorul vrea să audă că filtrul nu reduce costul și că lipsește paginarea.

73 Senior

Explică diferența dintre capacitatea on-demand și provisioned în DynamoDB, ce sunt partițiile „fierbinți” și cum folosești GSI și LSI.

Răspuns scurt: On-demand taxează per cerere și se adaptează singur; provisioned cere capacitate setată, cu auto scaling, mai ieftină la trafic stabil. Partiția fierbinte primește trafic disproporționat pe o cheie. GSI are altă cheie, LSI păstrează partition key.

Moduri de capacitate:

  • On-demand: plătești per cerere de citire și scriere; tabela se adaptează la trafic fără configurare. Potrivit pentru trafic imprevizibil, aplicații noi, medii de test.
  • Provisioned: setezi unități de capacitate de citire (RCU) și scriere (WCU), cu auto scaling după o țintă de utilizare; poți cumpăra capacitate rezervată. Mai ieftin pentru trafic constant și previzibil. Peste capacitate primești ProvisionedThroughputExceededException.
  • Poți schimba modul de câteva ori pe zi, deci nu e o decizie definitivă.

Partiții fierbinți: datele sunt împărțite în partiții după hash-ul partition key, iar fiecare partiție are o limită de throughput. Dacă un singur client_id sau o singură dată (de exemplu cheia 2026-10-31) primește majoritatea scrierilor, acea partiție devine gâtul de sticlă, indiferent de capacitatea totală. Adaptive capacity compensează parțial, dar soluția e modelarea: chei cu cardinalitate mare, sau write sharding (sufix aleator sau calculat, de exemplu 2026-10-31#7), cu agregare la citire.

Indexuri secundare:

  • GSI (global): partition key și sort key diferite de tabelă; se poate adăuga oricând; are capacitate proprie (în provisioned); citirile sunt doar eventual consistente. Dacă un GSI nu are capacitate suficientă, poate frâna scrierile în tabelă.
  • LSI (local): aceeași partition key, sort key diferită; se definește doar la crearea tabelei; permite citiri puternic consistente; limitează mărimea totală a itemilor cu aceeași partition key la 10 GB.

Proiectezi atributele proiectate în index (KEYS_ONLY, INCLUDE, ALL) ca să nu plătești stocare și scrieri inutile.

Ce urmărește intervievatorul: Verifică experiența cu DynamoDB în producție. Un senior știe că un GSI subdimensionat poate frâna scrierile în tabela de bază.

74 Senior

Proiectează o tabelă DynamoDB pentru un magazin online care trebuie să afișeze: comenzile unui client ordonate după dată, detaliile unei comenzi cu produsele ei și comenzile aflate într-o anumită stare. Cum gândești modelarea?

Răspuns scurt: Pornești de la tiparele de acces, nu de la entități. Un design single-table folosește chei generice (PK, SK): CLIENT#id cu COMANDA#data#id pentru lista clientului, COMANDA#id cu PRODUS#id pentru detalii, și un GSI pe stare și dată pentru comenzile dintr-o stare.

În DynamoDB nu există join-uri, așa că pui împreună datele pe care le citești împreună. Pașii:

  • Listezi tiparele de acces cu frecvența lor: comenzile unui client (des), o comandă cu produsele (des), comenzile „în livrare” (pentru depozit, periodic).
  • Alegi cheile ca fiecare tipar să fie un GetItem sau un Query.
PK                SK                              Atribute
CLIENT#c42        PROFIL                          nume, email
CLIENT#c42        COMANDA#2026-10-30#o981         total, stare
COMANDA#o981      DETALII                         adresa, client_id, stare
COMANDA#o981      PRODUS#p17                      cantitate, pret
COMANDA#o981      PRODUS#p23                      cantitate, pret

GSI1: GSI1PK = STARE#in_livrare, GSI1SK = 2026-10-30#o981
  • comenzile clientului: Query PK = CLIENT#c42 AND begins_with(SK, "COMANDA#"), cu ordine descrescătoare;
  • comanda cu produsele: Query PK = COMANDA#o981, un singur apel;
  • comenzile într-o stare: Query pe GSI1 cu GSI1PK = STARE#in_livrare. Pentru că o stare poate concentra multe comenzi, la volume mari adaugi sharding în cheia GSI.

Compromisuri de discutat:

  • denormalizare: starea comenzii apare în două itemi; la schimbare le actualizezi împreună cu TransactWriteItems;
  • sparse index: atributele GSI1PK există doar pe itemii care trebuie indexați, deci indexul rămâne mic;
  • rapoarte ad-hoc (vânzări pe categorie, pe lună) nu se fac din DynamoDB: exporți în S3 și interoghezi cu Athena, sau trimiți fluxul DynamoDB Streams într-un depozit analitic.

Single-table nu e obligatoriu: mai multe tabele sunt acceptabile când tiparele nu se intersectează. Important e ca fiecare acces frecvent să fie servit de o cheie.

Ce urmărește intervievatorul: Verifică dacă știi să modelezi pornind de la tiparele de acces. Greșeala tipică: o tabelă per entitate, ca în SQL, cu multe apeluri pentru o singură pagină.

Lambda, API Gateway, SQS și SNS

75 Junior

Ce este AWS Lambda, cum se taxează și ce limite importante are?

Răspuns scurt: Lambda rulează cod declanșat de evenimente, fără servere de administrat. Plătești invocările și durata înmulțită cu memoria. Limite: 15 minute pe invocare, memorie între 128 MB și 10 240 MB, CPU proporțional cu memoria.

Încarci codul (arhivă zip sau imagine de container), alegi runtime-ul (Python, Node.js, Java, .NET, Ruby sau un runtime propriu) și configurezi ce declanșează funcția: API Gateway, S3, SQS, EventBridge, DynamoDB Streams și multe altele. AWS pornește medii de execuție la cerere și le scalează automat.

Taxarea are două componente: numărul de cereri și durata, măsurată în GB-secunde (memoria configurată înmulțită cu timpul de execuție, rotunjit la milisecundă). Există și un nivel gratuit lunar. Consecință: o funcție care așteaptă după un API lent plătește timp de așteptare.

Limite importante:

  • timeout maxim de 15 minute; joburile mai lungi merg pe Fargate, Batch sau Step Functions care împart lucrul;
  • memorie configurabilă între 128 MB și 10 240 MB; CPU-ul se alocă proporțional cu memoria, deci uneori mai multă memorie înseamnă o funcție mai rapidă și chiar mai ieftină;
  • spațiu temporar /tmp configurabil între 512 MB și 10 GB, care nu persistă între medii de execuție;
  • dimensiune maximă a payload-ului pentru invocări sincrone (de ordinul câtorva MB), deci fișierele mari trec prin S3;
  • limite de concurență pe cont și regiune.

Funcțiile trebuie să fie stateless: un mediu de execuție poate fi refolosit pentru invocări succesive, dar nu ai nicio garanție. Starea durabilă stă în DynamoDB, S3 sau altă bază.

Lambda se potrivește pentru trafic variabil, procesare de evenimente și integrări; pentru încărcări constante și mari, containerele pot fi mai economice.

Ce urmărește intervievatorul: Verifică înțelegerea modelului serverless și a limitelor lui. Mulți nu știu că CPU-ul depinde de memoria configurată.

Eroarea, în practică:Task timed out after 3.00 secondsmemorySize must be greater than or equal to 128

76 Junior

Scrie o funcție Lambda în Python, declanșată de încărcarea unui fișier în S3, care afișează în log numele bucketului, cheia și dimensiunea fișierului. Ce capcană are cheia primită în eveniment?

Răspuns scurt: Handler-ul parcurge event["Records"] și citește s3.bucket.name, s3.object.key și s3.object.size. Capcana: cheia vine URL-encoded (un spațiu apare ca +), deci o decodezi cu urllib.parse.unquote_plus înainte să o folosești la get_object.

PYTHON
import json
import urllib.parse
import boto3

s3 = boto3.client("s3")  # creat o singură dată, refolosit între invocări

def lambda_handler(event, context):
    for record in event["Records"]:
        bucket = record["s3"]["bucket"]["name"]
        cheie = urllib.parse.unquote_plus(record["s3"]["object"]["key"])
        marime = record["s3"]["object"].get("size", 0)
        print(json.dumps({"bucket": bucket, "cheie": cheie, "marime": marime}))
        # exemplu de citire:
        # obiect = s3.get_object(Bucket=bucket, Key=cheie)
    return {"procesate": len(event["Records"])}

Detalii importante:

  • un eveniment poate conține mai multe înregistrări, de aceea parcurgi lista;
  • cheia e URL-encoded: facturi/oct 2026.pdf sosește ca facturi/oct+2026.pdf; fără decodare, get_object dă NoSuchKey;
  • clientul boto3 e creat în afara handler-ului, ca să fie refolosit în invocările care nimeresc același mediu de execuție;
  • print ajunge în CloudWatch Logs; JSON pe un singur rând se interoghează ușor cu Logs Insights.

Capcane de configurare:

  • buclă infinită: dacă funcția scrie rezultatul înapoi în același bucket, pe un prefix care declanșează din nou evenimentul, se apelează singură la nesfârșit și generează costuri. Filtrezi notificarea pe prefix sau sufix (de exemplu doar incarcari/ și .jpg) și scrii rezultatul în alt prefix sau alt bucket;
  • invocarea din S3 e asincronă: în caz de eroare, Lambda reîncearcă, deci procesarea trebuie să fie idempotentă;
  • rolul de execuție are nevoie de s3:GetObject pe bucket, iar S3 de permisiunea de a invoca funcția (o politică pe resursa Lambda, creată automat de consolă).

Ce urmărește intervievatorul: E o întrebare practică de cod serverless. Decodarea cheii și bucla infinită sunt cele două capcane pe care intervievatorul le caută.

77 Junior

Ce este rolul de execuție al unei funcții Lambda și de ce o funcție nouă nu scrie nimic în CloudWatch Logs?

Răspuns scurt: Rolul de execuție e rolul IAM pe care Lambda îl preia când rulează funcția; codul primește permisiunile lui. Ca să scrie loguri, rolul are nevoie de logs:CreateLogGroup, logs:CreateLogStream și logs:PutLogEvents, de obicei prin politica AWSLambdaBasicExecutionRole; dacă lipsesc, logurile se pierd fără eroare vizibilă în funcție.

Funcția nu are credențiale proprii. La fiecare mediu de execuție, Lambda preia rolul configurat și pune credențialele temporare în variabilele de mediu AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, AWS_SESSION_TOKEN. SDK-ul le găsește automat.

Trust policy a rolului trebuie să permită principalul lambda.amazonaws.com. Politica de permisiuni conține exact ce face codul, de exemplu:

JSON
{
  "Version": "2012-10-17",
  "Statement": [
    {"Effect": "Allow",
     "Action": ["logs:CreateLogGroup", "logs:CreateLogStream", "logs:PutLogEvents"],
     "Resource": "arn:aws:logs:eu-central-1:123456789012:*"},
    {"Effect": "Allow",
     "Action": ["dynamodb:PutItem"],
     "Resource": "arn:aws:dynamodb:eu-central-1:123456789012:table/Comenzi"}
  ]
}

Dacă rolul nu are drepturile de logging, funcția rulează, dar grupul /aws/lambda/<nume> nu apare sau rămâne gol. Consola le adaugă automat la crearea unui rol nou; în IaC trebuie incluse explicit.

Alte politici gestionate utile: AWSLambdaVPCAccessExecutionRole (pentru funcții în VPC, care trebuie să creeze interfețe de rețea), AWSLambdaSQSQueueExecutionRole (pentru citire din SQS).

Distincția importantă: rolul de execuție spune ce poate face funcția; politica pe resursa funcției spune cine o poate invoca (de exemplu API Gateway sau S3). O eroare AccessDenied în loguri ține de primul; o funcție care nu e invocată deloc ține adesea de al doilea.

Un rol pentru fiecare funcție, cu privilegii minime, limitează impactul unei funcții compromise.

Ce urmărește intervievatorul: Verifică dacă înțelegi permisiunile în serverless. Confuzia dintre rolul de execuție și politica de invocare apare des.

Eroarea, în practică:The role defined for the function cannot be assumedThe specified log group does not exist

78 Junior

Scrie o funcție Lambda în Python pentru un API HTTP din API Gateway, care la GET /comenzi/{id} întoarce JSON. Ce format trebuie să aibă răspunsul?

Răspuns scurt: Cu integrarea proxy, funcția primește tot request-ul în event (parametrii de path în event["pathParameters"]) și întoarce un dicționar cu statusCode, headers și body ca șir de caractere, de obicei produs cu json.dumps.

PYTHON
import json

COMENZI = {"o981": {"id": "o981", "total": 249.90, "stare": "in_livrare"}}

def raspuns(cod, date):
    return {
        "statusCode": cod,
        "headers": {"Content-Type": "application/json"},
        "body": json.dumps(date),
    }

def lambda_handler(event, context):
    metoda = event["requestContext"]["http"]["method"]   # format payload 2.0
    id_comanda = (event.get("pathParameters") or {}).get("id")
    if metoda != "GET" or not id_comanda:
        return raspuns(400, {"eroare": "cerere invalidă"})
    comanda = COMENZI.get(id_comanda)
    if comanda is None:
        return raspuns(404, {"eroare": "comanda nu există"})
    return raspuns(200, comanda)

Ruta în API Gateway este GET /comenzi/{id}, cu integrare Lambda. Cu HTTP API și formatul de payload 2.0, metoda e în requestContext.http.method și path-ul în rawPath; la REST API (format 1.0) găsești httpMethod și path. Dacă amesteci formatele, codul primește KeyError.

Reguli ale integrării proxy:

  • body trebuie să fie string; un dicționar acolo produce eroare 502 la client;
  • dacă funcția aruncă excepție sau întoarce un format greșit, API Gateway răspunde cu 502, iar cauza o vezi în logurile funcției;
  • corpul cererii vine ca string în event["body"], eventual codat Base64 (isBase64Encoded).

HTTP API vs REST API: HTTP API e mai simplu, mai ieftin și cu latență mai mică, cu autorizare JWT și CORS integrate. REST API are în plus chei de API cu planuri de utilizare, validarea cererilor, transformări, cache și integrare directă cu AWS WAF. Pentru un API nou, simplu, HTTP API e de obicei suficient.

Ce urmărește intervievatorul: Verifică dacă ai construit efectiv un API serverless. Un body care nu e string, cu eroarea 502 rezultată, e o greșeală foarte des întâlnită.

Eroarea, în practică:API Gateway: {"message":"Internal Server Error"}

79 Junior

Care e diferența dintre Amazon SQS și Amazon SNS? Ce înseamnă tiparul fan-out?

Răspuns scurt: SQS e o coadă: mesajele așteaptă până le citește și le șterge un consumator. SNS e publish/subscribe: mesajul ajunge imediat la toți abonații. Fan-out înseamnă un topic SNS cu mai multe cozi SQS abonate.

SQS (Simple Queue Service) — model pull:

  • producătorul trimite mesajul, iar acesta stă în coadă până îl citește un consumator (implicit 4 zile, maximum 14);
  • consumatorul citește, procesează, apoi șterge mesajul; dacă nu îl șterge, mesajul redevine vizibil și e reluat;
  • decuplează ritmul producătorului de cel al consumatorului și absoarbe vârfurile;
  • tipuri: Standard (throughput practic nelimitat, livrare cel puțin o dată, ordinea nu e garantată) și FIFO (ordine strictă în cadrul unui grup de mesaje, deduplicare).

SNS (Simple Notification Service) — model push:

  • publici un mesaj într-un topic, iar SNS îl livrează imediat tuturor abonaților: cozi SQS, funcții Lambda, endpoint-uri HTTP(S), email, SMS, notificări mobile;
  • nu păstrează mesajele: dacă un abonat HTTP nu e disponibil, SNS reîncearcă după o politică, apoi poate trimite mesajul într-o coadă DLQ;
  • filtrarea mesajelor permite fiecărui abonat să primească doar mesajele care îl interesează, după atribute sau conținut.

Fan-out: evenimentul „comandă plasată” e publicat o dată într-un topic SNS. Trei cozi SQS sunt abonate: facturare, depozit, email de confirmare. Fiecare serviciu își consumă coada în ritmul lui; dacă serviciul de email e căzut o oră, mesajele lui așteaptă în coadă, fără să afecteze celelalte servicii.

Pentru rutare mai bogată pe evenimente (reguli după conținut, multe surse și ținte, integrare cu servicii SaaS), EventBridge este alternativa.

Ce urmărește intervievatorul: Verifică dacă înțelegi diferența dintre push și pull și cum se combină. Greșeala tipică: SNS folosit ca o coadă care păstrează mesajele.

80 Mid

Ce este un cold start în Lambda, ce îl influențează și cum îl reduci?

Răspuns scurt: Întârzierea primei invocări pe un mediu nou: pornirea mediului, descărcarea codului, a runtime-ului și inițializarea. Depinde de runtime, pachet și cod de inițializare; o reduci cu pachete mici, provisioned concurrency sau SnapStart.

Când nu există un mediu de execuție liber, Lambda creează unul nou. Etapele:

  • alocarea mediului și descărcarea codului (zip sau imagine de container);
  • pornirea runtime-ului (interpretorul Python, JVM-ul);
  • rularea codului de inițializare, adică tot ce e în afara handler-ului: importuri, clienți SDK, conexiuni.

Invocările următoare care nimeresc același mediu sunt „calde” și sar peste acești pași. Când traficul crește, apar medii noi, deci cold start-urile apar și la scalare, nu doar după perioade de inactivitate.

Ce îl influențează:

  • runtime-ul: Java și .NET au porniri mai lente decât Python sau Node.js, mai ales cu framework-uri grele;
  • dimensiunea pachetului și numărul de dependențe încărcate la import;
  • memoria: mai multă memorie înseamnă mai mult CPU, deci inițializare mai rapidă.

Cum îl reduci:

  • elimini dependențele inutile și imporți doar ce folosești;
  • creezi clienții SDK o singură dată, în afara handler-ului, dar amâni inițializările grele de care nu are nevoie fiecare invocare;
  • provisioned concurrency: ții un număr de medii inițializate permanent, cu cost suplimentar; se poate programa după orele de vârf;
  • SnapStart: Lambda face un snapshot al mediului inițializat și pornește din el; disponibil inițial pentru Java și extins ulterior la Python și .NET, pe versiuni recente de runtime;
  • pentru Java, framework-uri gândite pentru pornire rapidă sau compilare nativă.

Pentru multe aplicații, cold start-ul afectează doar un procent mic de cereri. Măsoară întâi: câmpul Init Duration din rândul REPORT al logurilor arată durata exactă.

Ce urmărește intervievatorul: Verifică înțelegerea ciclului de viață al unei funcții. Candidații slabi propun „un ping la 5 minute”, care nu rezolvă cold start-urile la scalare.

81 Mid

Ce înseamnă concurrency în Lambda? Explică reserved și provisioned concurrency și ce se întâmplă când o funcție e limitată (throttled).

Răspuns scurt: Numărul de invocări simultane, limitat pe cont și regiune (implicit 1 000). Reserved concurrency garantează și plafonează o funcție, provisioned ține medii pregătite. Peste limită, invocările sincrone primesc 429, cele asincrone sunt reîncercate.

Aproximativ, concurența necesară este cereri pe secundă × durata medie în secunde. O funcție care durează 200 ms la 500 de cereri pe secundă are nevoie de aproximativ 100 de medii simultane.

Limita de cont: toate funcțiile din cont și regiune împart o limită comună, implicit 1 000 (conturile noi pot porni cu mai puțin). Se poate mări prin Service Quotas. Există și o limită de cât de repede poate crește concurența unei funcții.

Reserved concurrency pe o funcție:

  • îi rezervă o parte din limita contului, ca alte funcții să nu o poată consuma;
  • e și un plafon: funcția nu poate depăși valoarea. Util pentru a proteja o bază de date care acceptă puține conexiuni sau un API terț cu limită de rată;
  • setată la 0, oprește complet funcția, un „întrerupător” util într-un incident.

Provisioned concurrency: un număr de medii pre-inițializate, fără cold start, cu cost suplimentar. Se configurează pe o versiune sau un alias.

Throttling, când nu mai e concurență disponibilă:

  • invocări sincrone (API Gateway): eroare 429 TooManyRequestsException; clientul trebuie să reîncerce;
  • invocări asincrone (S3, SNS): Lambda pune evenimentul înapoi în coada internă și reîncearcă o perioadă;
  • SQS cu event source mapping: mesajele rămân în coadă, iar poller-ul încetinește.

Metricile ConcurrentExecutions și Throttles din CloudWatch arată problema. O alarmă pe Throttles e una dintre primele pe care le configurezi pentru o funcție critică.

Ce urmărește intervievatorul: Verifică dacă știi să dimensionezi și să protejezi sistemele serverless. Folosirea reserved concurrency ca plafon pentru a proteja baza de date este un semn de experiență.

82 Mid

Scrie un consumator Python care citește mesaje dintr-o coadă SQS Standard. Explică visibility timeout, long polling și dead-letter queue.

Răspuns scurt: Consumatorul apelează receive_message cu WaitTimeSeconds=20 (long polling), procesează fiecare mesaj și îl șterge cu delete_message doar după succes. Visibility timeout ascunde mesajul cât timp e procesat; dacă nu e șters, reapare. După maxReceiveCount eșecuri, mesajul merge în dead-letter queue.

PYTHON
import json
import boto3

sqs = boto3.client("sqs")
URL = "https://sqs.eu-central-1.amazonaws.com/123456789012/comenzi"

def proceseaza(comanda):
    print("procesez", comanda["id"])   # trebuie să fie idempotent

while True:
    r = sqs.receive_message(QueueUrl=URL, MaxNumberOfMessages=10,
                            WaitTimeSeconds=20, VisibilityTimeout=60)
    for m in r.get("Messages", []):
        try:
            proceseaza(json.loads(m["Body"]))
            sqs.delete_message(QueueUrl=URL, ReceiptHandle=m["ReceiptHandle"])
        except Exception as e:
            print("eșec, mesajul va reapărea:", e)

Visibility timeout: după ce un consumator primește mesajul, SQS îl ascunde de ceilalți pentru perioada respectivă (implicit 30 de secunde). Dacă mesajul nu e șters în acest timp, redevine vizibil și e livrat din nou. Trebuie să fie mai mare decât durata maximă de procesare; pentru joburi lungi, consumatorul îl prelungește cu change_message_visibility.

Long polling (WaitTimeSeconds până la 20): apelul așteaptă până apar mesaje, în loc să întoarcă imediat un răspuns gol. Reduce numărul de apeluri, deci costul, și răspunsurile goale.

Dead-letter queue: în redrive policy setezi coada DLQ și maxReceiveCount, de exemplu 5. Un mesaj care eșuează de 5 ori e mutat acolo, ca să nu blocheze sau să consume resurse la nesfârșit. Pui o alarmă pe numărul de mesaje din DLQ și, după corectarea bug-ului, folosești redrive ca să le trimiți înapoi în coada sursă.

Pentru că SQS Standard livrează cel puțin o dată, același mesaj poate ajunge de două ori; procesarea trebuie să fie idempotentă, de exemplu cu o cheie unică salvată condiționat într-o bază.

Ce urmărește intervievatorul: Verifică experiența practică cu cozile. Ștergerea mesajului înainte de procesare și lipsa idempotenței sunt greșelile clasice.

83 Senior

Explică cum tratează Lambda erorile pentru invocările sincrone, asincrone și pentru event source mappings (SQS, DynamoDB Streams). Cum eviți pierderea sau procesarea dublă a evenimentelor?

Răspuns scurt: Sincron, eroarea ajunge la apelant. Asincron, Lambda reîncearcă de două ori implicit, apoi trimite la o destinație on-failure sau DLQ. La event source mappings, reîncearcă până la succes sau expirare. Ai nevoie mereu de idempotență.

Sincron (API Gateway, apel direct RequestResponse): Lambda nu reîncearcă. Clientul primește eroarea și decide. SDK-urile reîncearcă unele erori, deci și aici pot apărea execuții duble.

Asincron (S3, SNS, EventBridge, InvocationType=Event): evenimentul intră într-o coadă internă. La eroare, Lambda reîncearcă de două ori implicit, cu pauze. Configurezi numărul de reîncercări (0–2) și vârsta maximă a evenimentului (până la 6 ore). După epuizare, evenimentul merge la o destinație on-failure (SQS, SNS, EventBridge, altă Lambda), care primește și detaliile erorii, sau la o DLQ. Fără ele, evenimentul se pierde.

Event source mapping:

  • SQS: poller-ul citește loturi; dacă funcția eșuează, mesajele redevin vizibile după visibility timeout, iar redrive policy a cozii le mută în DLQ după maxReceiveCount. Cu ReportBatchItemFailures, funcția raportează doar mesajele eșuate, iar cele reușite nu mai sunt reprocesate.
  • Kinesis și DynamoDB Streams: ordinea pe shard contează, deci un lot eșuat e reîncercat până reușește sau expiră, blocând shard-ul. Setezi MaximumRetryAttempts, MaximumRecordAgeInSeconds, BisectBatchOnFunctionError (împarte lotul ca să izoleze înregistrarea defectă) și o destinație on-failure.

Idempotență, pentru că toate sursele pot livra de mai multe ori:

  • o cheie de idempotență (ID-ul mesajului sau al comenzii), scrisă cu PutItem condiționat (attribute_not_exists) în DynamoDB înaintea efectului;
  • utilitarul Idempotency din Powertools for AWS Lambda implementează acest tipar;
  • operațiile externe (plăți, emailuri) primesc aceeași cheie, dacă API-ul lor o suportă.

Alarmele pe DLQ și pe IteratorAge (pentru streamuri) îți arată când evenimentele se acumulează.

Ce urmărește intervievatorul: Verifică dacă înțelegi semantica de livrare în sisteme distribuite. Un senior știe că un singur mesaj defect poate bloca un shard întreg.

Eroarea, în practică:Lambda: "FunctionError": "Unhandled"

84 Senior

Un API sincron primește comenzi și apelează imediat trei servicii lente (plăți, stoc, email). La vârfuri apar timeout-uri și comenzi pierdute. Cum redesenezi fluxul cu servicii AWS?

Răspuns scurt: Separi primirea de procesare: API-ul validează, salvează comanda și întoarce imediat 202 Accepted, apoi publică un eveniment. Procesarea se face asincron prin SQS (sau SNS/EventBridge cu fan-out), cu reîncercări, DLQ și idempotență, iar pașii dependenți se orchestrează cu Step Functions.

Problema fluxului sincron: latența cererii e suma celor trei apeluri, iar oricare dintre ele, dacă e lent sau căzut, strică toată comanda. La vârfuri, serviciile din spate sunt copleșite exact când contează mai mult.

Arhitectura propusă:

  • API Gateway + Lambda primesc comanda, o validează și o scriu în DynamoDB cu starea primita, folosind o cheie de idempotență trimisă de client, ca o reîncercare a clientului să nu creeze o comandă dublă;
  • răspunsul este 202 Accepted cu ID-ul comenzii; clientul urmărește starea prin polling, WebSocket sau notificare;
  • un eveniment ComandaPrimita ajunge în EventBridge sau SNS (direct din cod sau prin DynamoDB Streams, ca evenimentul să nu se piardă dacă publicarea eșuează după scriere — tiparul transactional outbox);
  • fiecare serviciu are propria coadă SQS, cu DLQ și alarmă; workerii consumă în ritmul lor, iar reserved concurrency limitează presiunea asupra serviciilor fragile.

Orchestrare: dacă pașii depind unul de altul (rezervi stocul, apoi încasezi, apoi trimiți emailul, iar la o plată eșuată eliberezi stocul), un Step Functions state machine descrie fluxul, cu reîncercări per pas și pași de compensare (tiparul saga). Tranzacțiile distribuite clasice nu există aici.

Compromisuri de discutat cu echipa:

  • consistență eventuală: clientul vede „în procesare”, nu rezultatul final;
  • ordinea mesajelor nu e garantată în SQS Standard; dacă e necesară, SQS FIFO cu MessageGroupId pe comandă;
  • observabilitate: un ID de corelare propagat prin toate mesajele și trasare cu X-Ray.

Rezultatul: API-ul răspunde rapid și constant, iar vârfurile devin cozi care se golesc, nu erori.

Ce urmărește intervievatorul: Verifică gândirea de arhitectură distribuită. Un senior menționează idempotența, outbox-ul și compensările, nu doar „pun o coadă”.

CloudWatch, CloudFormation și costuri

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

Ce metrici trimite EC2 implicit în CloudWatch și de ce nu vezi utilizarea memoriei sau a discului?

Răspuns scurt: CPU, rețea, operații pe disc și status checks, de la hypervisor, la 5 minute (1 minut cu monitorizare detaliată). Memoria și spațiul pe disc se văd doar din sistemul de operare, deci instalezi CloudWatch agent.

O metrică CloudWatch e definită de namespace (de exemplu AWS/EC2), nume (CPUUtilization) și dimensiuni (InstanceId=i-0abc). Statisticile (Average, Maximum, Sum, percentile) se calculează pe o perioadă.

Implicit, pentru EC2 primești, fără cost suplimentar, la 5 minute:

  • CPUUtilization;
  • NetworkIn, NetworkOut, pachete;
  • DiskReadOps și altele pentru instance store, iar pentru EBS metrici în namespace-ul AWS/EBS;
  • StatusCheckFailed_System și StatusCheckFailed_Instance;
  • CPUCreditBalance pentru instanțele burstable.

Monitorizarea detaliată le trimite la 1 minut, contra cost, util pentru scalare mai rapidă.

Memoria, spațiul pe disc, procesele țin de sistemul de operare, pe care hypervisorul nu îl vede. Pentru ele instalezi CloudWatch agent (prin SSM, în AMI sau din user data), cu o configurație care alege metricile (mem_used_percent, disk_used_percent) și fișierele de log de trimis. Agentul are nevoie de un rol cu CloudWatchAgentServerPolicy. Metricile personalizate se taxează.

Aplicațiile pot publica propriile metrici cu PutMetricData sau, mai eficient, prin Embedded Metric Format: scrii în log un JSON cu structură specială, iar CloudWatch extrage metricile din el, fără apeluri API suplimentare.

Serviciile gestionate (RDS, Lambda, ALB, SQS) au metricile lor detaliate, inclusiv memoria pentru RDS (FreeableMemory).

Ce urmărește intervievatorul: Verifică dacă știi ce vede CloudWatch fără configurare. Mulți presupun că memoria EC2 apare automat.

86 Junior

Scrie comanda AWS CLI care creează o alarmă CloudWatch: dacă CPU-ul unei instanțe depășește 80% în medie timp de 10 minute, se trimite un email prin SNS. Ce stări poate avea alarma?

Răspuns scurt: Creezi un topic SNS cu o abonare de email confirmată, apoi aws cloudwatch put-metric-alarm pe CPUUtilization din AWS/EC2, cu perioadă de 300 de secunde, 2 perioade de evaluare, prag 80 și acțiunea spre ARN-ul topicului. Stările sunt OK, ALARM și INSUFFICIENT_DATA.

BASH
aws sns create-topic --name alerte-prod
aws sns subscribe --topic-arn arn:aws:sns:eu-central-1:123456789012:alerte-prod \
  --protocol email --notification-endpoint ops@exemplu.ro
# abonarea trebuie confirmată din emailul primit

aws cloudwatch put-metric-alarm \
  --alarm-name cpu-mare-web-1 \
  --namespace AWS/EC2 --metric-name CPUUtilization \
  --dimensions Name=InstanceId,Value=i-0abc123def4567890 \
  --statistic Average --period 300 --evaluation-periods 2 \
  --threshold 80 --comparison-operator GreaterThanThreshold \
  --treat-missing-data missing \
  --alarm-actions arn:aws:sns:eu-central-1:123456789012:alerte-prod \
  --ok-actions arn:aws:sns:eu-central-1:123456789012:alerte-prod

--period 300 cu --evaluation-periods 2 înseamnă două perioade consecutive de 5 minute peste prag. Cu --datapoints-to-alarm poți cere, de exemplu, 3 din 5 perioade, ca să eviți alarmele declanșate de un vârf scurt.

Stările:

  • OK: metrica e sub prag;
  • ALARM: condiția e îndeplinită; acțiunile se execută la trecerea în această stare, nu la fiecare evaluare;
  • INSUFFICIENT_DATA: nu există suficiente date, de exemplu imediat după creare sau când instanța e oprită.

--treat-missing-data decide cum sunt tratate datele lipsă: missing, notBreaching, breaching sau ignore. Pentru o metrică ce dispare când serviciul cade, breaching e uneori alegerea corectă.

Acțiunile pot fi și de Auto Scaling, de oprire, repornire sau recuperare a instanței. Pentru a evita zgomotul, composite alarms combină mai multe alarme cu AND/OR.

Ce urmărește intervievatorul: Verifică dacă poți configura monitorizarea de bază fără consolă. Uitarea confirmării abonării la email e o greșeală frecventă.

Eroarea, în practică:Period must be 10, 30 or a multiple of 60

87 Junior

Care e diferența dintre CloudWatch, CloudTrail și AWS Config? Ce serviciu folosești ca să afli cine a șters un security group ieri?

Răspuns scurt: CloudWatch măsoară cum funcționează resursele (metrici, loguri, alarme), CloudTrail înregistrează cine a făcut ce apel API și când, iar AWS Config ține istoricul configurației resurselor și verifică reguli de conformitate. Ca să afli cine a șters security group-ul, cauți evenimentul DeleteSecurityGroup în CloudTrail.

CloudWatch răspunde la „cum se comportă sistemul?”: metrici (CPU, latență, erori), loguri ale aplicațiilor și serviciilor, alarme, dashboard-uri.

CloudTrail răspunde la „cine a făcut ce?”: fiecare apel API (din consolă, CLI, SDK, alte servicii) devine un eveniment cu identitatea, ora, IP-ul sursă, parametrii și rezultatul. Event history păstrează gratuit evenimentele de management din ultimele 90 de zile, căutabile în consolă. Pentru păstrare mai lungă și analiză creezi un trail care scrie în S3 (ideal într-un cont separat de loguri, pentru toate regiunile și toate conturile organizației). Evenimentele de date (de exemplu fiecare GetObject din S3) se activează separat, contra cost.

BASH
aws cloudtrail lookup-events \
  --lookup-attributes AttributeKey=EventName,AttributeValue=DeleteSecurityGroup \
  --start-time 2026-10-30T00:00:00Z

Rezultatul arată userIdentity, adică utilizatorul sau rolul (și, pentru roluri, numele sesiunii), plus IP-ul sursă.

AWS Config răspunde la „cum arăta resursa și e conformă?”: înregistrează configurația resurselor și fiecare schimbare, cu relațiile dintre ele. Vezi cum arăta security group-ul înainte de ștergere și ce instanțe îl foloseau. Config rules verifică reguli (de exemplu „niciun bucket S3 public”, „volumele EBS criptate”) și pot declanșa remedieri automate.

Pe scurt: CloudWatch pentru operare, CloudTrail pentru audit și investigații de securitate, Config pentru conformitate și istoricul configurației. În practică se folosesc împreună.

Ce urmărește intervievatorul: Verifică dacă știi unde cauți informația în funcție de întrebare. Confuzia dintre CloudWatch și CloudTrail e frecventă la juniori.

88 Junior

Ce este AWS CloudFormation? Scrie un template minim care creează un bucket S3 cu versioning și criptare și exportă numele lui.

Răspuns scurt: CloudFormation e serviciul AWS de infrastructure as code: descrii resursele într-un template YAML sau JSON, iar CloudFormation le creează, actualizează și șterge ca un stack. Template-ul minim are Resources cu un AWS::S3::Bucket și Outputs cu numele bucketului.

YAML
AWSTemplateFormatVersion: "2010-09-09"
Description: Bucket pentru documente, cu versioning
Parameters:
  Mediu:
    Type: String
    AllowedValues: [dev, prod]
    Default: dev
Resources:
  BucketDocumente:
    Type: AWS::S3::Bucket
    DeletionPolicy: Retain
    Properties:
      BucketName: !Sub "firma-documente-${Mediu}-${AWS::AccountId}"
      VersioningConfiguration:
        Status: Enabled
      BucketEncryption:
        ServerSideEncryptionConfiguration:
          - ServerSideEncryptionByDefault:
              SSEAlgorithm: AES256
      PublicAccessBlockConfiguration:
        BlockPublicAcls: true
        BlockPublicPolicy: true
        IgnorePublicAcls: true
        RestrictPublicBuckets: true
Outputs:
  NumeBucket:
    Value: !Ref BucketDocumente
    Export:
      Name: !Sub "${AWS::StackName}-NumeBucket"
BASH
aws cloudformation deploy --template-file bucket.yaml \
  --stack-name documente-dev --parameter-overrides Mediu=dev

Concepte:

  • template: descrierea declarativă; stack: instanța lui în cont și regiune, cu toate resursele create;
  • parametri pentru valori care diferă între medii; pseudo-parametri ca AWS::AccountId și AWS::Region;
  • !Ref întoarce identificatorul principal al resursei (pentru bucket, numele), !Sub construiește șiruri;
  • outputs cu export pot fi importate în alte stack-uri cu !ImportValue;
  • DeletionPolicy: Retain păstrează bucketul dacă stack-ul e șters.

CloudFormation își ține singur starea, deci nu există un fișier de state de gestionat, iar la o eroare în timpul creării face rollback automat.

Ce urmărește intervievatorul: Verifică dacă ai scris IaC nativ AWS. Intervievatorul urmărește dacă știi structura template-ului și funcțiile intrinseci de bază.

89 Junior

Cum se formează factura AWS și ce faci din prima zi ca să nu ai surprize?

Răspuns scurt: Plătești calcul, stocare, cereri și transfer de date, mai ales spre internet și între regiuni sau zone. Din prima zi: buget cu alerte în AWS Budgets, Cost Anomaly Detection, Cost Explorer și tag-uri pe resurse.

Componentele frecvente ale facturii:

  • calcul: instanțe EC2, containere Fargate, durata funcțiilor Lambda, instanțe RDS, plătite pe secundă sau pe oră;
  • stocare: GB pe lună în S3, EBS, snapshot-uri, backup-uri, loguri CloudWatch;
  • cereri: apeluri API la S3, DynamoDB, API Gateway, SQS, KMS;
  • transfer de date: intrarea din internet e în general gratuită, dar ieșirea spre internet se taxează, la fel transferul între regiuni și, în multe cazuri, între zone de disponibilitate;
  • servicii de rețea: NAT gateway (pe oră și pe GB), load balancere, adrese IPv4 publice, interface endpoints;
  • suport și licențe.

Ce faci din prima zi:

  • AWS Budgets: un buget lunar cu alerte la praguri (de exemplu la o parte din buget și la depășirea prognozată), trimise pe email sau SNS;
  • alerte de facturare și Cost Anomaly Detection, care semnalează creșteri neobișnuite;
  • Cost Explorer pentru a vedea costurile pe serviciu, regiune și tag;
  • tag-uri (Proiect, Mediu, Echipa) activate ca tag-uri de alocare a costurilor;
  • AWS Pricing Calculator înainte de a lansa ceva nou;
  • Free Tier: verifici ce acoperă efectiv pentru contul tău, pentru că regulile diferă între conturi și au fost schimbate de AWS în timp.

Cele mai frecvente surprize la început: resurse lăsate pornite în altă regiune, un NAT gateway uitat, volume EBS și snapshot-uri rămase după ștergerea instanțelor, loguri fără retenție.

Ce urmărește intervievatorul: Verifică responsabilitatea față de costuri, o calitate apreciată la orice nivel. Juniorii uită adesea de transferul de date și de NAT.

90 Mid

Scrie o interogare CloudWatch Logs Insights care arată numărul de erori pe intervale de 5 minute din logurile unei funcții Lambda și cele mai lente 10 invocări. Ce setare a grupurilor de loguri e uitată des?

Răspuns scurt: Pentru erori: filter @message like /ERROR/ | stats count(*) by bin(5m). Pentru invocările lente: filter @type = "REPORT" | sort @duration desc | limit 10. Setarea uitată e retenția: implicit, logurile nu expiră niciodată și costul de stocare crește continuu.

Erori pe intervale de 5 minute:

fields @timestamp, @message
| filter @message like /ERROR/
| stats count(*) as erori by bin(5m)
| sort erori desc

Cele mai lente invocări, folosind rândul REPORT pe care Lambda îl scrie la finalul fiecărei invocări:

filter @type = "REPORT"
| fields @requestId, @duration, @maxMemoryUsed / 1000000 as memorie_mb, @initDuration
| sort @duration desc
| limit 10

Pentru Lambda, Logs Insights descoperă automat câmpurile @duration, @billedDuration, @maxMemoryUsed și @initDuration. Dacă aplicația scrie loguri JSON, câmpurile lor sunt extrase automat și le poți filtra direct, de exemplu filter nivel = "ERROR" and client_id = "c42". De aceea logurile structurate sunt mult mai utile decât textul liber.

Logs Insights se taxează după volumul de date scanate, deci restrângi intervalul de timp și grupurile de loguri.

Retenția: un grup nou are implicit „Never expire”. Setezi o retenție potrivită (de exemplu 30 de zile pentru dezvoltare, mai mult pentru producție, conform cerințelor de audit) și, pentru arhivă lungă, exporți în S3. În IaC, creezi grupul de loguri explicit, cu RetentionInDays, înainte ca serviciul să-l creeze automat fără retenție.

Alte unelte utile: metric filters, care transformă un tipar din loguri într-o metrică pe care pui alarmă, și subscription filters, care trimit logurile în timp real spre Lambda, Firehose sau OpenSearch.

Ce urmărește intervievatorul: Verifică dacă folosești logurile pentru investigații reale. Lipsa retenției este o sursă clasică de costuri care cresc nevăzute.

Eroarea, în practică:retentionInDays must satisfy enum value set

91 Mid

Ce se întâmplă când o actualizare de stack CloudFormation eșuează la jumătate? Cum previi înlocuirea accidentală a unei baze de date la un update?

Răspuns scurt: CloudFormation face rollback la configurația anterioară a stack-ului (UPDATE_ROLLBACK_COMPLETE). Pentru resursele critice folosești change sets ca să vezi dinainte ce se înlocuiește, DeletionPolicy și UpdateReplacePolicy pe Retain sau Snapshot, stack policies care interzic înlocuirea și termination protection pe stack.

Rollback: dacă o resursă eșuează la update, CloudFormation readuce resursele deja modificate la starea anterioară. Uneori rollback-ul eșuează și el (de exemplu, o resursă a fost modificată manual) și stack-ul rămâne în UPDATE_ROLLBACK_FAILED; atunci folosești „continue update rollback”, eventual sărind resursele problematice. Poți dezactiva rollback-ul în dezvoltare, ca să investighezi resursa defectă.

Înlocuirea e riscul mare. Unele proprietăți nu pot fi modificate pe loc; schimbarea lor înseamnă că CloudFormation creează o resursă nouă și o șterge pe cea veche. Pentru o bază RDS, schimbarea anumitor proprietăți (de exemplu identificatorul instanței) duce la o bază nouă și goală.

Protecții:

  • Change sets: înainte de execuție vezi lista schimbărilor, iar coloana Replacement arată True pentru resursele care vor fi recreate;
BASH
aws cloudformation create-change-set --stack-name app-prod \
  --change-set-name v42 --template-body file://app.yaml
aws cloudformation describe-change-set --stack-name app-prod --change-set-name v42
  • DeletionPolicy: Snapshot sau Retain pentru baze de date și bucketuri, și UpdateReplacePolicy, care se aplică resursei vechi la înlocuire;
  • stack policy care interzice Update:Replace și Update:Delete pe resursele critice;
  • termination protection pe stack;
  • deletion protection activat chiar în proprietățile bazei.

Drift detection compară resursele reale cu template-ul și arată ce a fost schimbat manual. Schimbările manuale sunt o cauză frecventă a eșecurilor de update.

Ce urmărește intervievatorul: Verifică experiența cu IaC în producție. Un candidat cu experiență a văzut cel puțin o dată o resursă recreată neașteptat.

92 Mid

Factura de luna aceasta conține costuri pe care nimeni din echipă nu le poate explica. Cum găsești resursele uitate și cum previi situația pe viitor?

Răspuns scurt: Analizezi Cost Explorer pe serviciu, regiune și usage type, cauți resurse uitate (EBS neatașate, snapshot-uri, IP-uri, NAT, load balancere, alte regiuni) și le legi de proprietari prin tag-uri. Previi cu tag-uri obligatorii, bugete și curățenie automată.

Investigația:

  • Cost Explorer, grupat pe serviciu, apoi pe regiune și pe usage type. Usage type spune exact ce plătești, de exemplu NatGateway-Bytes sau EBS:VolumeUsage.gp3.
  • Cost and Usage Report (sau exporturile de date de cost) în S3, interogat cu Athena, când ai nevoie de detalii la nivel de resursă.
  • Verifici toate regiunile: Tag Editor sau AWS Resource Explorer listează resursele din toate regiunile.

Suspecți obișnuiți:

  • volume EBS în starea available (neatașate);
  • snapshot-uri și AMI-uri vechi, fără politică de retenție;
  • Elastic IP-uri și alte adrese IPv4 publice nefolosite;
  • NAT gateway-uri și load balancere în medii de test abandonate;
  • instanțe RDS de test pornite permanent;
  • grupuri de loguri fără retenție;
  • bucketuri cu versiuni vechi sau încărcări multipart neterminate.
BASH
aws ec2 describe-volumes --filters Name=status,Values=available \
  --query 'Volumes[].[VolumeId,Size,CreateTime]' --output table

Prevenție:

  • tag-uri obligatorii (Proprietar, Proiect, Mediu), impuse prin tag policies în AWS Organizations sau prin SCP-uri care refuză crearea resurselor fără tag;
  • tag-urile activate ca cost allocation tags, ca să apară în rapoarte;
  • bugete pe echipă sau pe proiect, cu alerte trimise echipei, nu doar unui administrator;
  • mediile de test create prin IaC și distruse automat; instanțele de dezvoltare oprite noaptea cu Instance Scheduler;
  • Trusted Advisor și Compute Optimizer pentru resurse subutilizate.

Costul este o responsabilitate a echipelor care creează resursele, nu doar a celui care plătește factura.

Ce urmărește intervievatorul: Verifică abordarea sistematică și practica de FinOps. Răspunsul slab: „mă uit prin consolă și șterg ce nu recunosc”.

93 Senior

Echipa ta trebuie să aleagă între CloudFormation, AWS CDK și Terraform pentru infrastructura AWS. Ce argumente aduci?

Răspuns scurt: CloudFormation e nativ și fără stare de gestionat, dar YAML-ul crește greu. CDK generează CloudFormation din cod, cu abstracții. Terraform e multi-furnizor, dar cere gestionarea stării. Decid competențele echipei, furnizorii și standardele firmei.

CloudFormation:

  • nativ AWS: starea e ținută de serviciu, rollback automat, integrare cu StackSets (deploy în mai multe conturi și regiuni), Service Catalog, Control Tower;
  • resursele noi AWS sunt adesea suportate rapid, dar nu întotdeauna din prima zi;
  • YAML-ul devine lung și repetitiv; reutilizarea se face prin nested stacks, module sau macro-uri.

AWS CDK:

  • scrii infrastructura într-un limbaj de programare, iar cdk synth produce template-uri CloudFormation; deploy-ul trece tot prin CloudFormation, deci păstrezi avantajele lui;
  • constructs de nivel înalt: câteva linii creează un serviciu cu load balancer, roluri și security groups cu valori implicite bune;
  • testare cu framework-urile limbajului, bucle, condiții, tipuri;
  • riscul: abstracțiile ascund multe resurse, iar codul de infrastructură poate deveni prea „inteligent”; ai nevoie de disciplină și de review pe diff-ul generat (cdk diff).

Terraform (sau OpenTofu):

  • un singur instrument pentru AWS, alte cloud-uri, DNS extern, monitorizare, GitHub;
  • plan arată clar schimbările, ecosistem mare de module;
  • starea trebuie ținută într-un backend remote cu locking (de exemplu S3 cu blocare), protejată, pentru că poate conține date sensibile;
  • licența s-a schimbat în 2023, motiv pentru care a apărut OpenTofu.

Criterii de decizie de discutat cu echipa: ce limbaje știe echipa, dacă infrastructura include și alți furnizori decât AWS, ce folosesc deja celelalte echipe din firmă, cât de importante sunt suportul AWS și integrarea cu serviciile de guvernanță.

Cel mai prost rezultat e un amestec necoordonat. Alegi un instrument principal și reguli clare pentru excepții.

Ce urmărește intervievatorul: Verifică dacă poți argumenta o decizie tehnică cu compromisuri, nu cu preferințe. Un senior leagă alegerea de echipă și de context.

Arhitectură, DR și situații practice

94 Junior

Un coleg vine dintr-o firmă în care fiecare server avea un nume și era reparat manual când avea probleme. Cum i-ai explica diferența de abordare în cloud („pets vs cattle”)?

Răspuns scurt: I-aș explica că în cloud serverele sunt înlocuibile: descrise în cod, pornite dintr-o imagine și înlocuite automat când se strică. Datele stau în servicii gestionate, iar schimbările trec prin pipeline, nu prin conectări manuale.

Un model de răspuns, structurat pentru o discuție cu un coleg:

Pornesc de la ce cunoaște. „Pets” sunt servere unice, cu nume, configurate manual de-a lungul anilor. Când unul se îmbolnăvește, îl „tratezi”: te conectezi, cauți problema, aplici o corecție. Merge, dar fiecare server devine diferit de celelalte, nimeni nu mai știe exact ce e instalat pe el, iar refacerea lui după un dezastru e incertă.

Explic alternativa. „Cattle” sunt servere identice, numerotate, create automat:

  • configurația e în cod: launch template, AMI construit automat, IaC pentru rețea și permisiuni;
  • un Auto Scaling group le pornește și le înlocuiește singur când pică health check-ul;
  • o modificare nu se face pe server, ci în cod, urmată de un deploy care înlocuiește instanțele;
  • datele importante stau în RDS, S3, DynamoDB, iar logurile în CloudWatch, deci ștergerea unui server nu pierde nimic.

Arăt câștigul concret, pe un exemplu din proiect. „Data trecută, când serverul de rapoarte a rămas fără disc, am pierdut o oră să facem curat. Cu abordarea asta, ASG-ul ar fi înlocuit instanța în câteva minute, iar noi am fi corectat cauza în cod.”

Recunosc limitele. Unele sisteme rămân „pets” o vreme (o bază de date veche, un server cu licență legată de hardware). Nu trebuie schimbat totul deodată.

Las loc pentru întrebări și îi propun să facem împreună prima modificare prin pipeline. O explicație fără jargon inutil, cu un exemplu din proiectul lui, convinge mai bine decât o prezentare.

Ce urmărește intervievatorul: Verifică dacă poți explica un concept fundamental al cloud-ului unui coleg, cu empatie. Intervievatorul urmărește claritatea, nu terminologia.

95 Mid

Care sunt pilonii AWS Well-Architected Framework? Dă câte un exemplu concret de practică pentru fiecare.

Răspuns scurt: Sunt șase piloni: Operational Excellence, Security, Reliability, Performance Efficiency, Cost Optimization și Sustainability. Exemple: IaC și runbook-uri, least privilege și criptare, Multi-AZ și backup testat, alegerea tipului potrivit de resursă, Savings Plans și curățenie, instanțe Graviton și scalare la zero.

Well-Architected e un set de principii și întrebări cu care evaluezi o arhitectură. AWS oferă și un instrument gratuit, Well-Architected Tool, care te ghidează prin întrebări și produce o listă de riscuri.

  • Operational Excellence (excelența operațională): infrastructura în IaC, deploy-uri mici și frecvente, cu posibilitate de revenire; runbook-uri pentru incidente; post-mortem-uri fără vinovați.
  • Security (securitate): privilegiul minim în IAM, credențiale temporare, criptare în repaus și în tranzit, CloudTrail și GuardDuty active, protejarea fiecărui nivel (WAF, security groups, subrețele private).
  • Reliability (fiabilitate): resurse în mai multe zone, Auto Scaling cu auto-vindecare, reîncercări cu backoff, backup-uri restaurate efectiv la teste, cote de serviciu verificate.
  • Performance Efficiency (eficiența performanței): alegerea tipului potrivit de serviciu (serverless, containere, instanțe specializate), cache cu CloudFront sau ElastiCache, teste de încărcare.
  • Cost Optimization (optimizarea costurilor): dimensionare corectă după metrici, Savings Plans pentru consumul stabil, Spot pentru joburi tolerante, tag-uri și bugete, oprirea mediilor de test.
  • Sustainability (sustenabilitate): utilizare ridicată a resurselor, procesoare eficiente energetic (de exemplu Graviton), scalare la zero când nu e trafic, date vechi mutate în clase de stocare reci sau șterse.

Pilonii intră uneori în conflict: Multi-AZ crește fiabilitatea și costul. Valoarea cadrului e că face aceste compromisuri explicite și documentate, în loc să fie luate implicit.

Există și lens-uri specializate, de exemplu Serverless Lens sau SaaS Lens.

Ce urmărește intervievatorul: Verifică dacă poți lega principiile de practici concrete. Mulți candidați enumeră doar cinci piloni, uitând de Sustainability.

96 Mid

Afli că o cheie de acces AWS a echipei a fost publicată într-un depozit GitHub public. Ce faci, în ordine?

Răspuns scurt: Dezactivezi imediat cheia, verifici în CloudTrail ce s-a făcut cu ea, elimini orice resursă sau acces creat de atacator, înlocuiești cheia în aplicații cu un rol sau o cheie nouă, cureți istoricul Git și documentezi incidentul cu măsuri ca să nu se repete.

Un model de răspuns structurat, de tip „limitează, investighează, remediază, învață”:

1. Limitează imediat (minute, nu ore):

  • dezactivezi cheia (aws iam update-access-key --status Inactive); nu o ștergi încă, ca să păstrezi legătura cu evenimentele din CloudTrail;
  • dacă AWS a detectat scurgerea, contul poate avea deja aplicată politica AWSCompromisedKeyQuarantine și un caz deschis la suport;
  • anunți persoana responsabilă de securitate, conform procedurii firmei.

2. Investighează:

  • în CloudTrail cauți toate evenimentele cu acel accessKeyId, în toate regiunile, din momentul publicării;
  • cauți semne tipice: utilizatori, chei sau roluri IAM noi, instanțe pornite în regiuni nefolosite, schimbări de politici pe bucketuri, acces la date (GetObject, dacă data events sunt active).

3. Remediază:

  • ștergi resursele și identitățile create de atacator și revoci sesiunile active ale rolurilor afectate;
  • creezi o cheie nouă sau, mai bine, treci aplicația pe un rol IAM, OIDC sau Identity Center;
  • elimini secretul din istoricul Git, dar consideri cheia compromisă oricum, pentru că poate fi deja copiată;
  • verifici factura pentru costuri anormale și contactezi suportul AWS dacă e cazul.

4. Învață (post-mortem fără vinovați):

  • de ce exista o cheie permanentă și de ce a putut ajunge în cod;
  • scanare de secrete în pipeline și protecție la push pe GitHub;
  • alerte GuardDuty și pe crearea de utilizatori IAM noi.

La interviu, contează să arăți calm și o ordine clară a pașilor.

Ce urmărește intervievatorul: Verifică reacția la un incident de securitate real. Greșeala tipică: ștergi doar commit-ul din Git și crezi că problema s-a rezolvat.

97 Mid

Imediat după un deploy, utilizatorii primesc erori 502 de la Application Load Balancer. Cum depanezi pas cu pas?

Răspuns scurt: Dacă impactul e mare, faci întâi rollback. Apoi verifici starea țintelor, metricile ELB 502 față de Target 5XX, access logs și logurile aplicației. Cauze tipice: port greșit, proces căzut, keep-alive mai scurt decât al ALB.

Un model structurat de răspuns:

0. Impactul: dacă erorile afectează mulți utilizatori, primul pas e revenirea la versiunea anterioară (rollback). Investigația continuă după ce serviciul e restabilit.

1. Unde se generează eroarea:

  • HTTPCode_ELB_502_Count crescut înseamnă că ALB-ul nu a primit un răspuns valid de la țintă (conexiune refuzată, închisă, răspuns malformat);
  • HTTPCode_Target_5XX_Count înseamnă că aplicația însăși a răspuns cu 5xx, iar ALB doar transmite;
  • în access logs ale ALB (în S3), câmpurile elb_status_code și target_status_code arată exact cine a generat ce. Un target_status_code lipsă cu elb_status_code 502 indică o problemă de conexiune la țintă.

2. Țintele: în target group vezi dacă sunt healthy, unhealthy sau draining și motivul. Instanțele noi au pornit aplicația pe portul corect?

3. Cauze tipice după deploy:

  • aplicația ascultă pe alt port sau doar pe 127.0.0.1;
  • procesul cade la pornire (configurație lipsă, secret inaccesibil, migrare eșuată);
  • keep-alive: dacă aplicația sau serverul ei închide conexiunile inactive mai repede decât timeout-ul de inactivitate al ALB (implicit 60 de secunde), ALB poate trimite o cerere pe o conexiune deja închisă și întoarce 502. Timeout-ul keep-alive al aplicației trebuie să fie mai mare decât cel al ALB;
  • răspunsuri cu headere invalide sau prea mari;
  • funcție Lambda ca țintă care întoarce un format greșit.

4. Confirmare: după corectare, urmărești metricile și adaugi o alarmă și un pas de verificare automată în pipeline, ca un deploy defect să fie oprit înainte să ajungă la toți utilizatorii.

Ce urmărește intervievatorul: Verifică metoda de depanare sub presiune. Diferențierea dintre 502 generat de ALB și 5xx generat de aplicație arată experiență reală.

98 Senior

Compară strategiile de recuperare după dezastre în AWS: backup and restore, pilot light, warm standby și multi-site active/active. Cum alegi una pentru o aplicație?

Răspuns scurt: În ordinea costului și a vitezei: backup and restore (ore), pilot light (date replicate, calcul oprit), warm standby (copie micșorată pornită), active/active (mai multe regiuni servesc trafic). Alegi după RTO, RPO și costul indisponibilității.

Recuperarea după dezastre se referă aici la pierderea unei regiuni întregi sau a contului, nu a unei zone (pentru zone, Multi-AZ e soluția standard).

  • Backup and restore: backup-uri (snapshot-uri RDS și EBS, S3, AWS Backup) copiate în altă regiune, iar infrastructura descrisă în IaC. La dezastru, creezi totul de la zero în regiunea secundară și restaurezi datele. Cost minim, recuperare în ore, pierdere de date egală cu intervalul dintre backup-uri.
  • Pilot light: datele sunt replicate continuu în regiunea secundară (replici RDS între regiuni, Aurora Global Database, replicare S3, DynamoDB global tables), dar serverele aplicației nu rulează sau rulează la minim. La dezastru, pornești calculul și muți DNS-ul. Recuperare în zeci de minute.
  • Warm standby: o copie completă, dar micșorată, a mediului rulează permanent în regiunea secundară și poate servi trafic. La dezastru, o scalezi și muți tot traficul. Recuperare în minute.
  • Multi-site active/active: ambele regiuni servesc trafic permanent, cu rutare Route 53 după latență sau ponderi. Pierderea unei regiuni înseamnă doar redirecționarea traficului. Cel mai scump și cel mai complex, mai ales pentru scrieri în ambele regiuni, unde trebuie rezolvate conflictele.

Cum alegi: întrebi business-ul cât costă o oră de indisponibilitate și câte date se pot pierde, și obții RTO și RPO. Apoi alegi cea mai ieftină strategie care le respectă. Aplicațiile diferite ale aceleiași firme pot avea strategii diferite.

Detalii care contează: un plan de DR fără exerciții periodice nu e un plan; backup-urile se păstrează și într-un cont separat; serviciile globale (IAM, Route 53) și cotele din regiunea secundară trebuie verificate dinainte.

Ce urmărește intervievatorul: Verifică dacă poți lega strategia tehnică de cerințele de business. Un senior insistă pe testarea efectivă a recuperării.

99 Senior

Un startup lansează o aplicație web nouă, cu trafic greu de prevăzut și o echipă de trei dezvoltatori. Ar construi-o pe EC2, pe containere (ECS Fargate) sau serverless (Lambda)? Cum argumentezi?

Răspuns scurt: Compari efortul de operare, profilul traficului, costul, limitele tehnice și competențele echipei. Pentru o echipă mică și trafic imprevizibil, serverless sau Fargate sunt de obicei potrivite; EC2 are sens pentru control special sau trafic mare constant.

Răspunsul bun pornește de la întrebări, nu de la tehnologia preferată:

  • ce tip de încărcare are aplicația: cereri HTTP scurte, conexiuni persistente (WebSocket), procesare lungă, dependențe de sistem speciale;
  • cât de variabil e traficul și cum arată în perioadele fără utilizatori;
  • ce știe echipa și cât timp are pentru operare;
  • ce cerințe de cost, latență și conformitate există.

Lambda + API Gateway + DynamoDB sau Aurora Serverless:

  • plusuri: zero servere, scalare automată, cost aproape nul la trafic zero, patch-urile sistemului făcute de AWS;
  • minusuri: limita de 15 minute, cold start, conexiunile la baze relaționale cer RDS Proxy, testarea locală și depanarea sunt diferite, costul poate crește la trafic mare și constant.

ECS pe Fargate:

  • plusuri: containerul rulează identic local și în cloud, fără limite de durată, fără administrarea serverelor, ușor de mutat ulterior pe altă platformă;
  • minusuri: plătești continuu pentru task-urile pornite, iar ALB-ul, rețeaua și pipeline-ul de imagini trebuie configurate.

EC2 cu Auto Scaling:

  • plusuri: control complet, cel mai ieftin la încărcare mare și stabilă cu Savings Plans, orice software;
  • minusuri: tu răspunzi de sistemul de operare, patch-uri, AMI-uri, agenți.

Pentru scenariul dat, aș propune serverless sau Fargate, după tipul aplicației, cu IaC de la început, ca decizia să poată fi revizuită. Contează să documentezi motivele și criteriile la care ai reveni (de exemplu, un anumit nivel de trafic constant sau o funcționalitate care depășește limitele Lambda).

Ce urmărește intervievatorul: Verifică judecata arhitecturală și capacitatea de a argumenta compromisuri. Răspunsul slab alege o tehnologie fără să pună întrebări despre context.

100 Senior

Ești responsabil de migrarea unei aplicații monolit dintr-un centru de date propriu în AWS. Cum planifici migrarea și ce strategii de migrare cunoști?

Răspuns scurt: Pornești cu inventarul și dependențele, alegi pentru fiecare componentă una dintre strategiile cunoscute ca „7 R” (retire, retain, rehost, relocate, repurchase, replatform, refactor), construiești fundația (conturi, rețea, identitate), migrezi în valuri cu un plan de revenire și abia apoi optimizezi.

Evaluare:

  • inventarul serverelor, bazelor de date, dependențelor de rețea și al integrărilor cu alte sisteme (AWS Application Discovery Service ajută la colectarea datelor);
  • cerințe nefuncționale: RTO și RPO, conformitate, ferestre de mentenanță acceptate, licențe.

Strategiile („7 R”):

  • retire: retragi ce nu mai e folosit;
  • retain: păstrezi temporar on-premises ce nu poate fi mutat acum;
  • rehost („lift and shift”): muți serverele aproape neschimbate pe EC2, de exemplu cu AWS Application Migration Service;
  • relocate: muți platforme întregi (de exemplu VMware) fără modificări;
  • repurchase: treci pe un produs SaaS;
  • replatform: schimbări mici cu câștig mare, de exemplu baza de date pe RDS în loc de server propriu, fișierele în S3;
  • refactor: rescrii părți ale aplicației pentru servicii cloud-native, când business-ul o justifică.

Fundația (landing zone): structura de conturi, conectivitatea cu centrul de date (Site-to-Site VPN sau Direct Connect), identitatea, logurile centralizate, guvernanța costurilor.

Execuție în valuri: începi cu o aplicație cu risc mic, ca echipa să învețe. Datele bazei le migrezi cu AWS DMS (inclusiv replicare continuă până la momentul trecerii) sau cu replicarea nativă a motorului. Pentru trecerea finală: TTL DNS redus din timp, o fereastră de comutare, criterii clare de succes și un plan de revenire testat.

După migrare: dimensionezi corect resursele pe baza metricilor reale, introduci Savings Plans și abia apoi faci refactorizări. A face rehost și refactor simultan crește mult riscul.

Ce urmărește intervievatorul: Verifică experiența cu proiecte mari și gestionarea riscului. Un senior separă clar migrarea de modernizare.

Întrebări de interviu pe meserie

Alte tehnologii

← Toate întrebările de interviu

Tudor Andrei Dumitrescu
Cine coordonează pregătirea de interviu

Tudor Andrei Dumitrescu

Senior Software Developer · fondatorul Academiei Programatorilor

LinkedIn
  1. 2019 Junior JavaCognizant Softvision
  2. 2021 Mid JavaCognizant Softvision
  3. 2022 Team LeaderEndava
  4. 2023 Senior Software DeveloperUniCredit
  5. Acum Senior Software DeveloperHCLTech
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu
Certificat de formator autorizatMinisterul Muncii și Ministerul Educației · 2022
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu

Certificat de formator autorizat · Ministerul Muncii și Ministerul Educației · 2022

Din 2020 construiește Academia Programatorilor, iar din 2026 și JoburiIT.ro. Întrebările de aici urmăresc ce se cere la interviurile de AWS, de la junior la mid, iar pe JoburiIT.ro îți poți certifica apoi cunoștințele.

Învață AWS scriind cod, nu doar citind

Curs Cloud: AWS fundamentals: lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 15 lecții sunt gratuite.