...
Pregătire interviuri

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

Întrebările despre Docker 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 Docker: primele 15 lecții sunt gratuite.

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

  • 100întrebări
  • 51junior
  • 34mid
  • 15senior
  • 138 minde citit
Întrebări de interviu Docker cu răspunsuri

La un interviu în care se verifică Docker, întrebările vin de obicei în trei forme: teorie scurtă („ce face instrucțiunea…”, „care e diferența dintre…”), fragmente de Dockerfile sau compose.yaml pe care trebuie să le citești și să spui ce se întâmplă sau unde e problema, și sarcini practice: scrii un Dockerfile pentru o aplicație dată, pornești un mediu cu bază de date în Compose sau depanezi un container care se oprește imediat. Uneori primești o temă de casă în care aplicația trebuie să pornească cu un singur docker compose up, iar discuția de după pornește de la deciziile tale.

La nivel de junior, intervievatorul vrea să vadă că știi comenzile de bază fără ezitare (run, ps, logs, exec, build), că înțelegi diferența dintre imagine, container, volum și rețea și că un Dockerfile simplu îl scrii corect. La nivel de mid, întrebările merg spre „de ce”: cum funcționează cache-ul de build, ce se întâmplă cu semnalele și cu PID 1, cum comunică serviciile, cum ții secretele în afara imaginii, cum depanezi. La senior apar securitatea, resursele, build-urile în CI și deciziile de producție, inclusiv trecerea spre Kubernetes.

Fiecare întrebare are un răspuns scurt, bun de spus în primele secunde, și unul detaliat, cu explicația și comenzile de care ai nevoie la întrebările de continuare. Rulează exemplele pe calculatorul tău: un docker inspect văzut o dată se ține minte mult mai bine decât unul citit. Pentru Kubernetes în detaliu, CI/CD, Terraform și cloud, vezi pagina de întrebări pentru meseria de DevOps / Cloud Engineer.

Containere, namespaces și cgroups

1 Junior

Ce problemă rezolvă Docker, concret, pentru o echipă de dezvoltare?

Răspuns scurt: Docker împachetează aplicația împreună cu tot ce are nevoie ca să ruleze (runtime, biblioteci, configurație de sistem) într-o imagine care rulează la fel pe laptop, în CI și pe server. Dispare clasicul „pe calculatorul meu merge”.

Fără containere, fiecare mediu se configurează separat: pe laptopul tău e Node 18, pe server Node 20, colegul are altă versiune de OpenSSL, iar baza de date de test e instalată manual. Diferențele mici produc bug-uri greu de reprodus.

Docker rezolvă asta prin trei idei:

  • Imaginea este un pachet imuabil care conține sistemul de fișiere al aplicației: binarele, bibliotecile, codul și metadatele (comanda de pornire, variabilele implicite, portul documentat).
  • Containerul este un proces izolat pornit din imagine. Pornește în fracțiuni de secundă, pentru că nu bootează un sistem de operare.
  • Dockerfile-ul descrie în text, versionat în Git, cum se construiește imaginea, deci mediul devine reproductibil.

Beneficiile practice pe care le poți enumera la interviu: onboarding rapid (un coleg nou rulează docker compose up și are aplicația cu baza de date și Redis), același artefact testat în CI ajunge în producție, mai multe versiuni ale aceluiași serviciu pot rula pe aceeași mașină fără conflicte, iar curățenia e simplă, pentru că ștergi containerul și nu rămâne nimic instalat pe sistem.

Ce nu rezolvă Docker: nu face aplicația mai rapidă, nu înlocuiește configurația specifică fiecărui mediu (URL-uri, parole) și nu garantează securitatea doar pentru că un proces rulează într-un container.

Ce urmărește intervievatorul: Intervievatorul vrea să audă problema de business, nu doar definiția. Greșeala tipică este să descrii containerul ca pe o mașină virtuală mai mică.

2 Junior

Ce sunt namespaces în Linux și ce izolează fiecare dintre ele într-un container?

Răspuns scurt: Namespaces sunt mecanismul kernelului Linux care dă unui proces o vedere proprie asupra unei resurse: procese, rețea, sistem de fișiere, hostname, IPC, utilizatori. Un container este un proces pus în propriile namespaces.

Un container nu este o entitate a kernelului, ci un proces obișnuit căruia runtime-ul (de obicei runc) îi creează un set de namespaces. Fiecare namespace izolează un singur tip de resursă:

  • pid: procesul vede doar procesele din container, iar primul dintre ele are PID 1.
  • net: interfețe de rețea, adrese IP, tabelă de rutare și porturi proprii. De aceea două containere pot asculta amândouă pe portul 80.
  • mnt: puncte de montare proprii, deci containerul vede sistemul de fișiere din imagine, nu pe cel al host-ului.
  • uts: hostname propriu (implicit ID-ul scurt al containerului).
  • ipc: memorie partajată și cozi de mesaje separate.
  • user: maparea UID-urilor, astfel încât root din container poate fi un utilizator neprivilegiat pe host (folosit de modul rootless și de userns-remap).
  • cgroup: ascunde ierarhia de cgroups a host-ului.

Poți vedea asta direct pe un host Linux:

BASH
docker run -d --name web nginx
docker inspect -f '{{.State.Pid}}' web   # PID-ul pe host
sudo ls -l /proc/<PID>/ns                # namespaces ale procesului

Opțiuni precum --network host sau --pid host fac containerul să împartă namespace-ul respectiv cu host-ul, ceea ce slăbește izolarea. Namespaces controlează ce vede procesul, nu cât consumă; pentru limite de resurse există cgroups.

Ce urmărește intervievatorul: Se verifică dacă știi ce este un container sub capotă. Mulți candidați nu pot numi nimic dincolo de „e izolat”.

3 Junior

Ce sunt cgroups și ce legătură au cu opțiunile --memory și --cpus?

Răspuns scurt: Control groups (cgroups) sunt mecanismul kernelului care limitează și măsoară resursele unui grup de procese: memorie, CPU, I/O, număr de procese. Opțiunile --memory și --cpus ale lui docker run se traduc în setări de cgroup.

Dacă namespaces decid ce vede un proces, cgroups decid cât poate consuma. Docker pune fiecare container într-un cgroup propriu și scrie acolo limitele cerute:

BASH
docker run -d --name api --memory 512m --cpus 1.5 --pids-limit 200 imaginea-mea
docker stats api
  • --memory 512m setează limita de memorie. Dacă procesele o depășesc, kernelul pornește OOM killer-ul în interiorul cgroup-ului și omoară procesul, iar containerul iese de obicei cu codul 137.
  • --cpus 1.5 înseamnă că containerul poate folosi echivalentul a 1,5 nuclee pe intervalul de planificare. Peste această cotă procesul nu e omorât, ci încetinit (throttling).
  • --pids-limit previne un fork bomb care ar bloca tot host-ul.

Pe distribuțiile moderne se folosește cgroups v2, cu o ierarhie unificată; Docker suportă ambele versiuni. Tot din cgroups vin și cifrele afișate de docker stats.

Fără limite, un container poate consuma toată memoria host-ului și afecta celelalte containere sau chiar daemonul Docker. De aceea, pe un server cu mai multe servicii, limitele sunt o practică de bază, iar în Kubernetes aceleași mecanisme stau în spatele requests și limits.

Ce urmărește intervievatorul: Intervievatorul verifică dacă faci legătura între opțiunile din CLI și mecanismul din kernel. Greșeala tipică: a crede că depășirea CPU omoară containerul, ca la memorie.

Eroarea, în practică:invalid argument for "-m, --memory" flagMinimum memory limit allowed is 6MB

4 Junior

Ce se întâmplă, pas cu pas, când rulezi docker run -d -p 8080:80 nginx?

Răspuns scurt: Clientul docker trimite cererea la daemonul dockerd, care descarcă imaginea dacă lipsește, creează containerul (strat writable, rețea, port), iar containerd și runc pornesc procesul nginx în namespaces și cgroups proprii.

Arhitectura are mai multe componente, iar întrebarea verifică dacă le cunoști:

  • docker (CLI) este doar un client care vorbește cu daemonul printr-un API REST, implicit pe socket-ul /var/run/docker.sock.
  • dockerd gestionează imaginile, rețelele, volumele și construiește containerele.
  • containerd administrează ciclul de viață al containerelor și descărcarea imaginilor.
  • runc este runtime-ul OCI care creează efectiv namespaces și cgroups și pornește procesul.

Pașii:

  • Daemonul caută imaginea nginx:latest local. Dacă nu o are, o descarcă din registry-ul implicit (Docker Hub), strat cu strat.
  • Creează containerul: un strat writable deasupra straturilor imaginii, o interfață de rețea conectată la rețeaua bridge și o regulă de redirecționare de la portul 8080 al host-ului către portul 80 al containerului.
  • runc pornește procesul definit de ENTRYPOINT/CMD din imagine, aici nginx -g 'daemon off;'.
  • Cu -d, CLI-ul afișează ID-ul containerului și se întoarce, iar containerul rulează în fundal.

Aceeași secvență, separată, este docker pull, docker create și docker start. Faptul că CLI-ul doar vorbește cu un API explică și de ce poți controla un daemon de pe altă mașină cu DOCKER_HOST sau cu docker context.

Ce urmărește intervievatorul: Se verifică înțelegerea modelului client-daemon. Candidații slabi cred că docker rulează direct containerul.

Eroarea, în practică:Cannot connect to the Docker daemon

5 Junior

Cum rulează containerele Linux pe Windows sau macOS, dacă se bazează pe kernelul Linux?

Răspuns scurt: Pe macOS și Windows, Docker Desktop pornește o mașină virtuală Linux ușoară (pe Windows de obicei prin WSL 2), iar containerele rulează în kernelul acelei mașini virtuale. Clientul de pe sistemul tău vorbește cu daemonul din VM.

Un container Linux folosește direct kernelul host-ului, deci are nevoie de un kernel Linux. macOS și Windows nu au unul, așa că Docker Desktop rezolvă problema cu o mașină virtuală:

  • pe macOS, o VM Linux gestionată de Docker Desktop, pornită prin framework-ul de virtualizare al sistemului;
  • pe Windows, de obicei prin WSL 2, care oferă un kernel Linux real.

Consecințe care apar la interviu și în practică:

  • Bind mount-urile traversează granița dintre sistemul tău și VM, de aceea pot fi mai lente decât pe Linux, mai ales la proiecte cu multe fișiere mici (de exemplu node_modules).
  • Adresa localhost a containerului nu este cea a laptopului; pentru a ajunge din container la un serviciu de pe laptop folosești host.docker.internal.
  • Pe un Mac cu procesor Apple Silicon, VM-ul este arm64. O imagine construită doar pentru amd64 rulează prin emulare, mai lent, sau dă eroare de platformă.

Windows are și containere Windows native, care folosesc kernelul Windows, dar sunt un ecosistem separat: o imagine Windows nu rulează pe Linux și invers. Pe un server Linux nu există niciun strat intermediar, iar Docker Engine rulează direct.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă că înțelegi că un container împarte kernelul. Greșeala tipică: a spune că Docker „emulează” Linux în orice situație.

Eroarea, în practică:Cannot connect to the Docker daemon

6 Junior

Pornești docker run -d --name db postgres:16. Ce vezi dacă rulezi ps aux pe host-ul Linux și ce îți spune asta?

Răspuns scurt: Vezi procesele postgres în lista de procese a host-ului, cu alte PID-uri decât cele din container. Un container este un proces obișnuit al host-ului, doar izolat prin namespaces, nu o mașină separată.

Pe un host Linux:

BASH
docker run -d --name db -e POSTGRES_PASSWORD=secret postgres:16
ps aux | grep postgres
docker top db
docker exec db ps aux   # dacă imaginea conține ps

În ps aux pe host apar procesele postgres, cu PID-uri mari, rulate de un utilizator cu UID-ul 999 (utilizatorul postgres din imagine, care poate să nu aibă nume pe host). În container, procesul principal are PID 1, pentru că trăiește în propriul namespace pid. docker top arată aceleași procese, cu PID-urile de pe host.

Ce înveți din asta:

  • Kernelul este unul singur. Nu există un al doilea sistem de operare care bootează, de aceea containerele pornesc rapid și consumă puțină memorie suplimentară.
  • Un utilizator cu acces root pe host vede și poate controla procesele din containere.
  • UID-urile sunt numere, nu nume. Root din container (UID 0) este root pe host, dacă nu folosești user namespaces sau modul rootless. Asta stă la baza recomandării de a nu rula aplicațiile ca root.

Pe Docker Desktop nu vei vedea procesele pe macOS sau Windows, pentru că ele trăiesc în VM-ul Linux.

Ce urmărește intervievatorul: Întrebarea verifică dacă ai înțeles practic, nu din definiții, că un container este un proces. Răspunsul bun menționează și consecința de securitate a UID-urilor.

7 Mid

Ce este OCI și de ce o imagine construită cu Docker rulează și în Podman sau în Kubernetes cu containerd?

Răspuns scurt: Open Container Initiative (OCI) definește standarde deschise pentru formatul imaginilor, pentru runtime și pentru distribuția prin registry. Docker, Podman, containerd și CRI-O respectă aceleași specificații, deci imaginile sunt interschimbabile.

OCI are trei specificații principale:

  • Image spec: cum arată o imagine (manifest, configurație, straturi arhivate, index pentru mai multe platforme).
  • Runtime spec: cum se descrie și se pornește un container dintr-un sistem de fișiere și un fișier de configurație. runc este implementarea de referință.
  • Distribution spec: API-ul HTTP prin care se încarcă și se descarcă imaginile dintr-un registry.

Datorită lor, lanțul este decuplat: construiești imaginea cu Docker sau BuildKit, o publici în orice registry compatibil (Docker Hub, GitHub Container Registry, Amazon ECR, Harbor), iar Kubernetes o rulează prin containerd sau CRI-O, fără Docker instalat pe noduri.

Asta explică o întrebare frecventă de continuare: când Kubernetes a renunțat la dockershim (în versiunea 1.24), imaginile construite cu Docker au continuat să funcționeze exact la fel, pentru că sunt imagini OCI. S-a schimbat doar componenta care le rulează pe noduri.

Podman este o alternativă fără daemon, compatibilă în mare parte cu CLI-ul Docker (podman run, podman build), care rulează implicit rootless. Pentru interviu e suficient să știi că există, că folosește aceleași imagini și că diferențele sunt în arhitectură, nu în formatul artefactului.

Ce urmărește intervievatorul: Se verifică dacă vezi imaginea ca standard, nu ca format proprietar Docker. Candidații se încurcă des la povestea dockershim.

8 Mid

De ce o imagine Docker nu conține un kernel și ce consecințe practice are faptul că toate containerele împart kernelul host-ului?

Răspuns scurt: Containerele sunt procese ale host-ului, deci folosesc kernelul acestuia; imaginea are doar sistemul de fișiere al spațiului utilizator. Consecințele: pornire rapidă și overhead mic, dar și izolare mai slabă decât la o VM și dependență de funcțiile kernelului host-ului.

O imagine ubuntu sau alpine conține doar programele din user space: shell, biblioteca C, managerul de pachete, fișierele din /etc. Nu are kernel și nu bootează nimic. Când rulezi uname -r într-un container, vezi versiunea kernelului host-ului:

BASH
docker run --rm alpine uname -r

Consecințe pe care e bine să le spui:

  • Performanță: nu există emulare de hardware, apelurile de sistem merg direct în kernel, deci overhead-ul CPU e neglijabil.
  • Compatibilitate: aplicația depinde de funcțiile kernelului host-ului. O aplicație care cere un modul de kernel sau o funcție recentă (de exemplu un anumit apel de sistem sau un tip de eBPF) poate să nu meargă pe un host mai vechi, chiar dacă imaginea e aceeași.
  • Setări de kernel: parametrii sysctl globali și modulele încărcate sunt ale host-ului. Doar unii parametri pe namespace pot fi setați per container cu --sysctl.
  • Securitate: o vulnerabilitate în kernel poate permite ieșirea din container către host. De aceea, pentru cod complet neîncrezător (multi-tenant), se folosesc soluții cu izolare suplimentară, precum gVisor sau Kata Containers.
  • Sistem de operare: o imagine Linux nu rulează nativ pe un kernel Windows.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă că înțelegi compromisul dintre viteză și izolare. Răspunsurile slabe se opresc la „containerele sunt mai ușoare”.

9 Senior

Cum este construit sistemul de fișiere al unui container cu driverul overlay2 și ce înseamnă copy-on-write?

Răspuns scurt: overlay2 suprapune straturile read-only ale imaginii (lowerdir) cu un strat writable al containerului (upperdir) într-o singură vedere (merged). La prima modificare a unui fișier din imagine, acesta este copiat întâi în stratul writable: asta e copy-on-write.

OverlayFS este un sistem de fișiere de tip union din kernelul Linux. Docker îl folosește astfel:

  • lowerdir: straturile imaginii, read-only, partajate de toate containerele pornite din aceeași imagine.
  • upperdir: stratul propriu al containerului, unde ajung scrierile.
  • merged: vederea combinată pe care o vede procesul ca /.

Le poți vedea:

BASH
docker inspect -f '{{json .GraphDriver.Data}}' web

Reguli importante:

  • Citirea unui fișier din imagine nu costă nimic suplimentar.
  • La prima scriere într-un fișier existent, kernelul copiază întregul fișier în upperdir (copy-up). Pentru un fișier mare de bază de date, asta înseamnă latență și spațiu dublat.
  • Ștergerea unui fișier din imagine creează un „whiteout” în upperdir; fișierul rămâne fizic în stratul de jos. Același mecanism, la build, explică de ce RUN rm nu micșorează imaginea.
  • Stratul writable dispare la docker rm.

De aici vin recomandările de producție: datele cu scrieri intense (baze de date, cozi, upload-uri) stau în volume, care ocolesc complet stratul overlay, iar containerul în sine se tratează ca efemer. docker ps -s arată cât a crescut stratul writable al fiecărui container și ajută la depistarea aplicațiilor care scriu loguri sau fișiere temporare în container.

Ce urmărește intervievatorul: Se verifică înțelegerea mecanismului din spatele straturilor și a efectelor asupra performanței. Mulți știu de straturi, dar nu știu ce se întâmplă la prima scriere.

Imagini, tag-uri și registry

10 Junior

Cum se citește numele unei imagini precum ghcr.io/firma/api:2.3.1? Ce înseamnă când scrii doar nginx?

Răspuns scurt: Formatul este registry/namespace/repository:tag. Aici registry-ul este ghcr.io, namespace-ul firma, repository-ul api, tag-ul 2.3.1. nginx simplu înseamnă docker.io/library/nginx:latest.

Un nume complet de imagine are patru părți:

  • registry: serverul de unde se descarcă (docker.io, ghcr.io, registry.gitlab.com, 123456789012.dkr.ecr.eu-central-1.amazonaws.com). Dacă lipsește, Docker folosește Docker Hub.
  • namespace: utilizatorul sau organizația. Pe Docker Hub, imaginile oficiale stau în namespace-ul library.
  • repository: numele imaginii.
  • tag: varianta; dacă lipsește, se folosește latest.

Exemple de expandare:

nginx                 -> docker.io/library/nginx:latest
bitnami/redis:7.2     -> docker.io/bitnami/redis:7.2
localhost:5000/app:1  -> registry local pe portul 5000

Poți adăuga și un digest: nginx@sha256:..., care identifică exact conținutul.

Câteva lucruri care se întreabă ca follow-up:

  • latest este doar un tag ca oricare altul, nu înseamnă automat „cea mai nouă versiune”. Este ce a publicat ultima dată autorul cu acel nume.
  • Același conținut poate avea mai multe tag-uri: node:20, node:20.18 și node:lts pot indica aceeași imagine la un moment dat.
  • docker tag nu copiază nimic; adaugă doar un nume nou pentru același ID de imagine. Tocmai de aceea, înainte de docker push către alt registry, retag-uiești imaginea cu numele complet al acelui registry.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi de unde vine o imagine. Greșeala frecventă: a crede că latest se actualizează automat.

Eroarea, în practică:pull access denied, repository does not existmanifest for ... not found: manifest unknown

11 Junior

Care e diferența dintre python:3.12, python:3.12-slim și python:3.12-alpine? Pe care o alegi pentru un API Flask?

Răspuns scurt: Varianta completă are un Debian cu multe unelte de build, slim este un Debian minimal, iar alpine folosește Alpine Linux cu biblioteca musl, foarte mică. Pentru un API Flask, slim este de obicei alegerea sigură.

Variantele oficiale diferă prin sistemul de bază:

  • python:3.12 (Debian complet): include compilatoare, git, biblioteci de dezvoltare. Este mare, dar orice pachet cu extensii native se instalează fără bătăi de cap. Bun pentru etapa de build.
  • python:3.12-slim: Debian cu minimul necesar. Mult mai mică, încă folosește glibc, deci pachetele precompilate (wheels) de pe PyPI merg direct.
  • python:3.12-alpine: bazată pe Alpine, cea mai mică. Folosește musl în loc de glibc, iar apk în loc de apt.

Capcana Alpine pentru Python: multe wheels erau publicate doar pentru glibc, așa că pe Alpine pachete precum numpy sau psycopg se compilau din surse, cu build lent și dependențe suplimentare, iar imaginea finală ajungea uneori mai mare. Situația s-a îmbunătățit odată cu wheels musllinux, dar nu pentru toate pachetele. Pot exista și diferențe subtile de comportament (DNS, locale, performanța alocatorului de memorie).

Pentru un API Flask aș alege python:3.12-slim, cu versiune fixată, eventual cu un build multi-stage în care compilez dependențele pe imaginea completă și copiez doar rezultatul. Alpine merită pentru binare statice sau unelte mici, după ce ai testat aplicația pe ea. Indiferent de variantă, tag-ul fixat (de exemplu 3.12.7-slim-bookworm) face build-ul previzibil.

Ce urmărește intervievatorul: Se verifică dacă alegi imaginea de bază argumentat, nu doar după dimensiune. Mulți nu cunosc capcana musl/glibc.

Eroarea, în practică:exec: "bash": executable file not found in $PATH/bin/sh: apt-get: not found

12 Junior

Primești o imagine necunoscută. Cum afli ce face, fără să o rulezi?

Răspuns scurt: Cu docker image inspect vezi comanda de pornire, entrypoint-ul, variabilele de mediu, portul expus, utilizatorul și arhitectura. Cu docker history vezi straturile și instrucțiunile care le-au creat, cu dimensiunea fiecăruia.

Două comenzi îți dau majoritatea informațiilor:

BASH
docker image inspect --format '{{json .Config}}' imagine | python3 -m json.tool
docker history --no-trunc imagine

Din inspect, secțiunea Config conține:

  • Entrypoint și Cmd: ce se execută la docker run;
  • Env: variabilele implicite, inclusiv PATH;
  • ExposedPorts: porturile documentate cu EXPOSE;
  • User și WorkingDir: cu ce utilizator și din ce folder pornește procesul;
  • Labels: metadate precum autorul, sursa, versiunea;
  • Healthcheck, dacă există.

La nivelul rădăcină apar Architecture, Os și RootFS.Layers (lista de straturi).

docker history arată fiecare instrucțiune din Dockerfile și cât a adăugat. Dacă vezi un strat de sute de MB după un RUN apt-get install, știi de unde vine dimensiunea. Atenție: istoricul poate conține valori trimise prin ARG și comenzi complete, motiv pentru care secretele nu se pun niciodată în argumente de build.

Pentru a explora fișierele, poți crea containerul fără să-l pornești și să-l exporți: docker create --name tmp imagine urmat de docker export tmp | tar -t. Uneltele precum dive arată interactiv conținutul fiecărui strat, iar docker scout sau trivy îți spun ce pachete vulnerabile conține.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi să investighezi singur o imagine. Greșeala tipică este să o rulezi direct, ca root, ca să vezi ce face.

13 Junior

Ce este digestul unei imagini (sha256:...) și prin ce diferă de un tag?

Răspuns scurt: Digestul este hash-ul criptografic al manifestului imaginii: identifică exact un conținut și nu se poate schimba. Tag-ul este o etichetă mutabilă, care poate fi mutată oricând pe altă imagine.

Când faci docker pull nginx:1.27, registry-ul rezolvă tag-ul la un digest și îl afișează:

BASH
docker pull nginx:1.27
# Digest: sha256:...
docker images --digests nginx
docker pull nginx@sha256:<digest>

Diferențe importante:

  • Tag-ul este un pointer. Autorul imaginii poate publica azi nginx:1.27 cu un patch de securitate, iar mâine același tag indică altă imagine. E util pentru actualizări, dar build-ul tău nu mai e identic.
  • Digestul este derivat din conținut. Dacă orice bit din manifest se schimbă, digestul se schimbă. Un FROM nginx@sha256:... produce mereu aceeași bază.
  • Pentru imaginile multi-arhitectură, digestul de la nivel de tag este al unui index (manifest list), care trimite la câte un manifest per platformă, fiecare cu digestul lui.

Unde le folosești:

  • În producție și în CI, fixarea pe digest garantează că rulezi exact ce ai testat. Unelte precum Renovate sau Dependabot pot actualiza digesturile automat, prin pull request.
  • În Kubernetes sau Compose, un image: app@sha256:... elimină ambiguitatea „care versiune rulează de fapt”.

Diferența de ID: docker images afișează un IMAGE ID local, care este hash-ul configurației imaginii, nu digestul din registry. Sunt două valori diferite și se confundă des.

Ce urmărește intervievatorul: Se verifică înțelegerea imuabilității și a reproducibilității. Candidații confundă des IMAGE ID cu digestul.

Eroarea, în practică:manifest for ... not found: manifest unknown

14 Junior

Ai construit local imaginea api:dev. Ce comenzi rulezi ca să o publici în contul tău de Docker Hub și să o descarci pe alt server?

Răspuns scurt: Te autentifici cu docker login, dai imaginii un nume care include utilizatorul și versiunea cu docker tag, o încarci cu docker push, iar pe server rulezi docker pull cu același nume.

Pașii:

BASH
docker login                          # cere utilizator și token de acces
docker tag api:dev ionpopescu/api:1.0.0
docker tag api:dev ionpopescu/api:latest
docker push ionpopescu/api:1.0.0
docker push ionpopescu/api:latest

# pe server
docker pull ionpopescu/api:1.0.0
docker run -d -p 80:8000 ionpopescu/api:1.0.0

Detalii pe care le merită menționate:

  • Numele trebuie să înceapă cu utilizatorul sau organizația ta; un push către api:1.0.0 ar încerca docker.io/library/api, unde nu ai drepturi.
  • La push se trimit doar straturile pe care registry-ul nu le are deja. Dacă schimbi doar codul, se încarcă doar ultimul strat.
  • Pentru autentificare se folosește un access token, nu parola contului, iar în CI tokenul vine dintr-un secret al pipeline-ului, cu docker login --password-stdin.
  • Repository-urile pot fi publice sau private; pe unul privat, serverul trebuie și el autentificat înainte de pull.
  • Dacă serverul are altă arhitectură (de exemplu laptopul e arm64, serverul amd64), imaginea trebuie construită pentru platforma serverului, altfel vei primi eroarea „exec format error” sau un avertisment de platformă.

Pentru alt registry, schimbi doar prefixul: docker tag api:dev ghcr.io/ionpopescu/api:1.0.0.

Ce urmărește intervievatorul: Întrebarea verifică fluxul de distribuție complet. Greșeala frecventă: push fără prefixul de utilizator sau folosirea parolei în loc de token.

Eroarea, în practică:denied: requested access to the resource is deniedAn image does not exist locally with the tag

15 Junior

Ce sunt imaginile <none>:<none> din docker images, de ce docker rmi refuză uneori să șteargă o imagine și cum faci curățenie?

Răspuns scurt: Imaginile <none> sunt „dangling”: au rămas fără tag după ce ai reconstruit aceeași etichetă. docker rmi refuză dacă imaginea e folosită de un container, chiar oprit. Curățenia se face cu docker image prune și docker system prune.

Când rulezi de mai multe ori docker build -t app ., tag-ul app:latest se mută pe imaginea nouă, iar cea veche rămâne fără nume, afișată ca <none>:<none>. Acestea sunt imaginile dangling.

De ce refuză docker rmi:

  • Există un container, chiar oprit, creat din acea imagine: „image is being used by stopped container”. Ștergi întâi containerul sau folosești -f, dar asta lasă containerul fără nume de imagine.
  • Imaginea are mai multe tag-uri: docker rmi app:1 șterge doar tag-ul, nu conținutul, cât timp există și app:latest.

Comenzile de curățenie:

BASH
docker image prune            # doar imaginile dangling
docker image prune -a         # toate imaginile nefolosite de vreun container
docker container prune        # containerele oprite
docker builder prune          # cache-ul de build
docker system df              # cât ocupă fiecare categorie
docker system prune           # containere oprite, rețele nefolosite, dangling, cache

Atenție la două lucruri: docker system prune nu șterge volumele decât cu --volumes, iar prune -a pe un server poate șterge imagini pe care le vei descărca din nou la următorul deploy. Pe mașinile de CI, curățenia periodică (de exemplu cu --filter until=24h) este importantă, altfel discul se umple treptat.

Ce urmărește intervievatorul: Se verifică dacă știi să gestionezi spațiul ocupat de Docker. Mulți rulează prune -a fără să știe ce șterge.

Eroarea, în practică:conflict: unable to remove repository referenceno space left on device

16 Mid

Echipa lucrează pe Mac-uri cu Apple Silicon, iar serverele sunt x86. Ce probleme apar și cum construiești imagini pentru ambele arhitecturi?

Răspuns scurt: Imaginile construite pe Mac sunt implicit linux/arm64 și nu rulează nativ pe servere linux/amd64. Soluția este docker buildx build --platform linux/amd64,linux/arm64, care produce o imagine multi-arhitectură, publicată ca un singur tag.

O imagine conține binare compilate pentru o anumită arhitectură de procesor. Pe un Mac M1/M2/M3, docker build produce linux/arm64. Pe serverul x86, containerul pornește cu „exec format error” sau, dacă e instalată emularea, rulează lent.

Variante:

BASH
# doar pentru server
docker build --platform linux/amd64 -t firma/api:1.4.0 .

# multi-arhitectură, publicată direct în registry
docker buildx create --use
docker buildx build --platform linux/amd64,linux/arm64 \
  -t firma/api:1.4.0 --push .

docker buildx imagetools inspect firma/api:1.4.0

buildx construiește câte o imagine pentru fiecare platformă și publică un index (manifest list) sub același tag. La docker pull, fiecare mașină își ia automat varianta potrivită.

Ce trebuie știut:

  • Build-ul pentru arhitectura străină folosește de obicei emulare QEMU și poate fi mult mai lent, mai ales la compilări. Alternative: noduri de build native pentru fiecare arhitectură sau cross-compilare (Go și Rust o fac ușor, cu ARG TARGETARCH în Dockerfile).
  • Imaginile de bază trebuie să existe pentru ambele platforme; imaginile oficiale de obicei există.
  • O imagine multi-platformă nu se poate încărca simplu în magazia locală clasică de imagini; de aceea se folosește --push sau magazia containerd din Docker Desktop.

Ce urmărește intervievatorul: Intervievatorul verifică dacă ai întâlnit problema reală din echipele cu Mac-uri noi. Greșeala tipică: imaginea merge local și pică în producție fără un mesaj clar.

Eroarea, în practică:exec format error

17 Mid

Cum ai organiza tag-urile imaginilor unui serviciu într-o echipă, astfel încât să știi oricând ce cod rulează și să poți reveni la versiunea anterioară?

Răspuns scurt: Fiecare build primește un tag imuabil, legat de commit (de exemplu SHA-ul scurt), iar release-urile primesc și versiuni semantice. Tag-urile mobile (latest, main) sunt doar pentru comoditate, iar deploy-ul folosește tag-ul imuabil sau digestul.

O schemă practică:

  • api:git-3f9c2ab: pentru fiecare commit construit în CI. Imuabil, nu se suprascrie niciodată; legătura cu codul e directă.
  • api:1.8.2, plus opțional api:1.8 și api:1: la release, după versionarea semantică. Tag-urile scurte se mută la fiecare patch.
  • api:main sau api:latest: indică ultimul build de pe ramura principală, util pentru medii de test, nu pentru producție.

Retag-ul nu cere rebuild. Imaginea testată pe staging devine release prin adăugarea unui nume nou:

BASH
docker pull firma/api:git-3f9c2ab
docker tag firma/api:git-3f9c2ab firma/api:1.8.2
docker push firma/api:1.8.2

Așa ajunge în producție exact artefactul testat. Rollback-ul înseamnă redeploy cu tag-ul anterior, nu reconstruire din cod vechi.

Completări utile:

  • Adaugi metadate standard prin LABEL org.opencontainers.image.revision și org.opencontainers.image.version, ca docker inspect pe server să arate commit-ul.
  • Multe registry-uri permit marcarea tag-urilor ca imuabile (de exemplu Amazon ECR), astfel încât nimeni să nu poată suprascrie o versiune publicată.
  • Stabilești o politică de retenție: păstrezi release-urile, dar ștergi automat build-urile de commit mai vechi de o perioadă convenită.

Ce urmărește intervievatorul: Se verifică gândirea de echipă și trasabilitatea. Răspunsurile slabe se opresc la „nu folosesc latest”, fără să propună o schemă.

18 Mid

Care e diferența dintre docker save/docker load și docker export/docker import? Când ai nevoie de ele?

Răspuns scurt: save/load lucrează cu imagini: păstrează straturile, tag-urile și metadatele (CMD, ENV). export/import lucrează cu sistemul de fișiere al unui container: produce o singură arhivă plată, fără istoric și fără configurație.

Cele două perechi par similare, dar fac lucruri diferite:

BASH
# imagine -> arhivă tar -> imagine
docker save -o api.tar firma/api:1.0
docker load -i api.tar

# container -> sistem de fișiere plat -> imagine nouă
docker export web > web-fs.tar
docker import web-fs.tar web-snapshot:1

save/load:

  • arhiva conține fiecare strat, manifestul și configurația;
  • după load, imaginea are același ID, aceleași tag-uri, același CMD și ENTRYPOINT;
  • poți salva mai multe imagini într-o arhivă și le poți comprima cu gzip.

export/import:

  • iei doar fișierele din container, inclusiv modificările din stratul writable;
  • se pierd istoricul straturilor și metadatele, deci imaginea importată nu știe ce comandă să ruleze; trebuie să i le dai cu --change 'CMD [...]';
  • volumele montate nu sunt incluse.

Când ai nevoie:

  • servere fără acces la internet sau la registry (medii izolate, unele rețele industriale): muți imaginile cu save/load;
  • depanare sau analiză a conținutului unui container;
  • import e util rar, de exemplu pentru a crea o imagine de bază dintr-un rootfs.

În mod normal, distribuția se face printr-un registry, care transferă doar straturile lipsă. Un registry privat local este de obicei o soluție mai bună decât arhive copiate manual.

Ce urmărește intervievatorul: Intervievatorul verifică dacă distingi imaginea de containerul ei. Greșeala tipică: folosirea export pentru backup de imagini și pierderea metadatelor.

Eroarea, în practică:reference does not exist

19 Senior

Compania vrea un registry intern pentru imagini. Ce aspecte ai lua în calcul la alegerea și administrarea lui?

Răspuns scurt: Autentificarea și controlul accesului, scanarea de vulnerabilități, politicile de retenție și curățare, tag-urile imuabile, un cache pentru imaginile publice (pull-through), backup-ul și apropierea de mediile de rulare. Alegi între serviciul cloud-ului folosit și soluții auto-găzduite precum Harbor.

Un registry devine o piesă critică: dacă nu răspunde, nu mai poți face deploy sau autoscalare. Aspectele de analizat:

  • Unde rulează: serviciile gestionate (Amazon ECR, Google Artifact Registry, Azure Container Registry, GitHub Container Registry) elimină întreținerea și se integrează cu IAM-ul cloud-ului. Harbor sau registry-ul open source distribution sunt potrivite on-premise.
  • Acces: conturi pe echipe sau proiecte, tokenuri cu drepturi minime pentru CI (push doar pe repository-ul propriu), acces doar de citire pentru servere.
  • Securitate: scanare automată la push, posibilitatea de a bloca imaginile cu vulnerabilități critice, semnarea imaginilor (de exemplu cu Cosign) și verificarea semnăturii la deploy.
  • Imuabilitate: tag-urile de release nu se pot suprascrie.
  • Retenție: reguli care șterg build-urile vechi de commit, urmate de garbage collection, pentru că ștergerea unui tag nu eliberează automat spațiul straturilor.
  • Proxy cache pentru Docker Hub: Docker Hub aplică limite de pull, mai stricte pentru cererile anonime. Un pull-through cache protejează CI-ul și clusterul de aceste limite și de indisponibilitatea temporară a Docker Hub.
  • Disponibilitate și latență: registry în aceeași regiune cu clusterul, replicare dacă ai mai multe regiuni, monitorizare și backup.

La interviu, structura răspunsului contează: disponibilitate, securitate, costuri de stocare, operare.

Ce urmărește intervievatorul: Se verifică gândirea de platformă la nivel senior. Candidații uită de obicei garbage collection-ul și limitele de pull de pe Docker Hub.

Eroarea, în practică:x509: certificate signed by unknown authority

Instrucțiunile din Dockerfile

Exersează capitolul cu exerciții reale: Curs Docker →
20 Junior

Găsește problemele din acest Dockerfile pentru o aplicație Node.js:

FROM node:latest
COPY . .
RUN npm install
RUN npm run build
EXPOSE 3000
CMD npm start

Răspuns scurt: Imaginea de bază nu e fixată, nu există WORKDIR, codul e copiat înainte de instalarea dependențelor (cache inutil), se folosește npm install în loc de npm ci, rulează ca root, iar CMD în formă shell împiedică primirea corectă a semnalelor.

Pe rând:

  • FROM node:latest: build-ul se schimbă de la sine când apare o versiune nouă de Node. Fixezi o versiune: node:20-slim sau mai exact.
  • Lipsește WORKDIR, deci fișierele ajung direct în /, amestecate cu sistemul.
  • COPY . . înainte de instalare: orice modificare în cod invalidează cache-ul și reinstalează toate dependențele.
  • npm install poate actualiza package-lock.json; npm ci instalează exact ce e în lockfile.
  • Fără .dockerignore, COPY . . aduce node_modules local și .git.
  • Imaginea finală conține și dependențele de dezvoltare.
  • Procesul rulează ca root.
  • CMD npm start rulează prin /bin/sh -c, iar semnalul de oprire ajunge la shell, nu la aplicație.

Varianta corectată:

FROM node:20-slim
WORKDIR /app
ENV NODE_ENV=production
COPY package.json package-lock.json ./
RUN npm ci
COPY . .
RUN npm run build && npm prune --omit=dev
USER node
EXPOSE 3000
CMD ["node", "dist/server.js"]

Imaginea oficială Node are deja utilizatorul node. Pentru o imagine finală și mai mică, build-ul ar trece într-o etapă separată (multi-stage).

Ce urmărește intervievatorul: Exercițiul de review arată rapid nivelul practic. Candidații găsesc de obicei latest, dar ratează ordinea pentru cache și forma shell a lui CMD.

21 Junior

Ce face WORKDIR și de ce nu scrii pur și simplu RUN cd /app?

Răspuns scurt: WORKDIR setează folderul curent pentru instrucțiunile care urmează (RUN, COPY, CMD, ENTRYPOINT) și pentru procesul din container; îl creează dacă nu există. RUN cd /app se pierde imediat, pentru că fiecare RUN pornește într-un shell nou.

Fiecare instrucțiune RUN rulează într-un container intermediar separat, cu un shell nou. Schimbarea de folder dintr-un RUN nu se păstrează pentru următorul:

FROM alpine:3.20
RUN mkdir /app && cd /app
RUN touch fisier.txt      # ajunge în /, nu în /app

Corect:

FROM alpine:3.20
WORKDIR /app
RUN touch fisier.txt      # /app/fisier.txt
COPY config.yaml .        # /app/config.yaml
CMD ["./server"]          # pornește din /app

Ce trebuie să știi despre WORKDIR:

  • Creează automat folderul, cu proprietar root (contează dacă rulezi ulterior ca alt utilizator și aplicația trebuie să scrie acolo).
  • Căile relative se compun: WORKDIR /app urmat de WORKDIR src înseamnă /app/src. Recomandarea este să folosești căi absolute, pentru claritate.
  • Valoarea ajunge în configurația imaginii, deci docker exec -it container sh te duce direct în acel folder.
  • La rulare poți să o suprascrii cu docker run -w /alt/folder.

Dacă totuși ai nevoie de o schimbare temporară de folder, o faci în aceeași comandă: RUN cd /tmp && make install. Este perfect valid, doar că nu are efect după linia respectivă.

Ce urmărește intervievatorul: Întrebarea verifică dacă înțelegi că fiecare RUN e izolat. Greșeala tipică apare la juniorii obișnuiți cu scripturile bash.

Eroarea, în practică:python: can't open file '/app/app.py'Cannot find module '/app/server.js'

22 Junior

Imaginea are EXPOSE 8080. Pornești docker run -d app și nu poți accesa aplicația de pe localhost:8080. De ce?

Răspuns scurt: EXPOSE doar documentează portul pe care ascultă aplicația; nu publică nimic pe host. Ca să ajungi la el de pe laptop, publici portul la rulare cu -p 8080:8080 sau publici toate porturile expuse cu -P.

EXPOSE este o metadată a imaginii. Spune: „procesul din această imagine ascultă pe 8080/tcp”. Efectele lui reale:

  • apare în docker inspect și în docker ps (coloana PORTS, ca 8080/tcp, fără săgeată);
  • este folosit de docker run -P, care publică toate porturile expuse pe porturi aleatorii ale host-ului;
  • servește ca documentație pentru cine folosește imaginea.

Ce nu face: nu deschide portul pe host și nu e o condiție ca alte containere din aceeași rețea să se conecteze. Pe o rețea Docker, containerele își accesează reciproc orice port pe care ascultă procesul, cu sau fără EXPOSE.

Rezolvarea:

BASH
docker run -d -p 8080:8080 app       # host:container
docker run -d -P app                 # port aleatoriu
docker port <container>              # vezi ce port a primit

Dacă după publicare tot nu merge, verifici că aplicația ascultă pe 0.0.0.0, nu pe 127.0.0.1 în interiorul containerului, și că portul din -p (partea dreaptă) coincide cu cel pe care ascultă efectiv aplicația. EXPOSE 8080 nu îl schimbă pe acesta: dacă aplicația pornește pe 3000, EXPOSE nu o mută.

Poți specifica protocolul: EXPOSE 53/udp.

Ce urmărește intervievatorul: Se verifică distincția dintre documentare și publicare. Este una dintre cele mai frecvente confuzii la juniori.

Eroarea, în practică:curl: (7) Failed to connect to localhost port 8080No public port '80/tcp' published for web

23 Junior

Care e diferența dintre forma exec și forma shell la CMD, și de ce docker stop durează 10 secunde pentru containerul de mai jos?

FROM python:3.12-slim
COPY app.py .
CMD python app.py

Răspuns scurt: Forma shell (CMD python app.py) pornește /bin/sh -c, deci shell-ul devine PID 1 și nu transmite SIGTERM aplicației. Docker așteaptă 10 secunde, apoi trimite SIGKILL. Forma exec, CMD ["python", "app.py"], pornește Python direct ca PID 1.

Instrucțiunile CMD, ENTRYPOINT și RUN au două forme:

CMD python app.py              # shell: /bin/sh -c "python app.py"
CMD ["python", "app.py"]       # exec: execve direct, fără shell

La docker stop, Docker trimite SIGTERM procesului cu PID 1 din container și așteaptă implicit 10 secunde; dacă procesul nu s-a oprit, trimite SIGKILL.

În forma shell, PID 1 este sh. Shell-ul nu are un handler pentru SIGTERM și, fiind PID 1, kernelul nu aplică acțiunea implicită de terminare, deci semnalul e ignorat. Python nu află niciodată că trebuie să se oprească, conexiunile nu se închid curat, iar după 10 secunde procesul e omorât. Codul de ieșire va fi 137.

Cu forma exec, Python primește SIGTERM direct. Unele imagini mai noi au sh care face exec automat pentru o singură comandă, dar nu te baza pe asta.

Avantajele formei shell: expandarea variabilelor ($PORT) și operatori ca &&. Dacă ai nevoie de ele, folosești un script entrypoint care se termină cu exec, astfel încât aplicația să înlocuiască shell-ul ca PID 1.

Atenție: forma exec este JSON, deci cere ghilimele duble. CMD ['python', 'app.py'] nu e JSON valid și Docker îl tratează ca formă shell.

Ce urmărește intervievatorul: Se verifică legătura dintre sintaxa Dockerfile și oprirea grațioasă. Candidații știu de obicei că există două forme, dar nu știu consecința asupra semnalelor.

Eroarea, în practică:JSONArgsRecommended: JSON arguments for CMD

24 Junior

Ce comandă rulează efectiv în fiecare caz, pentru imaginea de mai jos?

FROM python:3.12-slim
WORKDIR /app
COPY app.py .
ENTRYPOINT ["python", "app.py"]
CMD ["--port", "5000"]
BASH
docker run img
docker run img --port 8000 --debug
docker run --entrypoint sh img -c 'ls -la'

Răspuns scurt: Primul rulează python app.py --port 5000. Al doilea rulează python app.py --port 8000 --debug, pentru că argumentele înlocuiesc CMD. Al treilea înlocuiește entrypoint-ul și rulează sh -c 'ls -la', iar CMD din imagine este ignorat.

Regula: comanda finală este ENTRYPOINT urmat de CMD, iar argumentele de după numele imaginii din docker run înlocuiesc complet CMD, nu se adaugă la el.

  • docker run img: python app.py --port 5000. CMD furnizează argumentele implicite.
  • docker run img --port 8000 --debug: python app.py --port 8000 --debug. Valorile implicite --port 5000 dispar.
  • docker run --entrypoint sh img -c 'ls -la': entrypoint-ul devine sh, argumentele -c 'ls -la' țin locul lui CMD. Când suprascrii entrypoint-ul la rulare, CMD din imagine este resetat.

Tiparul acesta face imaginea să se comporte ca o unealtă de linie de comandă: utilizatorul trimite doar opțiunile. E folosit des pentru CLI-uri împachetate (de exemplu docker run imagine-cli --help).

Capcane:

  • Dacă ENTRYPOINT e scris în forma shell, CMD și argumentele din docker run sunt ignorate.
  • --entrypoint acceptă doar executabilul; argumentele lui se pun după numele imaginii.
  • În Compose, entrypoint: și command: au aceeași relație ca ENTRYPOINT și CMD.

Pentru depanare, docker run --rm -it --entrypoint sh img este felul standard de a intra într-o imagine al cărei entrypoint pornește aplicația direct.

Ce urmărește intervievatorul: Întrebarea de tip „ce rulează” verifică regula de combinare, nu doar definițiile. Greșeala tipică este să crezi că argumentele se adaugă după CMD.

Eroarea, în practică:No command specifiedMultipleInstructionsDisallowed: multiple CMD

25 Junior

Ce valori vede aplicația la rulare, pentru Dockerfile-ul și comenzile de mai jos?

FROM alpine:3.20
ARG VERSIUNE=1.0
ENV APP_VERSION=$VERSIUNE
ARG MEDIU=dev
CMD ["sh", "-c", "echo $APP_VERSION $MEDIU"]
BASH
docker build --build-arg VERSIUNE=2.5 --build-arg MEDIU=prod -t demo .
docker run --rm demo

Răspuns scurt: Afișează 2.5 urmat de un spațiu gol: APP_VERSION a fost copiată din ARG într-un ENV, deci există în imagine, dar MEDIU este doar ARG și dispare după build.

Diferența de bază:

  • ARG există doar în timpul build-ului. Poate fi setat cu --build-arg și folosit în instrucțiunile de după el (RUN, ENV, COPY). Nu ajunge în mediul containerului.
  • ENV intră în configurația imaginii și este vizibil la build, în instrucțiunile următoare, dar și în fiecare container pornit din imagine. Se poate suprascrie la rulare cu -e.

În exemplu, VERSIUNE primește 2.5 de la --build-arg, iar ENV APP_VERSION=$VERSIUNE îl „îngheață” în imagine. MEDIU primește prod, dar nu e folosit în nicio instrucțiune de build, iar la rulare variabila nu există, așa că shell-ul o înlocuiește cu șir gol.

Alte reguli care apar la follow-up:

  • Un ARG declarat înainte de FROM este vizibil doar în linia FROM (de exemplu FROM node:${NODE_VERSION}). Ca să-l folosești după, îl redeclari fără valoare: ARG NODE_VERSION.
  • Într-un build multi-stage, fiecare etapă trebuie să-și redeclare argumentele.
  • Schimbarea valorii unui ARG invalidează cache-ul de la primul loc în care este folosit.
  • Niciuna dintre ele nu e potrivită pentru secrete: valorile ARG pot apărea în docker history, iar ENV se vede în docker inspect. Pentru secrete la build se folosește RUN --mount=type=secret.

Ce urmărește intervievatorul: Se verifică ciclul de viață al variabilelor de build față de cele de rulare. Candidații presupun des că ARG ajunge și în container.

Eroarea, în practică:base name (${BASE_IMAGE}) should not be blankUndefinedVar: Usage of undefined variable

26 Junior

La ce folosește instrucțiunea LABEL și ce etichete merită puse pe imaginile unei echipe?

Răspuns scurt: LABEL adaugă metadate cheie-valoare în configurația imaginii, fără să creeze fișiere. Merită puse etichetele standard OCI: sursa codului, commit-ul, versiunea, data build-ului și echipa responsabilă.

LABEL scrie perechi cheie-valoare în configurația imaginii. Nu influențează rularea, dar face imaginea auto-descriptivă:

ARG GIT_SHA=unknown
ARG VERSION=0.0.0
LABEL org.opencontainers.image.source="https://github.com/firma/api" \
      org.opencontainers.image.revision=$GIT_SHA \
      org.opencontainers.image.version=$VERSION \
      org.opencontainers.image.title="api-comenzi" \
      ro.firma.echipa="plati"
BASH
docker build --build-arg GIT_SHA=$(git rev-parse --short HEAD) --build-arg VERSION=1.4.0 -t api .
docker inspect -f '{{json .Config.Labels}}' api
docker images --filter label=ro.firma.echipa=plati

De ce contează:

  • Pe un server cu zeci de containere, docker inspect îți spune imediat din ce commit provine fiecare, fără să cauți prin pipeline.
  • Registry-urile și scanerele afișează aceste etichete. GitHub Container Registry, de exemplu, leagă imaginea de repository prin org.opencontainers.image.source.
  • Filtrele după etichete (--filter label=...) ajută la curățenie și raportare.
  • Unele unelte (Traefik, de exemplu) citesc etichete de pe containere pentru configurare, dar acelea se pun de obicei la rulare, în Compose.

Convenția este să folosești prefixul org.opencontainers.image. pentru câmpurile standard și un domeniu inversat propriu pentru cele interne. Instrucțiunea MAINTAINER este învechită; în locul ei se folosește o etichetă. Etichetele cu valori variabile se pun spre finalul Dockerfile-ului, ca să nu invalideze cache-ul straturilor grele.

Ce urmărește intervievatorul: Se verifică dacă te gândești la trasabilitate, nu doar la funcționare. Puțini juniori știu de etichetele standard OCI.

27 Junior

De ce acest Dockerfile poate instala, după câteva săptămâni, o versiune veche sau poate da eroare la apt-get install?

FROM debian:bookworm-slim
RUN apt-get update
RUN apt-get install -y curl

Răspuns scurt: apt-get update e într-un strat separat, care rămâne în cache. Când modifici linia de instalare, Docker refolosește indexul vechi de pachete, care poate indica versiuni care nu mai există pe mirror. Cele două comenzi se pun în același RUN.

Cache-ul de build se bazează pe textul instrucțiunii. Linia RUN apt-get update nu se schimbă niciodată, deci Docker o refolosește oricât de vechi ar fi indexul de pachete descărcat atunci. Peste câteva săptămâni adaugi un pachet în linia a doua, iar apt-get install lucrează cu un index învechit. Rezultatul: versiuni vechi sau erori 404, pentru că mirror-ul nu mai are fișierele respective.

Forma corectă:

FROM debian:bookworm-slim
RUN apt-get update \
 && apt-get install -y --no-install-recommends curl ca-certificates \
 && rm -rf /var/lib/apt/lists/*

Ce face fiecare parte:

  • update și install în același strat: orice schimbare în lista de pachete reface și update-ul.
  • --no-install-recommends evită pachetele recomandate, care pot adăuga zeci de MB.
  • rm -rf /var/lib/apt/lists/* șterge indexul în același strat, deci nu ajunge în imagine. Într-un RUN separat nu ar mai micșora nimic.
  • Pachetele se listează câte unul pe linie, în ordine alfabetică, pentru diff-uri clare.

Dacă vrei reproducibilitate, fixezi versiunile (curl=7.88.1-10+deb12u8), cu costul că trebuie actualizate manual. Pentru a forța reîmprospătarea întregului build, docker build --no-cache --pull. Aceeași logică se aplică la apk add --no-cache pe Alpine, care nu păstrează deloc indexul.

Ce urmărește intervievatorul: Este un bug clasic de cache. Intervievatorul verifică dacă știi că cache-ul nu ține cont de timp, ci de textul instrucțiunii.

Eroarea, în practică:E: Unable to locate package (în Dockerfile)

28 Junior

Cum creezi un utilizator neprivilegiat într-un Dockerfile și îl folosești pentru aplicație? Scrie varianta pentru Debian și pentru Alpine.

Răspuns scurt: Creezi utilizatorul cu useradd (Debian) sau adduser -S (Alpine), dai drepturi doar pe ce trebuie scris, apoi treci la el cu USER. Toate instrucțiunile și procesul containerului rulează de atunci cu acel utilizator.

Debian/Ubuntu:

FROM python:3.12-slim
RUN groupadd --system --gid 1001 app \
 && useradd --system --uid 1001 --gid app --no-create-home app
WORKDIR /app
COPY --chown=app:app . .
USER app
CMD ["python", "server.py"]

Alpine:

FROM node:20-alpine
RUN addgroup -S -g 1001 app && adduser -S -u 1001 -G app app
WORKDIR /app
COPY --chown=app:app . .
USER app
CMD ["node", "server.js"]

Detalii care contează:

  • USER afectează toate instrucțiunile următoare, inclusiv RUN. Instalările de pachete se fac deci înainte de USER, cât ești încă root.
  • UID-ul fix (1001) ajută la permisiunile pe volume și la politicile din Kubernetes, care pot cere runAsNonRoot. Poți scrie și USER 1001, ceea ce permite verificarea că nu e root fără să citești /etc/passwd.
  • Codul poate rămâne proprietatea root și doar citibil pentru aplicație; dai drept de scriere doar pe folderele de care e nevoie (/app/uploads, /tmp). Așa, o vulnerabilitate în aplicație nu poate modifica codul.
  • Un utilizator neprivilegiat nu poate asculta pe porturi sub 1024 fără capability, deci aplicația ascultă pe 8080 sau 3000.
  • Multe imagini oficiale au deja un utilizator: node în imaginile Node, nginx în varianta nginx-unprivileged.

La rulare, docker run --user suprascrie valoarea din imagine.

Ce urmărește intervievatorul: Se verifică aplicarea practică a principiului de securitate. Greșeala frecventă: USER pus prea devreme, înainte de instalarea pachetelor, și build-ul pică.

Eroarea, în practică:unable to find user: no matching entries in passwdPermissionError: [Errno 13] Permission denied

29 Mid

Cum funcționează HEALTHCHECK într-un Dockerfile și ce face Docker când containerul devine unhealthy?

Răspuns scurt: HEALTHCHECK definește o comandă rulată periodic în container; codul de ieșire 0 înseamnă sănătos, 1 nesănătos. Docker doar marchează starea healthy/unhealthy și o expune; un container standalone nu este repornit automat din cauza ei.

Sintaxa:

HEALTHCHECK --interval=30s --timeout=3s --start-period=20s --retries=3 \
  CMD curl -fsS http://localhost:8080/health || exit 1
  • --interval: cât de des rulează verificarea.
  • --timeout: după cât timp o rulare e considerată eșuată.
  • --start-period: perioada de pornire în care eșecurile nu se numără.
  • --retries: câte eșecuri consecutive duc la unhealthy.

Starea apare în docker ps și în detaliu în docker inspect --format '{{json .State.Health}}' api, cu ultimele rezultate și ieșirea comenzii.

Ce face Docker cu ea:

  • În Docker Engine simplu, nimic automat: politica --restart reacționează doar la oprirea procesului, nu la unhealthy. Ai nevoie de un orchestrator sau de o unealtă externă.
  • În Compose, depends_on cu condition: service_healthy așteaptă starea healthy înainte să pornească serviciul dependent.
  • Docker Swarm înlocuiește containerele nesănătoase.
  • Kubernetes ignoră HEALTHCHECK din imagine și folosește propriile probe.

Capcane: comanda rulează în container, deci curl trebuie să existe în imagine. Pe imagini minimale folosești un binar mic propriu sau un script în limbajul aplicației. Endpoint-ul de sănătate trebuie să fie ieftin; altfel, verificările frecvente pun presiune pe aplicație. HEALTHCHECK NONE dezactivează verificarea moștenită din imaginea de bază.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi limitele lui HEALTHCHECK. Mulți candidați cred că Docker repornește automat containerele nesănătoase.

Eroarea, în practică:dependency failed to start: container is unhealthycontainer has no healthcheck configured

30 Mid

De ce scripturile docker-entrypoint.sh din imaginile oficiale se termină cu exec "$@"? Scrie un astfel de script care așteaptă baza de date și rulează migrările.

Răspuns scurt: Scriptul face pregătirile, apoi exec "$@" înlocuiește procesul shell cu comanda primită din CMD. Aplicația devine PID 1, primește direct semnalele, iar utilizatorul poate încă suprascrie comanda la docker run.

Tiparul combină un ENTRYPOINT cu un CMD:

COPY docker-entrypoint.sh /usr/local/bin/
RUN chmod +x /usr/local/bin/docker-entrypoint.sh
ENTRYPOINT ["docker-entrypoint.sh"]
CMD ["gunicorn", "-b", "0.0.0.0:8000", "app:app"]
BASH
#!/bin/sh
set -e

if [ -n "$DB_HOST" ]; then
  echo "Aștept baza de date pe $DB_HOST:5432..."
  until nc -z "$DB_HOST" 5432; do sleep 1; done
fi

if [ "$RUN_MIGRATIONS" = "1" ]; then
  python manage.py migrate --noinput
fi

exec "$@"

De ce exec: fără el, shell-ul rămâne PID 1 și pornește aplicația ca proces copil. La docker stop, SIGTERM ajunge la shell, care nu îl transmite, iar aplicația e omorâtă forțat după timeout. Cu exec, procesul shell este înlocuit de aplicație.

De ce "$@": conține argumentele primite de entrypoint, adică CMD sau ce scrie utilizatorul după numele imaginii. Ghilimelele păstrează argumentele cu spații. Așa, docker run img python manage.py shell trece prin aceleași pregătiri, dar rulează altă comandă.

Atenție: set -e oprește scriptul la prima eroare; scriptul trebuie să aibă terminații de linie Unix (LF) și drept de execuție, altfel apare „no such file or directory” la pornire. Imaginea trebuie să conțină nc (netcat). Așteptarea bazei de date în entrypoint e utilă, dar aplicația ar trebui oricum să-și refacă singură conexiunea.

Ce urmărește intervievatorul: Se verifică înțelegerea legăturii dintre entrypoint, CMD și semnale. Greșeala tipică: lipsa lui exec sau un script salvat cu terminații de linie Windows.

Eroarea, în practică:FATAL: the database system is starting up

31 Mid

De ce variabila nu există în al doilea RUN și nici în container? Cum o faci disponibilă?

FROM alpine:3.20
RUN export API_URL=https://api.exemplu.ro
RUN echo "URL: $API_URL"
CMD ["sh", "-c", "echo $API_URL"]

Răspuns scurt: Fiecare RUN rulează într-un shell nou, iar export afectează doar acel shell, care se termină odată cu instrucțiunea. Pentru o valoare persistentă folosești ENV; pentru una necesară doar la build, ARG sau aceeași linie RUN.

Un strat de imagine salvează sistemul de fișiere, nu starea procesului. Variabilele de mediu, folderul curent sau procesele pornite într-un RUN dispar când containerul intermediar se oprește. Al doilea RUN afișează URL: , iar containerul afișează o linie goală.

Variante corecte, după nevoie:

# disponibilă la build și la rulare
ENV API_URL=https://api.exemplu.ro

# doar la build, configurabilă din exterior
ARG API_URL=https://api.exemplu.ro
RUN echo "URL: $API_URL"

# doar într-o singură comandă
RUN export API_URL=https://api.exemplu.ro && ./configure.sh

Același principiu explică alte surprize:

  • RUN service nginx start nu lasă nginx pornit; procesul moare odată cu stratul. Procesul principal se pornește din CMD.
  • RUN source venv/bin/activate nu activează mediul virtual pentru restul build-ului. Soluția obișnuită este ENV PATH="/opt/venv/bin:$PATH".
  • Fișierele create rămân, deci RUN echo 'export X=1' >> ~/.bashrc „funcționează” doar pentru shell-urile interactive bash, nu pentru CMD în forma exec.

Pentru configurații care diferă între medii (URL-ul de API în test față de producție), valoarea nu se pune în imagine: imaginea rămâne aceeași, iar variabila se dă la rulare cu -e sau --env-file.

Ce urmărește intervievatorul: Întrebarea verifică modelul mental al straturilor: se salvează fișiere, nu procese. Juniorii încearcă des RUN export sau RUN source.

Eroarea, în practică:UndefinedVar: Usage of undefined variable

32 Mid

De ce imaginea crește cu 300 MB după ultima linie și cum rescrii Dockerfile-ul?

FROM node:20-slim
WORKDIR /app
COPY . .
RUN npm ci
RUN chown -R node:node /app
USER node

Răspuns scurt: chown -R modifică metadatele fiecărui fișier, iar din cauza copy-on-write fiecare fișier modificat este copiat integral într-un strat nou. node_modules ajunge practic de două ori în imagine. Soluția: COPY --chown și rularea npm ci direct ca utilizatorul final.

Straturile se stochează ca diferențe de fișiere. Când un RUN schimbă proprietarul unui fișier, chiar fără să-i schimbe conținutul, stratul nou conține o copie completă a fișierului cu noile metadate. chown -R /app atinge tot node_modules, deci dimensiunea se dublează. Același efect îl au chmod -R și touch pe multe fișiere.

Variantă corectă:

FROM node:20-slim
WORKDIR /app
RUN chown node:node /app
USER node
COPY --chown=node:node package.json package-lock.json ./
RUN npm ci --omit=dev
COPY --chown=node:node . .
CMD ["node", "server.js"]
  • COPY --chown setează proprietarul în momentul copierii, deci fișierele ajung o singură dată în imagine. Există și COPY --chmod, cu BuildKit.
  • npm ci rulat după USER node creează node_modules deja cu proprietarul corect.
  • chown se face doar pe folderul gol /app, ceea ce nu costă nimic.

Merită întrebat și dacă aplicația trebuie să poată scrie peste propriul cod. De multe ori, mai sigur este ca fișierele să rămână ale lui root, doar citibile, iar utilizatorul aplicației să primească drept de scriere doar pe un folder dedicat.

Cum depistezi problema: docker history imagine arată dimensiunea fiecărui strat, iar dive arată fișierele duplicate între straturi.

Ce urmărește intervievatorul: Se verifică înțelegerea costului straturilor dincolo de „mai puține instrucțiuni”. Puțini candidați știu că schimbarea proprietarului copiază fișierele.

33 Mid

Scrie un Dockerfile pentru o aplicație Spring Boot construită cu Maven, astfel încât build-urile repetate să fie rapide și imaginea finală să conțină doar un JRE.

Răspuns scurt: Folosești un build multi-stage: în prima etapă, cu JDK și Maven, copiezi întâi pom.xml și descarci dependențele, apoi sursele și construiești jar-ul. Etapa finală pornește de la o imagine JRE și copiază doar jar-ul.

FROM maven:3.9-eclipse-temurin-21 AS build
WORKDIR /src
COPY pom.xml .
RUN mvn -B -q dependency:go-offline
COPY src ./src
RUN mvn -B -q package -DskipTests

FROM eclipse-temurin:21-jre
WORKDIR /app
RUN useradd --system --uid 1001 spring
COPY --from=build /src/target/*.jar app.jar
USER spring
EXPOSE 8080
ENTRYPOINT ["java", "-XX:MaxRAMPercentage=75", "-jar", "/app/app.jar"]

De ce este construit așa:

  • pom.xml copiat separat: stratul cu dependențele descărcate rămâne în cache cât timp nu modifici dependențele, deci o schimbare de cod reface doar compilarea.
  • dependency:go-offline nu prinde chiar toate plugin-urile, dar acoperă majoritatea. Cu BuildKit poți adăuga RUN --mount=type=cache,target=/root/.m2 pentru un cache Maven persistent între build-uri.
  • Etapa finală nu are Maven, JDK sau surse, deci e mai mică și cu mai puține pachete vulnerabile.
  • -XX:MaxRAMPercentage=75 face ca heap-ul să fie calculat din limita de memorie a containerului, nu din memoria host-ului.
  • Forma exec a lui ENTRYPOINT lasă JVM-ul să primească SIGTERM, iar Spring Boot face oprirea grațioasă dacă ai setat server.shutdown=graceful.

Testele se rulează de obicei separat în CI. Pentru Spring Boot există și extragerea pe straturi a jar-ului (layertools), care separă dependențele de cod pentru un cache și mai bun.

Ce urmărește intervievatorul: Se verifică aplicarea cache-ului și a multi-stage pe un stack concret. Greșeala tipică este COPY . . urmat de mvn package, care descarcă dependențele la fiecare build.

34 Senior

Două build-uri ale aceluiași commit, făcute la o lună distanță, produc imagini diferite și una dintre ele are un bug. Cum faci build-urile Docker reproductibile?

Răspuns scurt: Fixezi tot ce poate varia: imaginea de bază pe digest, versiunile pachetelor de sistem, dependențele aplicației prin lockfile, uneltele descărcate cu versiune și checksum. Build-ul pentru release se face o singură dată, iar artefactul se promovează între medii.

Surse tipice de variație și cum le elimini:

  • Imaginea de bază: FROM python:3.12-slim se mută pe imagini noi. Fixezi digestul: FROM python:3.12-slim@sha256:..., iar actualizările vin controlat, prin pull request-uri automate (Renovate, Dependabot).
  • Pachetele de sistem: apt-get install curl instalează ce există azi. Fixezi versiuni sau folosești snapshot-uri ale depozitelor (Debian are snapshot.debian.org).
  • Dependențele aplicației: lockfile obligatoriu (package-lock.json, poetry.lock, go.sum) și comenzi care îl respectă (npm ci, pip install --require-hashes).
  • Descărcări directe: curl ... | sh fără versiune e o problemă de reproducibilitate și de securitate. Descarci o versiune explicită și verifici checksum-ul:
ARG TOOL_VERSION=1.2.3
ARG TOOL_SHA256=<checksum publicat>
RUN curl -fsSLo /tmp/tool.tgz https://example.org/tool-${TOOL_VERSION}.tgz \
 && echo "${TOOL_SHA256}  /tmp/tool.tgz" | sha256sum -c -
  • Contextul de build: un .dockerignore strict împiedică fișierele locale să schimbe imaginea.
  • Timestamp-uri: BuildKit suportă SOURCE_DATE_EPOCH pentru a obține imagini identice bit cu bit, util când vrei să verifici că o imagine provine dintr-un anumit cod.

La fel de important este procesul: nu reconstruiești imaginea pentru producție. Construiești o dată, testezi și promovezi același digest. Pentru audit adaugi un SBOM și provenance la build (docker buildx build --sbom=true --provenance=true).

Ce urmărește intervievatorul: Se verifică maturitatea în gestionarea dependențelor. Răspunsurile slabe se opresc la tag-ul fixat, fără digest și fără lockfile.

Build: context, cache, multi-stage

35 Junior

Ce înseamnă punctul din docker build -t app . și de ce primești eroarea de mai jos?

COPY ../shared/config.yaml /app/
# failed to compute cache key: "/shared/config.yaml": not found

Răspuns scurt: Punctul este contextul de build: folderul ale cărui fișiere sunt trimise builder-ului. COPY poate accesa doar fișiere din context, deci ../shared nu este disponibil. Mărești contextul sau muți fișierul.

La docker build, CLI-ul trimite builder-ului (BuildKit) conținutul contextului, adică folderul dat ca ultim argument. Toate căile sursă din COPY și ADD sunt relative la context, iar .. nu poate ieși din el, din motive de securitate și reproducibilitate.

Soluții:

BASH
# context din folderul părinte, Dockerfile indicat explicit
docker build -f api/Dockerfile -t app ..
# în Dockerfile, căile devin relative la noul context
COPY shared/config.yaml /app/
COPY api/ /app/

Alte variante:

  • Cu BuildKit poți folosi contexte suplimentare: docker buildx build --build-context shared=../shared ., iar în Dockerfile COPY --from=shared config.yaml /app/.
  • Muți fișierul în proiect sau îl generezi la build.

Ce mai trebuie știut despre context:

  • Dimensiunea lui contează. Dacă rulezi build-ul din folderul home sau dintr-un proiect cu node_modules și .git mari, primul pas durează mult. BuildKit transferă doar ce e folosit și pe bază incrementală, dar un .dockerignore rămâne esențial.
  • Fișierul Dockerfile nu trebuie să fie în context, iar -f poate indica orice cale.
  • Contextul poate fi și un URL Git: docker build https://github.com/firma/api.git#main.
  • docker build - < Dockerfile construiește fără context, util pentru imagini care nu copiază fișiere.

Ce urmărește intervievatorul: Se verifică înțelegerea a ce primește builder-ul. Eroarea de mai sus apare des în monorepo-uri.

Eroarea, în practică:COPY: failed to calculate checksum: not found"docker buildx build" requires exactly 1 argument

36 Junior

Ce ai pune într-un .dockerignore pentru un proiect Node.js și ce riscuri de securitate apar dacă îl lipsește?

Răspuns scurt: Pui node_modules, .git, fișierele .env, logurile, build-urile locale, folderele de teste și configurațiile IDE. Fără el, COPY . . poate pune în imagine chei, parole și istoricul Git, care rămân accesibile oricui descarcă imaginea.

Un exemplu:

node_modules
npm-debug.log*
dist
coverage
.git
.gitignore
.env
.env.*
!.env.example
*.pem
.vscode
.idea
Dockerfile
docker-compose*.yml
README.md

Sintaxa seamănă cu .gitignore: tipare glob, ** pentru orice nivel, ! pentru excepții. Fișierul trebuie să fie în rădăcina contextului; începând cu BuildKit poți avea și un Dockerfile.dockerignore lângă un Dockerfile anume.

Riscurile când lipsește:

  • Secrete în imagine: .env cu parole de bază de date, chei .pem, fișiere de credențiale. Oricine are acces la imagine le poate extrage cu docker create și docker cp, chiar dacă aplicația nu le folosește.
  • Istoric Git: folderul .git conține tot istoricul, inclusiv secretele șterse în commit-uri vechi.
  • Binare incompatibile: node_modules construit pe macOS conține module native compilate pentru alt sistem și poate suprascrie ce a instalat npm ci în imagine.
  • Cache invalidat inutil: modificări în loguri sau în .git schimbă rezultatul lui COPY . . și reconstruiesc straturile.

Dacă un secret a ajuns deja într-o imagine publicată, ștergerea fișierului în versiunea următoare nu ajunge: secretul trebuie rotit (schimbat), pentru că imaginea veche poate fi deja descărcată.

Ce urmărește intervievatorul: Intervievatorul verifică dacă vezi .dockerignore ca protecție de securitate, nu doar ca optimizare. Puțini menționează istoricul Git.

Eroarea, în practică:COPY: failed to calculate checksum: not founderror from sender: open ...: permission denied

37 Junior

Ai construit o dată imaginea de mai jos. Modifici apoi doar src/routes.js și rulezi din nou docker build. Care pași vor fi CACHED?

FROM node:20-slim
WORKDIR /app
RUN apt-get update && apt-get install -y --no-install-recommends tini
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build
CMD ["tini", "--", "node", "dist/server.js"]

Răspuns scurt: FROM, WORKDIR, apt-get, COPY package*.json și npm ci vin din cache. COPY . . se reface, pentru că s-a schimbat un fișier copiat, iar npm run build se reface și el, fiind după un pas invalidat.

Builder-ul verifică fiecare instrucțiune în ordine:

  • Pentru RUN, cheia de cache este textul comenzii plus stratul anterior. Comanda apt-get nu s-a schimbat, deci e refolosită.
  • Pentru COPY și ADD, cheia include un checksum al conținutului fișierelor copiate (nu data modificării). package*.json nu s-au schimbat, deci și npm ci rămâne în cache.
  • COPY . . include src/routes.js, deci checksum-ul diferă și pasul se reface.
  • Odată ce un pas a fost invalidat, toți pașii de după se refac, chiar dacă textul lor e identic. De aceea npm run build rulează din nou.

Ordinea din Dockerfile urmează regula: ce se schimbă rar, sus; ce se schimbă des, jos. Instalarea dependențelor e costisitoare și depinde doar de manifeste, deci stă înaintea codului.

Situații care invalidează mai mult decât te aștepți:

  • Modifici package.json doar ca să schimbi versiunea aplicației: npm ci se reface.
  • Imaginea de bază s-a actualizat și folosești --pull: totul se reface.
  • Un ARG cu valoare nouă (de exemplu commit-ul) declarat sus invalidează toți pașii care îl folosesc; se declară cât mai jos.

Pentru diagnostic, docker build --progress=plain . afișează clar care pași sunt CACHED.

Ce urmărește intervievatorul: Exercițiul verifică regula de invalidare în lanț. Candidații uită des că pașii de după unul invalidat se refac toți.

38 Junior

Când folosești docker build --no-cache și când --pull? Ce diferență este între ele?

Răspuns scurt: --no-cache ignoră straturile din cache și rulează din nou fiecare instrucțiune. --pull verifică în registry dacă imaginea din FROM are o versiune nouă sub același tag și o descarcă. Pentru un build complet proaspăt le folosești împreună.

Sunt două probleme diferite:

  • Cache-ul local poate conține rezultatul unui RUN vechi, de exemplu un apt-get upgrade sau un git clone de acum o lună. Docker nu știe că lumea de afară s-a schimbat, pentru că textul comenzii e același. --no-cache forțează rularea tuturor pașilor.
  • Imaginea de bază locală poate fi veche. Fără --pull, dacă ai deja python:3.12-slim local, Docker o folosește chiar dacă în registry există o versiune nouă, cu patch-uri de securitate. --pull verifică digestul de la distanță.
BASH
docker build --pull -t api:1.5 .              # bază actualizată, cache pentru restul
docker build --pull --no-cache -t api:1.5 .   # totul proaspăt

Când le folosești:

  • Build-urile programate (de exemplu nocturne sau săptămânale) pentru imaginile de bază ale companiei: --pull --no-cache, ca să intre ultimele patch-uri.
  • Depanare: suspectezi că un strat din cache e stricat sau conține ceva vechi.
  • Build-urile obișnuite din CI: de obicei cu cache, pentru viteză, și cu --pull, ca să nu folosești o bază prea veche.

Există și opțiuni mai fine: --no-cache-filter <etapă> invalidează doar o etapă dintr-un build multi-stage. Un truc frecvent este un ARG CACHEBUST folosit într-un RUN, care invalidează de la acel pas încolo când îi dai o valoare nouă.

Ce urmărește intervievatorul: Se verifică dacă știi de ce cache-ul poate ascunde actualizări de securitate. Mulți confundă cele două opțiuni.

39 Mid

Cum folosești --target într-un Dockerfile multi-stage ca să ai, din același fișier, o imagine de dezvoltare, una de teste și una de producție?

Răspuns scurt: Definești etape cu nume (AS dev, AS test, AS prod) care pornesc dintr-o etapă comună, iar docker build --target <etapă> se oprește la etapa cerută. Cu BuildKit se construiesc doar etapele de care depinde ținta.

Un exemplu pentru Python:

FROM python:3.12-slim AS base
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

FROM base AS dev
COPY requirements-dev.txt .
RUN pip install --no-cache-dir -r requirements-dev.txt
CMD ["flask", "--app", "app", "run", "--host", "0.0.0.0", "--debug"]

FROM dev AS test
COPY . .
RUN pytest -q

FROM base AS prod
COPY . .
RUN useradd --system app
USER app
CMD ["gunicorn", "-b", "0.0.0.0:8000", "app:app"]
BASH
docker build --target dev -t api:dev .
docker build --target test .           # pică dacă testele pică
docker build -t api:1.0 .              # fără target: ultima etapă, prod

Ce câștigi:

  • Un singur Dockerfile, o singură sursă pentru dependențe; mediile nu se mai despart în timp.
  • BuildKit analizează graful și sare peste etapele care nu sunt necesare. Când construiești prod, etapele dev și test nu rulează. Cu builder-ul vechi, toate etapele de dinainte de țintă se construiau.
  • Etapa finală nu conține uneltele de test, dar ele sunt reproductibile.

În Compose, build: { context: ., target: dev } alege etapa pentru mediul local. Poți folosi COPY --from și pentru imagini externe, de exemplu COPY --from=ghcr.io/astral-sh/uv:0.4 /uv /bin/uv, ca să iei un binar fără să-l instalezi.

Ce urmărește intervievatorul: Se verifică folosirea multi-stage dincolo de „imagine mai mică”. Mulți nu știu că BuildKit construiește doar etapele necesare țintei.

Eroarea, în practică:target stage "productie" could not be found

40 Mid

Scrie un Dockerfile multi-stage pentru o aplicație React (Vite) servită de nginx, cu suport pentru rutele aplicației (refresh pe /produse/12).

Răspuns scurt: Prima etapă, pe Node, instalează dependențele și rulează npm run build. A doua pornește de la nginx, copiază doar folderul dist și o configurație care trimite rutele necunoscute la index.html (try_files).

FROM node:20-slim AS build
WORKDIR /app
COPY package.json package-lock.json ./
RUN npm ci
COPY . .
ARG VITE_API_URL=/api
ENV VITE_API_URL=$VITE_API_URL
RUN npm run build

FROM nginx:1.27-alpine
COPY nginx.conf /etc/nginx/conf.d/default.conf
COPY --from=build /app/dist /usr/share/nginx/html
EXPOSE 80

nginx.conf:

server {
  listen 80;
  root /usr/share/nginx/html;
  location / {
    try_files $uri $uri/ /index.html;
  }
  location /assets/ {
    expires 1y;
    add_header Cache-Control "public, immutable";
  }
}

Explicații:

  • Imaginea finală are doar nginx și fișierele statice, câteva zeci de MB, fără Node și fără node_modules.
  • try_files rezolvă problema de la refresh: fără el, nginx caută fișierul /produse/12, nu-l găsește și răspunde 404, deși ruta există în React Router.
  • Fișierele din assets/ au nume cu hash generat de Vite, deci pot fi cache-uite agresiv; index.html nu.

Capcană importantă: variabilele VITE_* sunt înglobate în JavaScript la build, nu citite la rulare. Imaginea are deci URL-ul de API fixat. Dacă vrei aceeași imagine în mai multe medii, folosești căi relative (/api, cu nginx ca reverse proxy) sau un fișier de configurație generat la pornirea containerului.

Ce urmărește intervievatorul: Se verifică un caz practic foarte frecvent. Candidații uită try_files și nu știu că variabilele de frontend se fixează la build.

41 Mid

Ce aduce BuildKit față de builder-ul clasic și cum folosești RUN --mount=type=cache?

Răspuns scurt: BuildKit (implicit din Docker 23.0) construiește etapele independente în paralel, sare peste cele inutile, oferă cache exportabil, secrete și chei SSH la build și mount-uri de cache. RUN --mount=type=cache păstrează între build-uri un folder, de exemplu cache-ul pip sau npm, fără să-l pună în imagine.

Funcții importante:

  • Graful de build: etapele independente rulează în paralel, iar cele de care ținta nu depinde nu se construiesc.
  • Transfer incremental al contextului: se trimite doar ce s-a schimbat.
  • RUN --mount=type=secret și --mount=type=ssh: acces la secrete și chei fără să rămână în straturi.
  • Cache exportabil (--cache-to, --cache-from) pentru CI.
  • Sintaxe noi: heredoc-uri în RUN, COPY --chmod, COPY --link.

Cache mount:

# syntax=docker/dockerfile:1
FROM python:3.12-slim
WORKDIR /app
COPY requirements.txt .
RUN --mount=type=cache,target=/root/.cache/pip \
    pip install -r requirements.txt

Problema pe care o rezolvă: când requirements.txt se schimbă și un singur pachet e nou, cache-ul de strat e invalidat și pip descarcă din nou totul. Cu cache mount, folderul /root/.cache/pip persistă pe mașina de build între rulări, iar pip descarcă doar pachetul nou. Folderul nu face parte din imagine, deci nu trebuie nici --no-cache-dir.

Echivalente: /root/.npm pentru npm, /root/.m2 pentru Maven, /go/pkg/mod și /root/.cache/go-build pentru Go, /var/cache/apt pentru apt (cu ajustări de configurare).

Limitare: cache mount-ul este local builder-ului. Pe runner-e CI efemere dispare odată cu mașina, deci acolo cache-ul de straturi exportat în registry contează mai mult.

Ce urmărește intervievatorul: Se verifică familiaritatea cu builder-ul modern. Răspunsurile slabe nu fac diferența dintre cache-ul de straturi și cache mount.

42 Mid

Aplicația are nevoie de un token pentru a instala pachete dintr-un registry npm privat. De ce ARG NPM_TOKEN e o idee proastă și cum faci corect?

Răspuns scurt: Valorile ARG pot rămâne în metadatele imaginii și în docker history, iar un .npmrc copiat rămâne într-un strat chiar dacă îl ștergi ulterior. Corect este un secret BuildKit: RUN --mount=type=secret, montat doar pe durata comenzii.

Ce merge prost cu varianta naivă:

ARG NPM_TOKEN
RUN echo "//registry.npmjs.org/:_authToken=${NPM_TOKEN}" > .npmrc \
 && npm ci && rm .npmrc
  • docker history --no-trunc poate arăta comanda cu valoarea argumentului.
  • Dacă .npmrc e creat și șters în instrucțiuni diferite, fișierul rămâne în stratul anterior.
  • Cache-ul de build și imaginile intermediare din CI pot păstra și ele valoarea.

Varianta corectă:

# syntax=docker/dockerfile:1
FROM node:20-slim AS deps
WORKDIR /app
COPY package.json package-lock.json .npmrc.template ./
RUN --mount=type=secret,id=npm_token \
    NPM_TOKEN="$(cat /run/secrets/npm_token)" npm ci

.npmrc.template (redenumit în .npmrc) conține //registry.npmjs.org/:_authToken=${NPM_TOKEN}, iar npm citește variabila din mediul comenzii.

BASH
docker buildx build --secret id=npm_token,env=NPM_TOKEN -t app .

Secretul este montat ca fișier temporar doar pentru acel RUN, nu intră în strat, nu afectează cache key-ul și nu apare în istoric. Pentru dependențe din repository-uri Git private există --mount=type=ssh, care folosește agentul SSH al mașinii de build.

Dacă imaginea finală e multi-stage, e bine ca etapa cu secret să nu fie cea publicată. În CI, secretul vine din depozitul de secrete al pipeline-ului, nu din cod.

Ce urmărește intervievatorul: Se verifică dacă știi cum se scurg secretele prin build. Greșeala tipică este rm într-un strat separat sau încrederea în ARG.

Eroarea, în practică:SecretsUsedInArgOrEnv: sensitive data in ARG/ENV

43 Mid

Ce sunt imaginile scratch și distroless? Scrie un Dockerfile care rulează un serviciu Go pe scratch și spune ce trebuie să adaugi manual.

Răspuns scurt: scratch este o imagine complet goală; distroless are doar minimul pentru rulare, fără shell sau manager de pachete. Pe scratch pui un binar static și adaugi manual certificatele CA, datele de fus orar și un UID neprivilegiat.

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

FROM scratch
COPY --from=build /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/
COPY --from=build /usr/share/zoneinfo /usr/share/zoneinfo
COPY --from=build /out/server /server
USER 65532:65532
EXPOSE 8080
ENTRYPOINT ["/server"]

Ce trebuie să știi:

  • CGO_ENABLED=0 produce un binar static. Altfel, binarul cere biblioteca C dinamică și containerul pornește cu un „no such file or directory” confuz.
  • Fără certificatele CA, orice apel HTTPS spre exterior eșuează cu o eroare de certificat.
  • Fără zoneinfo, încărcarea unui fus orar dă eroare (în Go există și varianta de a importa time/tzdata).
  • scratch nu are /etc/passwd, deci folosești un UID numeric.
  • Nu există shell: docker exec -it ... sh nu funcționează. Pentru depanare folosești docker debug (Docker Desktop) sau un container de debug care partajează namespace-ul procesului.

Distroless (gcr.io/distroless/static, base, java21 și altele) e un compromis: are certificate, fus orar, utilizator nonroot și runtime-ul necesar, dar tot fără shell. Avantajul ambelor: imagini foarte mici și puține pachete în care scanerele pot găsi vulnerabilități.

Ce urmărește intervievatorul: Se verifică înțelegerea a ce conține de fapt o imagine minimală. Candidații uită de obicei certificatele CA și binarul static.

Eroarea, în practică:exec: "bash": executable file not found in $PATH

44 Mid

De ce dimensiunea imaginii nu scade, deși ultima linie șterge fișierele?

FROM ubuntu:24.04
RUN apt-get update && apt-get install -y build-essential
COPY . /src
RUN make -C /src && cp /src/app /usr/local/bin/
RUN apt-get purge -y build-essential && rm -rf /src /var/lib/apt/lists/*

Răspuns scurt: Fiecare RUN adaugă un strat nou peste cele vechi, iar ștergerea într-un strat ulterior doar ascunde fișierele; ele rămân în straturile anterioare și se descarcă la fiecare pull. Curățenia trebuie făcută în același RUN sau, mai bine, cu un build multi-stage.

Imaginea este suma tuturor straturilor. Stratul 2 conține compilatorul, stratul 3 sursele, stratul 4 rezultatul compilării, iar stratul 5 conține doar marcaje de ștergere (whiteouts). Dimensiunea finală e practic suma primelor patru, plus puțin.

Variantă cu un singur strat:

FROM ubuntu:24.04
COPY . /src
RUN apt-get update \
 && apt-get install -y --no-install-recommends build-essential \
 && make -C /src && cp /src/app /usr/local/bin/ \
 && apt-get purge -y --auto-remove build-essential \
 && rm -rf /src /var/lib/apt/lists/*

Funcționează, dar orice modificare de cod reinstalează compilatorul, iar codul sursă trece totuși printr-un strat.

Varianta mai bună, multi-stage:

FROM ubuntu:24.04 AS build
RUN apt-get update && apt-get install -y --no-install-recommends build-essential
COPY . /src
RUN make -C /src

FROM ubuntu:24.04
COPY --from=build /src/app /usr/local/bin/app
CMD ["app"]

Etapa finală are doar baza și binarul; compilatorul rămâne în cache-ul de build și nu ajunge în imagine.

Concluzia practică: o comandă de curățenie are efect asupra dimensiunii doar în același strat în care au fost create fișierele. docker history îți arată imediat stratul vinovat. Opțiunea experimentală --squash există, dar multi-stage e soluția standard.

Ce urmărește intervievatorul: Se verifică modelul de straturi aplicat pe dimensiune. Este o greșeală foarte frecventă în Dockerfile-urile scrise de începători.

45 Senior

Build-urile Docker în CI durează mult, pentru că fiecare job pornește pe un runner curat, fără cache. Cum le accelerezi?

Răspuns scurt: Exporți cache-ul de straturi într-un loc persistent (registry, cache-ul GitHub Actions, S3) cu --cache-to și îl citești cu --cache-from, ordonezi corect Dockerfile-ul, micșorezi contextul și, unde se poate, folosești un builder persistent sau remote.

Cu un runner efemer, cache-ul local dispare după fiecare job. BuildKit poate salva și restaura cache-ul extern:

BASH
docker buildx build \
  --cache-from type=registry,ref=ghcr.io/firma/api:buildcache \
  --cache-to type=registry,ref=ghcr.io/firma/api:buildcache,mode=max \
  -t ghcr.io/firma/api:${GIT_SHA} --push .
  • mode=max exportă și straturile etapelor intermediare dintr-un build multi-stage, nu doar ale imaginii finale. Fără el, etapa de build nu ar avea cache.
  • Alte backend-uri: type=gha (cache-ul GitHub Actions), type=s3, type=local cu un folder restaurat de sistemul de CI.
  • Poți citi din mai multe surse: cache-ul ramurii curente și, ca rezervă, al lui main.

Alte pârghii, în ordinea impactului obișnuit:

  • Dockerfile ordonat corect: dependențele înaintea codului.
  • .dockerignore strict, ca să nu trimiți foldere mari și ca rezultatul lui COPY să nu se schimbe inutil.
  • Builder persistent sau remote (un nod BuildKit dedicat, servicii de build în cloud), unde cache-ul și cache mount-urile rămân calde.
  • Etape paralele: testele și lint-ul în etape separate, care rulează în paralel.
  • Imagine de bază internă, cu dependențele grele preinstalate și reconstruită periodic.
  • Evitarea emulării: pentru imagini multi-arhitectură, builder-e native pe fiecare arhitectură.

Măsori înainte și după cu --progress=plain, ca să vezi unde se duce timpul și ce nu vine din cache.

Ce urmărește intervievatorul: Se verifică experiența cu build-uri în pipeline. Candidații uită de obicei mode=max, iar etapa de build rămâne fără cache.

Ciclul de viață, porturi și resurse

46 Junior

Care e diferența dintre docker run, docker create și docker start?

Răspuns scurt: docker create creează containerul din imagine fără să-l pornească, docker start pornește un container existent, iar docker run le face pe amândouă, plus pull dacă imaginea lipsește. Opțiunile de configurare (porturi, volume, variabile) se dau doar la creare.

BASH
docker create --name web -p 8080:80 nginx:1.27   # stare: Created
docker start web                                 # stare: Up
docker stop web                                  # stare: Exited
docker start web                                 # pornește același container
docker run -d --name web2 -p 8081:80 nginx:1.27  # create + start

Detalii care se întreabă des:

  • Un container are configurația „înghețată” la creare. Nu poți adăuga un port sau un volum unui container existent cu docker start; trebuie să-l ștergi și să-l creezi din nou. (Câteva setări, ca limitele de resurse și politica de restart, se pot schimba cu docker update.)
  • docker start repornește același container, cu același strat writable. Fișierele create în container la rularea anterioară sunt încă acolo, ceea ce nu se întâmplă dacă rulezi din nou docker run, care creează un container nou.
  • docker start -a atașează terminalul la ieșirea containerului, iar -i și intrarea, ca un run interactiv.
  • Repetând docker run fără --rm și fără --name, adună containere oprite. docker ps -a le arată, iar docker container prune le șterge.

create e util când vrei să pregătești un container, de exemplu să-i copiezi fișiere cu docker cp înainte de pornire, sau să extragi fișiere dintr-o imagine fără s-o rulezi.

Ce urmărește intervievatorul: Se verifică înțelegerea diferenței dintre imagine, container creat și container pornit. Juniorii cred des că docker run repetat repornește același container.

Eroarea, în practică:The container name "/web" is already in use

47 Junior

Ce stări poate avea un container și ce comenzi îl mută dintr-o stare în alta?

Răspuns scurt: Stările principale sunt created, running, paused, restarting, exited și dead, plus removing în timpul ștergerii. create, start, pause/unpause, stop/kill și rm sunt comenzile care fac tranzițiile.

Ciclul de viață:

  • created: după docker create; are configurație și strat writable, dar niciun proces.
  • running: după start sau run; procesul principal rulează.
  • paused: după docker pause; procesele sunt înghețate prin cgroup freezer, nu primesc CPU, dar rămân în memorie. docker unpause le reia.
  • restarting: procesul s-a oprit și politica de restart îl repornește.
  • exited: procesul principal s-a terminat (normal, cu eroare sau după stop/kill). Stratul writable și logurile rămân până la docker rm.
  • dead: o ștergere a eșuat parțial, de obicei din cauza unei probleme cu driverul de stocare; containerul nu mai poate fi pornit, doar șters.
BASH
docker ps -a --format 'table {{.Names}}\t{{.Status}}'
docker ps -a --filter status=exited
docker inspect -f '{{.State.Status}} {{.State.ExitCode}}' web

Regula esențială: un container trăiește cât trăiește procesul lui principal (PID 1). Când acesta se termină, containerul trece în exited, chiar dacă alte procese din container mai rulau.

docker stop trimite SIGTERM, apoi SIGKILL după timeout. docker kill trimite direct SIGKILL (sau semnalul ales cu -s). docker rm -f oprește forțat și șterge într-un pas. docker events afișează în timp real toate tranzițiile, util la depanarea containerelor care repornesc în buclă.

Ce urmărește intervievatorul: Se verifică modelul de ciclu de viață. Greșeala frecventă: confuzia între paused și exited.

Eroarea, în practică:Error response from daemon: container is not runningcannot remove container: container is running

48 Junior

Explică opțiunile din docker run --rm -it --name lab ubuntu:24.04 bash. Ce se întâmplă când tastezi exit?

Răspuns scurt: --rm șterge containerul la oprire, -i ține deschisă intrarea standard, -t alocă un pseudo-terminal, --name dă un nume, iar bash înlocuiește comanda implicită. La exit, bash (PID 1) se termină, deci containerul se oprește și este șters.

Pe rând:

  • -i (interactive): păstrează stdin conectat, ca să poți trimite comenzi.
  • -t (tty): alocă un terminal, deci ai prompt, culori și editare de linie. Fără -t, bash funcționează, dar fără prompt; fără -i, nu poți scrie nimic.
  • --rm: containerul și volumele lui anonime sunt șterse automat la oprire. Bun pentru experimente și comenzi de unică folosință.
  • --name lab: nume ușor de folosit în docker exec lab ...; fără el, Docker generează un nume aleatoriu. Două containere nu pot avea același nume.
  • bash după imagine: înlocuiește CMD din imagine.

La exit, bash se termină. Fiind procesul principal, containerul se oprește, iar cu --rm este șters, împreună cu orice ai instalat sau creat în el. Datele care trebuie păstrate se pun pe un volum sau un bind mount.

Ce trebuie știut în plus:

  • Ctrl+P urmat de Ctrl+Q te detașează fără să oprești containerul, iar docker attach lab te reconectează.
  • Într-un script din CI, -t dă eroarea „the input device is not a TTY”; acolo folosești doar -i sau nimic.
  • docker run -it cu o imagine al cărei ENTRYPOINT pornește aplicația nu îți dă un shell; folosești --entrypoint bash.
  • --rm nu se combină cu politicile de restart.

Ce urmărește intervievatorul: Întrebarea verifică dacă știi ce face fiecare opțiune, nu doar combinația memorată. Mulți nu știu de ce containerul dispare la exit.

Eroarea, în practică:The container name "/web" is already in usethe input device is not a TTY

49 Junior

Rulezi docker run -d ubuntu:24.04 și containerul apare imediat ca Exited (0). De ce, și cum ții un container pornit?

Răspuns scurt: Imaginea ubuntu are drept comandă bash, care fără terminal nu are ce citi și se termină imediat cu codul 0. Un container rulează doar cât rulează procesul principal, deci are nevoie de un proces care stă în prim-plan, de obicei aplicația ta.

-d nu înseamnă „ține containerul pornit”, ci doar „nu atașa terminalul meu”. Procesul principal este CMD din imagine, adică bash. Fără -it, bash primește un stdin închis, citește EOF și iese. Containerul a făcut exact ce trebuia: a rulat comanda până la capăt.

Același lucru apare cu aplicații configurate să intre în fundal:

  • nginx care pornește ca daemon: imaginea oficială rulează nginx -g 'daemon off;' exact ca să rămână în prim-plan;
  • service apache2 start în CMD: pornește serviciul și iese, iar containerul se oprește;
  • un script care pornește aplicația cu & la final.

Soluțiile corecte:

  • CMD rulează aplicația în prim-plan, cu logurile spre stdout.
  • Pentru un container de experimente: docker run -dit ubuntu:24.04 (bash cu un terminal alocat rămâne deschis) sau docker run -d ubuntu:24.04 sleep infinity.

Cum depanezi containerele care se opresc imediat:

BASH
docker ps -a --filter name=app
docker logs app
docker inspect -f '{{.State.ExitCode}} {{.State.Error}}' app
docker run --rm -it --entrypoint sh imagine

Codul 0 înseamnă „s-a terminat normal”, deci nu e un crash. Un cod diferit de 0 indică o eroare a aplicației, iar logurile spun de obicei motivul.

Ce urmărește intervievatorul: Este una dintre cele mai frecvente nedumeriri la început. Intervievatorul verifică dacă ai înțeles legătura container-proces.

Eroarea, în practică:Containerul se oprește imediat: Exited (0)

50 Junior

Ce diferență este între -p 8080:80, -p 127.0.0.1:8080:80 și -P? Ce faci când primești „port is already allocated”?

Răspuns scurt: -p 8080:80 publică portul pe toate interfețele host-ului, -p 127.0.0.1:8080:80 doar pe localhost, iar -P publică toate porturile din EXPOSE pe porturi aleatorii. Eroarea înseamnă că portul de pe host e deja ocupat: afli de cine și alegi alt port.

Formatul este [ip:]port_host:port_container[/protocol]:

BASH
docker run -d -p 8080:80 nginx              # 0.0.0.0:8080 și [::]:8080
docker run -d -p 127.0.0.1:8080:80 nginx    # doar de pe mașina locală
docker run -d -p 5353:53/udp imagine-dns
docker run -d -P nginx && docker port $(docker ps -lq)

De ce contează adresa: pe un server, -p 5432:5432 pentru o bază de date o expune pe interfața publică. Pe Linux, regulile iptables create de Docker pot ocoli firewall-ul configurat cu ufw, deci baza de date devine accesibilă din internet. Pentru servicii folosite doar local sau printr-un reverse proxy, legi portul de 127.0.0.1 sau nu-l publici deloc.

„Bind for 0.0.0.0:8080 failed: port is already allocated”:

BASH
docker ps --filter publish=8080        # alt container?
sudo lsof -iTCP:8080 -sTCP:LISTEN      # alt proces de pe host?
  • Dacă e un container vechi, îl oprești sau îl ștergi.
  • Dacă e un proces de pe host, alegi alt port pe host: -p 8081:80. Portul din container rămâne 80.
  • Mai multe containere pot folosi același port intern (80), dar nu același port pe host.

Mapările nu se pot schimba pe un container existent; containerul se recreează cu noua opțiune.

Ce urmărește intervievatorul: Se verifică dacă știi și implicația de securitate a publicării pe toate interfețele. Mulți nu știu că pot lega portul doar de localhost.

Eroarea, în practică:Bind for 0.0.0.0:8080: port is already allocatedcurl: (7) Failed to connect to localhost port 8080

51 Junior

Ce îți spun codurile de ieșire 0, 1, 125, 126, 127, 137 și 143 ale unui container?

Răspuns scurt: 0 înseamnă terminare normală, 1 o eroare a aplicației, 125 o eroare a lui Docker la pornire, 126 comandă neexecutabilă, 127 comandă inexistentă, 137 omorât cu SIGKILL (des OOM sau docker kill), 143 oprit cu SIGTERM.

Codul de ieșire îl vezi în docker ps -a (Exited (137) 2 minutes ago) sau cu:

BASH
docker inspect -f '{{.State.ExitCode}} OOMKilled={{.State.OOMKilled}}' api

Semnificații:

  • 0: procesul s-a terminat cu succes. Pentru un job e corect; pentru un server, înseamnă că s-a oprit singur, de obicei pentru că a intrat în fundal sau nu avea ce face.
  • 1 (sau alt cod mic): eroare raportată de aplicație. Răspunsul e în docker logs.
  • 125: comanda docker run a eșuat înainte de pornire (opțiune greșită, port ocupat, conflict de nume).
  • 126: comanda există, dar nu poate fi executată, de exemplu un script fără drept de execuție.
  • 127: comanda nu a fost găsită. Frecvent: binar lipsă în imagine, greșeală în CMD, script cu terminații de linie Windows, unde interpretorul devine sh\r.
  • 128 + N: procesul a fost oprit de semnalul N. 137 = 128 + 9 (SIGKILL), 143 = 128 + 15 (SIGTERM), 130 = 128 + 2 (SIGINT, Ctrl+C).

Pentru 137 contează contextul: OOMKilled=true indică depășirea limitei de memorie; altfel, cineva a rulat docker kill sau docker stop a expirat pentru că aplicația nu a răspuns la SIGTERM. Dacă primești constant 137 la deploy, verifică întâi forma exec a lui CMD și tratarea semnalelor.

143 la oprire e un semn bun: aplicația a primit SIGTERM și a ieșit. Multe aplicații convertesc SIGTERM în cod 0 după o oprire curată.

Ce urmărește intervievatorul: Codurile de ieșire sunt primul indiciu la depanare. Intervievatorul verifică dacă știi regula 128 + semnal și cazul OOM.

Eroarea, în practică:Containerul se oprește imediat: Exited (1)Containerul s-a oprit cu Exited (137)

52 Junior

Cum îi spui lui nginx dintr-un container să-și reîncarce configurația fără să-l oprești? Ce diferă între docker stop, docker kill și docker pause?

Răspuns scurt: Trimiți un semnal procesului principal: docker kill -s HUP web, sau rulezi docker exec web nginx -s reload. stop trimite SIGTERM și apoi SIGKILL, kill trimite imediat semnalul ales (implicit SIGKILL), iar pause îngheață procesele fără să le oprească.

Mulți programe de tip server reîncarcă configurația la SIGHUP. docker kill nu înseamnă neapărat „omoară”, ci „trimite un semnal”:

BASH
docker exec web nginx -t            # verifici configurația înainte
docker kill -s HUP web              # reload
docker exec web nginx -s reload     # echivalent pentru nginx

Comparația:

  • docker stop web: trimite semnalul de oprire (SIGTERM sau cel definit cu STOPSIGNAL în imagine), așteaptă 10 secunde (configurabil cu -t sau --stop-timeout la creare), apoi SIGKILL. Este felul normal de a opri.
  • docker kill web: trimite imediat SIGKILL, fără perioadă de grație. Cu -s trimiți orice alt semnal, iar containerul rămâne pornit dacă procesul nu se oprește la acel semnal.
  • docker pause web: folosește cgroup freezer, procesele nu mai primesc timp de CPU, dar memoria și conexiunile deschise rămân. Clienții vor primi timeout. docker unpause le reia exact de unde erau. E util rar, de exemplu pentru un snapshot consistent al fișierelor.

Semnalul ajunge doar la PID 1. Dacă PID 1 este un shell sau un script fără exec, semnalul nu ajunge la nginx. De aceea forma exec și scripturile entrypoint corecte contează și pentru reload, nu doar pentru oprire.

Pentru configurații montate prin bind mount, unele editoare înlocuiesc fișierul cu unul nou, iar containerul vede în continuare inode-ul vechi; montarea întregului folder evită problema.

Ce urmărește intervievatorul: Se verifică înțelegerea faptului că docker kill trimite semnale. Mulți candidați nu știu că există -s.

Eroarea, în practică:cannot kill container: ... is not runningContainer is paused, unpause before exec

53 Junior

Ce politici de restart are Docker și pe care o alegi pentru un API pe un server fără orchestrator?

Răspuns scurt: no (implicit), on-failure[:max] (doar la cod de ieșire diferit de 0), always (mereu, inclusiv după repornirea daemonului) și unless-stopped (ca always, dar nu repornește un container oprit manual). Pentru un API, de obicei unless-stopped.

BASH
docker run -d --name api --restart unless-stopped -p 8000:8000 firma/api:1.4
docker update --restart on-failure:5 worker
docker inspect -f '{{.HostConfig.RestartPolicy.Name}} {{.RestartCount}}' api

Diferențele:

  • no: containerul rămâne oprit după orice ieșire.
  • on-failure[:N]: repornește doar dacă codul de ieșire nu e 0, opțional de maximum N ori. Potrivit pentru job-uri care au voie să se termine cu succes.
  • always: repornește la orice oprire. Dacă l-ai oprit manual cu docker stop, rămâne oprit până la repornirea daemonului sau a serverului, când pornește din nou.
  • unless-stopped: ca always, cu diferența că un container oprit manual rămâne oprit și după repornirea serverului. E alegerea cea mai previzibilă pentru servicii.

Comportamente de știut:

  • Între reporniri, Docker aplică o întârziere care crește progresiv, ca să nu încarce host-ul cu un container care cade imediat.
  • O politică de restart se aplică doar după ce containerul a rulat cel puțin 10 secunde o dată; altfel e considerat eșuat la pornire.
  • Politica reacționează doar la oprirea procesului. Un container unhealthy dar pornit nu e repornit.
  • Nu se combină cu --rm.

În Compose, opțiunea se scrie restart: unless-stopped. Pe mai multe servere sau cu nevoi de autoscalare, repornirea devine treaba unui orchestrator.

Ce urmărește intervievatorul: Se verifică diferența fină dintre always și unless-stopped. Candidații nu știu de obicei că politica ignoră starea de sănătate.

Eroarea, în practică:Conflicting options: --restart and --rminvalid restart policy format: unknown policy

54 Mid

De ce este special procesul cu PID 1 într-un container și ce rezolvă docker run --init sau tini?

Răspuns scurt: PID 1 nu primește acțiunile implicite ale semnalelor și trebuie să culeagă procesele orfane. Multe aplicații nu fac asta, deci ignoră SIGTERM sau lasă zombii. --init pune ca PID 1 un init minimal (tini), care transmite semnalele și culege zombii.

Pe un sistem Linux obișnuit, PID 1 este systemd sau alt init, care face două lucruri pe care aplicațiile nu le fac:

  • Semnale: kernelul nu aplică pentru PID 1 acțiunea implicită a unui semnal (de exemplu terminarea la SIGTERM). Dacă aplicația nu are un handler explicit, SIGTERM e ignorat, iar docker stop așteaptă timeout-ul și trimite SIGKILL.
  • Procese zombie: când un proces moare, părintele trebuie să-i citească starea (wait). Dacă părintele a murit înaintea lui, copilul e adoptat de PID 1. O aplicație Node sau Python care pornește subprocese (de exemplu un browser headless sau scripturi shell) și nu culege copiii orfani acumulează zombii, care pot epuiza în timp limita de procese.

Soluții:

BASH
docker run -d --init firma/scraper:1.0
RUN apt-get update && apt-get install -y --no-install-recommends tini && rm -rf /var/lib/apt/lists/*
ENTRYPOINT ["/usr/bin/tini", "--"]
CMD ["node", "server.js"]

--init adaugă docker-init (tini) fără să modifici imaginea; în Compose, init: true. Alternativa din imagine e utilă când nu controlezi felul în care e rulat containerul.

Init-ul nu ține loc de oprire grațioasă: transmite SIGTERM aplicației, dar aplicația tot trebuie să-l trateze (să închidă conexiunile, să termine cererile). Nici nu face din container o mașină cu mai multe servicii; pentru asta există unelte ca s6-overlay sau supervisord, folosite rar și cu motive clare.

Ce urmărește intervievatorul: Se verifică înțelegerea mecanismelor de proces din spatele containerelor. Puțini candidați știu de problema proceselor zombie.

Eroarea, în practică:JSONArgsRecommended: JSON arguments for CMD

55 Mid

Un container repornește de câteva ori pe zi cu codul 137, fără nimic relevant în loguri. Cum confirmi cauza și cum alegi limita de memorie?

Răspuns scurt: 137 fără eroare în loguri sugerează OOM kill. Confirmi cu docker inspect (OOMKilled: true) și dmesg, apoi măsori consumul real sub încărcare. Limita vine din vârful măsurat plus o marjă, după ce excluzi o scurgere de memorie.

Pașii:

BASH
docker inspect -f 'OOM={{.State.OOMKilled}} Exit={{.State.ExitCode}} Restarts={{.RestartCount}}' api
docker inspect -f '{{.HostConfig.Memory}}' api       # limita, în octeți (0 = fără)
docker events --filter container=api --filter event=oom
sudo dmesg -T | grep -i -E 'killed process|oom'
docker stats api
  • OOMKilled=true confirmă că procesul a fost omorât de kernel pentru depășirea limitei cgroup-ului.
  • Dacă nu există limită pe container, dar host-ul a rămas fără memorie, OOM killer-ul global poate alege procesul tău; dmesg arată asta.
  • Fără OOM, caută cine a trimis SIGKILL: un docker stop expirat sau un script extern.

Apoi analizezi consumul:

  • Graficul memoriei în timp (din docker stats sau din monitorizare, de exemplu cAdvisor cu Prometheus). O creștere continuă până la limită indică o scurgere de memorie; vârfuri scurte indică cereri costisitoare (un export mare încărcat integral în memorie).
  • Runtime-ul: JVM, Node și Python au setări proprii de heap care trebuie să încapă sub limită, cu loc pentru memoria non-heap.

Alegerea limitei: consumul de vârf măsurat la încărcare realistă, plus o marjă. Poți seta și --memory-reservation pentru o limită soft. Swap-ul se controlează cu --memory-swap; pentru servicii sensibile la latență e mai bine fără swap. Ridicarea limitei fără să înțelegi creșterea doar amână problema.

Ce urmărește intervievatorul: Se verifică o depanare reală, pas cu pas. Greșeala tipică este dublarea limitei de memorie fără nicio măsurătoare.

Eroarea, în practică:Containerul s-a oprit cu Exited (137)

56 Senior

Rulezi o aplicație Java și una Node.js în containere cu --memory 1g. Ce trebuie să configurezi ca runtime-urile să respecte limita?

Răspuns scurt: JVM-urile moderne (Java 10+, backport în 8u191) citesc limita cgroup-ului, dar implicit folosesc pentru heap doar 25% din ea; setezi -XX:MaxRAMPercentage. Pentru Node setezi --max-old-space-size sub limită. În ambele cazuri lași loc pentru memoria din afara heap-ului.

Un runtime care nu știe de limita containerului își dimensionează heap-ul după memoria host-ului și este omorât de OOM killer.

Java: de la Java 10 (și în Java 8 de la update-ul 191), JVM-ul este „container aware”: citește limitele de memorie și CPU din cgroups, iar versiunile actuale suportă și cgroups v2. Implicit, heap-ul maxim este 25% din limită, ceea ce irosește memoria. Setezi procentual:

BASH
java -XX:MaxRAMPercentage=75 -XX:+ExitOnOutOfMemoryError -jar app.jar

Restul de memorie e necesar pentru metaspace, stivele firelor de execuție, code cache, buffer-ele directe (Netty) și garbage collector. Dacă dai 95%, containerul poate fi omorât deși heap-ul nu e plin. Verifici ce vede JVM-ul cu java -XshowSettings:system -version.

Node.js: limita implicită a heap-ului V8 depinde de versiune și de memoria detectată; versiunile recente țin cont de limita cgroup-ului, dar comportamentul diferă între versiuni. Setezi explicit:

BASH
node --max-old-space-size=768 server.js
# sau ENV NODE_OPTIONS=--max-old-space-size=768

Buffer-ele și memoria nativă sunt în afara acestei valori.

Și CPU contează: JVM-ul alege numărul de fire pentru GC și thread pool-uri după CPU-urile detectate; --cpus 1 pe un host cu 32 de nuclee trebuie să fie văzut corect. Node rulează JavaScript pe un singur fir, deci limite de CPU sub 1 nucleu pot crește mult latența. Validezi totul cu un test de încărcare și cu metrici reale, nu doar cu calculul pe hârtie.

Ce urmărește intervievatorul: Se verifică experiența de producție cu runtime-uri gestionate. Greșeala tipică: heap egal cu limita containerului, care duce la OOM kill.

Eroarea, în practică:Containerul s-a oprit cu Exited (137)

57 Senior

La fiecare deploy al unui API pe un server cu Docker se pierd câteva cereri. Cum garantezi o oprire grațioasă și o înlocuire fără erori?

Răspuns scurt: Aplicația tratează SIGTERM: refuză conexiuni noi, termină cererile în curs și iese înainte de timeout. Traficul se mută pe containerul nou, devenit sănătos, înainte de oprirea celui vechi, printr-un reverse proxy cu verificări de sănătate.

Cererile se pierd de obicei din două motive: procesul e omorât în mijlocul cererilor, sau proxy-ul trimite trafic către un container care nu mai ascultă ori nu e încă pregătit.

Partea de container:

  • CMD și ENTRYPOINT în forma exec, sau exec la finalul scriptului, ca semnalul să ajungă la aplicație.
  • Handler pentru SIGTERM în aplicație. În Node: server.close() urmat de închiderea conexiunilor la baza de date; în Spring Boot, server.shutdown=graceful; în gunicorn, comportamentul implicit la SIGTERM e graceful, cu --graceful-timeout.
  • --stop-timeout (sau stop_grace_period în Compose) mai mare decât cea mai lungă cerere acceptabilă.
  • STOPSIGNAL dacă aplicația așteaptă alt semnal (de exemplu nginx folosește SIGQUIT pentru oprirea grațioasă).

Partea de rutare:

  • Un reverse proxy (Traefik, nginx, Caddy) în fața containerelor.
  • Pornești containerul nou, aștepți să devină healthy (un endpoint care verifică și dependențele), îl adaugi în proxy, apoi scoți containerul vechi din rotație și abia după aceea îl oprești.
  • Endpoint-ul de readiness începe să răspundă cu eroare imediat ce aplicația primește SIGTERM, ca proxy-ul să nu mai trimită trafic nou.

Validare: rulezi un test de încărcare în timpul unui deploy și verifici că nu apar coduri 502 sau conexiuni resetate. Pe un singur server, docker compose up -d simplu recreează containerul și produce o scurtă întrerupere; pentru zero downtime ai nevoie de pașii de mai sus sau de un orchestrator care îi face automat (rolling update cu probe).

Ce urmărește intervievatorul: Se verifică abordarea completă: proces, semnale și rutare. Răspunsurile slabe tratează doar partea de aplicație sau doar proxy-ul.

Rețele Docker

Exersează capitolul cu exerciții reale: Curs Docker →
58 Junior

Ce rețele creează Docker implicit și prin ce diferă bridge, host și none?

Răspuns scurt: bridge (implicit) dă fiecărui container o interfață într-o rețea privată, cu NAT spre exterior. host face containerul să folosească direct rețeaua host-ului, fără izolare și fără mapare de porturi. none lasă containerul doar cu interfața loopback.

BASH
docker network ls
# NAME    DRIVER
# bridge  bridge
# host    host
# none    null
  • bridge: Docker creează pe host interfața virtuală docker0, iar fiecare container primește o pereche de interfețe virtuale (veth) și o adresă privată, de regulă din 172.17.0.0/16. Ieșirea spre internet trece prin NAT, iar accesul din afară cere publicarea porturilor cu -p. Este modul implicit pentru docker run.
  • host: containerul împarte namespace-ul de rețea al host-ului. Un nginx pe portul 80 ascultă direct pe portul 80 al serverului. -p este ignorat. Avantaj: nu există NAT, deci latență minimă și acces la toate interfețele. Dezavantaj: fără izolare, conflicte de porturi între containere, iar pe Docker Desktop comportamentul diferă de cel de pe Linux.
  • none: doar lo. Folosit pentru job-uri care nu trebuie să comunice deloc, de exemplu procesarea unor fișiere neîncrezătoare.

Pe lângă acestea, poți crea rețele proprii de tip bridge, care adaugă DNS după numele containerelor și o izolare mai bună. Există și drivere pentru scenarii speciale: overlay (rețea între mai multe host-uri, în Swarm), macvlan și ipvlan (containerul primește o adresă direct în rețeaua fizică).

Poți vedea cum e conectat un container cu docker inspect -f '{{json .NetworkSettings.Networks}}' web.

Ce urmărește intervievatorul: Se verifică modelul de bază al rețelelor. Mulți nu știu că -p nu are efect cu --network host.

Eroarea, în practică:Published ports are discarded (host network)network-scoped alias only in user defined networks

59 Junior

De ce nu merge ping db între aceste două containere și cum repari?

BASH
docker run -d --name db -e POSTGRES_PASSWORD=x postgres:16
docker run -it --rm alpine ping db
# ping: bad address 'db'

Răspuns scurt: Ambele sunt pe rețeaua bridge implicită, care nu are rezolvare de nume între containere. Creezi o rețea proprie (docker network create app-net) și pornești ambele containere cu --network app-net; Docker oferă atunci DNS după numele containerului.

Rețeaua bridge implicită este păstrată pentru compatibilitate și nu înregistrează numele containerelor în DNS. Pe ea, containerele se pot accesa doar prin adresa IP, care se poate schimba la fiecare repornire. Opțiunea veche --link rezolva asta, dar este depreciată.

Pe o rețea bridge creată de tine (user-defined), Docker rulează un server DNS integrat la adresa 127.0.0.11 din fiecare container, care rezolvă numele containerelor, aliasurile și numele serviciilor din Compose:

BASH
docker network create app-net
docker run -d --name db --network app-net -e POSTGRES_PASSWORD=x postgres:16
docker run -it --rm --network app-net alpine ping -c 2 db
docker run -it --rm --network app-net alpine cat /etc/resolv.conf

Avantajele rețelelor proprii:

  • rezolvare de nume, deci în configurația aplicației scrii DB_HOST=db;
  • izolare: containerele din rețele diferite nu se văd între ele;
  • poți conecta și deconecta containere fără să le repornești (docker network connect).

Un container existent poate fi mutat pe noua rețea: docker network connect app-net db.

Docker Compose creează automat o rețea proprie pentru fiecare proiect, de aceea acolo numele serviciilor funcționează din prima. Pentru numele de domenii externe, DNS-ul integrat trimite cererile mai departe către serverele DNS ale host-ului.

Ce urmărește intervievatorul: Este o capcană clasică. Intervievatorul verifică dacă știi diferența dintre rețeaua implicită și una creată de tine.

Eroarea, în practică:bad address 'cache' (numele containerului)ERROR 2005: Unknown MySQL server host 'db'

60 Junior

Aplicația dintr-un container are DB_HOST=localhost, iar PostgreSQL rulează pe laptop, în afara Docker. De ce nu se conectează și cum repari?

Răspuns scurt: În container, localhost este containerul însuși, pentru că are propriul namespace de rețea. Pe Docker Desktop folosești host.docker.internal; pe Linux, adaugi --add-host=host.docker.internal:host-gateway, iar PostgreSQL trebuie să asculte și pe interfața accesibilă din container.

Fiecare container are interfața lui loopback. localhost:5432 în container caută un server PostgreSQL în container și primește „connection refused”. La fel, două containere diferite nu se pot accesa reciproc prin localhost (cu excepția celor care împart rețeaua, de exemplu cu --network container:alt).

Variante, în funcție de situație:

  • Docker Desktop (macOS, Windows): numele host.docker.internal indică automat host-ul.
BASH
docker run -e DB_HOST=host.docker.internal app
  • Linux: numele nu există implicit, dar îl poți crea:
BASH
docker run --add-host=host.docker.internal:host-gateway -e DB_HOST=host.docker.internal app

host-gateway este înlocuit cu adresa host-ului în rețeaua bridge. Pe Linux, PostgreSQL trebuie să asculte pe acea interfață (listen_addresses) și să accepte conexiuni din subrețeaua Docker în pg_hba.conf; dacă ascultă doar pe 127.0.0.1, conexiunea tot eșuează. Și firewall-ul host-ului poate bloca traficul.

  • --network host pe Linux: containerul folosește rețeaua host-ului și localhost funcționează, cu pierderea izolării.
  • Cel mai simplu pe termen lung: rulezi și baza de date într-un container, în aceeași rețea, cu DB_HOST=db.

În Compose, echivalentul pentru Linux este extra_hosts: ["host.docker.internal:host-gateway"].

Ce urmărește intervievatorul: Se verifică înțelegerea namespace-ului de rețea. Este o confuzie foarte frecventă la cei care trec prima dată o aplicație în container.

Eroarea, în practică:MongoNetworkError: connect ECONNREFUSED 27017Could not connect to Redis at 127.0.0.1:6379

61 Junior

Aplicația Flask de mai jos pornește, docker ps arată 0.0.0.0:5000->5000/tcp, dar browserul primește „connection reset”. Unde e bug-ul?

PYTHON
from flask import Flask
app = Flask(__name__)

@app.get("/")
def index():
    return "salut"

if __name__ == "__main__":
    app.run(port=5000)

Răspuns scurt: app.run() ascultă implicit pe 127.0.0.1, adică doar pe loopback-ul containerului. Traficul redirecționat de Docker vine pe interfața de rețea a containerului, unde nu ascultă nimeni. Trebuie app.run(host="0.0.0.0", port=5000).

Publicarea portului funcționează așa: conexiunea de pe host ajunge, prin NAT sau prin procesul docker-proxy, la adresa IP a containerului în rețeaua bridge, de exemplu 172.17.0.2:5000. Dacă serverul ascultă doar pe 127.0.0.1, conexiunea pe 172.17.0.2 este respinsă. Din interiorul containerului, curl localhost:5000 merge, ceea ce face bug-ul derutant.

Corect:

PYTHON
if __name__ == "__main__":
    app.run(host="0.0.0.0", port=5000)

sau, recomandat în producție, cu un server WSGI:

CMD ["gunicorn", "-b", "0.0.0.0:5000", "app:app"]

Aceeași problemă apare la multe unelte de dezvoltare:

  • Vite: vite --host 0.0.0.0 sau server.host în configurație;
  • Next.js dev: next dev -H 0.0.0.0;
  • Django: python manage.py runserver 0.0.0.0:8000;
  • Spring Boot ascultă implicit pe toate interfețele, deci nu are problema.

Cum confirmi:

BASH
docker exec app sh -c 'ss -ltnp || netstat -ltnp'
# 127.0.0.1:5000 = doar loopback; 0.0.0.0:5000 = toate interfețele

0.0.0.0 în container nu expune nimic în plus către internet: accesul din exterior este controlat de -p și de adresa pe care publici portul pe host.

Ce urmărește intervievatorul: Este probabil cel mai frecvent bug de rețea la începători. Intervievatorul verifică dacă știi diferența dintre loopback și interfața containerului.

Eroarea, în practică:curl: (56) Recv failure: Connection reset by peer

62 Mid

Ai un frontend, un API și o bază de date. Cum folosești rețelele Docker ca frontend-ul să nu poată ajunge direct la baza de date?

Răspuns scurt: Creezi două rețele: frontend (proxy și API) și backend (API și baza de date). API-ul e conectat la ambele, iar frontend-ul doar la prima. Pentru izolare suplimentară, rețeaua backend poate fi --internal, fără acces la internet.

Un container poate fi conectat la mai multe rețele; primește o interfață și o adresă în fiecare. Containerele comunică doar cu cele din rețelele comune.

BASH
docker network create frontend
docker network create --internal backend

docker run -d --name db  --network backend -e POSTGRES_PASSWORD=x postgres:16
docker run -d --name api --network backend firma/api:1.0
docker network connect frontend api
docker run -d --name web --network frontend -p 80:80 firma/web:1.0

Rezultatul:

  • web rezolvă și accesează api, dar db nu există pentru el;
  • api vede ambele;
  • db nu are ieșire spre internet, datorită lui --internal, și nu are porturi publicate.

În Compose:

YAML
services:
  web:
    networks: [frontend]
  api:
    networks: [frontend, backend]
  db:
    networks: [backend]
networks:
  frontend:
  backend:
    internal: true

Atenție: o rețea internal blochează și ieșirea spre internet, deci un serviciu care trebuie să apeleze un API extern are nevoie și de o rețea normală. Segmentarea pe rețele este un strat de apărare, nu un firewall complet; comunicarea între serviciile din aceeași rețea nu e filtrată pe porturi.

Principiul de bază rămâne: publici pe host doar ce trebuie accesat din afară, de obicei doar proxy-ul.

Ce urmărește intervievatorul: Se verifică dacă folosești rețelele pentru izolare, nu doar pentru conectivitate. Mulți publică portul bazei de date fără motiv.

63 Mid

Cum distribui cererile între trei containere identice ale unui serviciu folosind DNS-ul Docker? Ce limitări are abordarea?

Răspuns scurt: Pornești containerele în aceeași rețea cu același alias (--network-alias api); DNS-ul integrat returnează toate adresele pentru numele api, într-o ordine care se schimbă. E un echilibru grosier, dependent de clienți și de cache-ul DNS, fără verificare de sănătate.

BASH
docker network create app-net
for i in 1 2 3; do
  docker run -d --name api$i --network app-net --network-alias api firma/api:1.0
done
docker run --rm --network app-net alpine nslookup api

nslookup arată trei adrese. În Compose, docker compose up -d --scale api=3 face același lucru automat: numele serviciului devine un nume DNS cu mai multe adrese.

Limitări:

  • Cache DNS în client: multe runtime-uri rezolvă numele o dată și refolosesc conexiunea sau adresa. JVM-ul poate ține rezultatul în cache, iar pool-urile de conexiuni HTTP păstrează conexiunile deschise, deci tot traficul poate merge la un singur container.
  • Fără sănătate: un container care a pornit, dar nu răspunde, rămâne în răspunsul DNS cât timp rulează.
  • Fără algoritm: nu există ponderi, sesiuni lipicioase sau „cel mai puțin încărcat”.
  • Porturile publicate: trei containere nu pot publica același port pe host. Cu --scale, un ports: "8000:8000" fix dă conflict.

Soluția obișnuită este un reverse proxy în fața replicilor (nginx, HAProxy, Traefik, Envoy): proxy-ul publică singurul port și distribuie cererile, cu verificări de sănătate și reîncercări. nginx rezolvă un nume de upstream implicit doar la pornire, deci pentru replici dinamice configurezi resolver 127.0.0.11 și variabile în proxy_pass, sau folosești Traefik, care descoperă containerele automat.

În Kubernetes, un Service oferă o adresă virtuală stabilă și echilibrare făcută de kube-proxy, deci problema dispare din aplicație.

Ce urmărește intervievatorul: Se verifică înțelegerea limitelor echilibrării prin DNS. Candidații ignoră aproape mereu cache-ul DNS și conexiunile persistente.

Eroarea, în practică:can't set container_name and replicas

64 Mid

API-ul nu poate contacta Redis în altă rețea Docker, iar imaginea API-ului nu are ping, curl sau nslookup. Cum depanezi?

Răspuns scurt: Verifici întâi cu docker network inspect dacă ambele containere sunt în aceeași rețea, apoi pornești un container de depanare (de exemplu nicolaka/netshoot) care împarte namespace-ul de rețea al API-ului și testezi de acolo DNS-ul și portul.

Pași în ordine:

BASH
docker ps --format '{{.Names}}: {{.Networks}}'
docker network inspect app-net -f '{{range .Containers}}{{.Name}} {{.IPv4Address}}{{"\n"}}{{end}}'
docker logs api | tail -50

Ce cauți:

  • Sunt cele două containere într-o rețea comună? Dacă unul e pe bridge implicit, numele nu se rezolvă.
  • Ce nume folosește aplicația? redis ca nume de container, numele serviciului din Compose sau un alias?
  • Ce eroare apare: „Name or service not known” (DNS), „connection refused” (portul nu ascultă), „timeout” (rețea sau firewall)?

Apoi intri în namespace-ul de rețea al API-ului cu un container care are toate uneltele:

BASH
docker run --rm -it --network container:api nicolaka/netshoot
nslookup redis
nc -zv redis 6379
redis-cli -h redis ping    # dacă e disponibil în imagine

--network container:api îți dă exact vederea de rețea a API-ului (aceeași adresă IP, același /etc/resolv.conf), fără să modifici imaginea API-ului.

Pe partea Redis:

BASH
docker exec redis redis-cli ping
docker exec redis sh -c 'cat /proc/net/tcp | head'   # sau ss, dacă există

Verifici că Redis ascultă pe 0.0.0.0 și nu are protected-mode activ fără parolă. Pe Docker Desktop există și docker debug, care atașează unelte la orice container. Evită să instalezi pachete în containerul de producție doar pentru depanare.

Ce urmărește intervievatorul: Se verifică metoda de lucru, nu doar comenzile. Intervievatorul vrea să vadă că separi problemele de DNS, de port și de rută.

65 Mid

Când are sens --network host și ce compromisuri implică?

Răspuns scurt: Are sens pentru aplicații foarte sensibile la latență sau care gestionează multe porturi dinamice, pentru unelte de monitorizare a rețelei host-ului ori pentru depanare. Compromisurile: fără izolare de rețea, conflicte de porturi, -p ignorat și comportament diferit pe Docker Desktop.

Cu --network host, containerul nu primește namespace de rețea propriu. Procesul vede interfețele host-ului și ascultă direct pe ele:

BASH
docker run -d --network host --name web nginx
curl http://localhost:80

Când merită:

  • Aplicații cu trafic foarte mare sau latență critică, unde NAT-ul și docker-proxy adaugă overhead măsurabil.
  • Servicii care deschid porturi dinamice greu de mapat (unele protocoale VoIP, aplicații cu intervale mari de porturi UDP).
  • Agenți de monitorizare sau colectoare de metrici care trebuie să vadă rețeaua host-ului (de exemplu exportere Prometheus pentru nod).
  • Depanare: vrei să excluzi rețeaua Docker din ecuație.

Compromisuri:

  • Izolare: containerul poate asculta pe orice port și vede tot traficul local. Un serviciu care ascultă din greșeală pe 0.0.0.0 e expus direct.
  • Porturi: două containere care ascultă pe același port intră în conflict, ca două procese pe host. Nu mai poți rula mai multe instanțe pe 8080.
  • Fără DNS de rețea Docker: containerul nu face parte din rețelele Docker și nu rezolvă numele celorlalte containere.
  • Portabilitate: pe Docker Desktop, rețeaua „host” este a mașinii virtuale Linux. Versiunile recente oferă o opțiune de host networking, dar comportamentul nu e identic cu cel de pe un server Linux.

În Kubernetes, echivalentul este hostNetwork: true, folosit tot pentru componente de infrastructură, nu pentru aplicații obișnuite.

Ce urmărește intervievatorul: Se verifică dacă poți argumenta un compromis. Răspunsul slab este fie „niciodată”, fie „mereu, e mai rapid”.

Eroarea, în practică:Published ports are discarded (host network)

66 Senior

Pe un server Linux ai configurat ufw să blocheze tot în afară de 22 și 443, dar baza de date publicată cu -p 5432:5432 e accesibilă din internet. De ce, și cum repari?

Răspuns scurt: Docker scrie propriile reguli iptables pentru porturile publicate, în lanțuri evaluate înaintea regulilor ufw, deci traficul spre container ocolește firewall-ul. Repari prin a nu publica portul sau prin legarea lui de 127.0.0.1, iar pentru filtre proprii folosești lanțul DOCKER-USER.

Când publici un port, Docker adaugă reguli în tabela nat (DNAT) și în lanțul FORWARD din tabela filter. Pachetul destinat portului 5432 este redirecționat spre adresa containerului înainte să ajungă în lanțul INPUT, unde ufw își pune regulile. Pentru ufw, traficul nu e destinat host-ului, ci redirecționat, deci regulile lui de intrare nu se aplică.

Soluții, în ordinea preferinței:

  • Nu publica porturile serviciilor interne. Aplicația ajunge la baza de date prin rețeaua Docker, cu DB_HOST=db.
  • Dacă ai nevoie de acces local (pentru backup sau administrare), leagă portul de localhost și folosește un tunel SSH:
BASH
docker run -d -p 127.0.0.1:5432:5432 postgres:16
ssh -L 5432:127.0.0.1:5432 user@server
  • Pentru reguli proprii, Docker oferă lanțul DOCKER-USER, evaluat înaintea regulilor sale:
BASH
iptables -I DOCKER-USER -i eth0 -p tcp -m conntrack --ctorigdstport 5432 -j DROP
  • Implicit, în fișierul daemon.json al daemonului poți seta "ip": "127.0.0.1", astfel încât porturile publicate fără adresă să fie legate de localhost.
  • Firewall-ul furnizorului de cloud (security group) se aplică în afara mașinii și nu e ocolit.

Dezactivarea completă a gestionării iptables ("iptables": false) este posibilă, dar strică rețeaua containerelor dacă nu scrii manual toate regulile. Indiferent de soluție, verifici din exterior cu nmap sau nc, nu presupui.

Ce urmărește intervievatorul: Este o problemă de securitate reală și des întâlnită. Intervievatorul verifică dacă știi cum interacționează Docker cu firewall-ul host-ului.

Volume, date, variabile și secrete

67 Junior

Pornești un container MySQL, adaugi date, apoi rulezi docker rm -f mysql și îl creezi din nou. Ce se întâmplă cu datele și de ce?

Răspuns scurt: Dacă n-ai montat nimic pe /var/lib/mysql, imaginea MySQL creează un volum anonim; containerul nou primește un volum anonim nou, deci datele par pierdute, deși volumul vechi poate exista încă, orfan. Datele din stratul writable se pierd definitiv la docker rm.

Un container are un strat writable propriu, care există doar cât există containerul. Orice fișier scris acolo dispare la docker rm. docker stop și docker start nu afectează datele.

Imaginea MySQL declară VOLUME /var/lib/mysql în Dockerfile. Când pornești containerul fără să montezi ceva acolo, Docker creează un volum anonim, cu un nume hash:

BASH
docker volume ls
# DRIVER  VOLUME NAME
# local   4f1c9e2b7a...

La docker rm -f mysql (fără -v), volumul anonim rămâne pe disc, dar nu mai e legat de niciun container. Containerul nou primește alt volum anonim, gol, iar MySQL inițializează o bază nouă. Datele vechi există încă, însă greu de identificat, și vor dispărea la primul docker volume prune.

Corect, cu volum cu nume:

BASH
docker volume create mysql-data
docker run -d --name mysql -e MYSQL_ROOT_PASSWORD=secret \
  -v mysql-data:/var/lib/mysql mysql:8.4
docker rm -f mysql
docker run -d --name mysql -e MYSQL_ROOT_PASSWORD=secret \
  -v mysql-data:/var/lib/mysql mysql:8.4   # datele sunt aici

Alte detalii: docker rm -v șterge și volumele anonime ale containerului, iar --rm face același lucru automat. Variabilele de inițializare (MYSQL_ROOT_PASSWORD, MYSQL_DATABASE) au efect doar la prima pornire, pe un volum gol; pe un volum existent sunt ignorate, ceea ce produce des confuzii de tipul „am schimbat parola în variabilă și nu merge”.

Ce urmărește intervievatorul: Se verifică înțelegerea volumelor anonime declarate în imagine. Este o sursă frecventă de date „pierdute” la începători.

Eroarea, în practică:password authentication failed for user "postgres"ERROR 1045 (28000): Access denied for user 'root'

68 Junior

Ce comenzi folosești ca să gestionezi volumele: vezi unde sunt pe disc, ce containere le folosesc și cum le cureți în siguranță?

Răspuns scurt: docker volume ls, inspect (arată Mountpoint), create și rm; docker ps -a --filter volume=<nume> arată containerele care îl folosesc, iar docker volume prune șterge volumele nefolosite. Ștergerea e definitivă, deci verifici întâi.

BASH
docker volume create pgdata
docker volume ls
docker volume ls --filter dangling=true          # nefolosite de vreun container
docker volume inspect pgdata
# "Mountpoint": "/var/lib/docker/volumes/pgdata/_data"
docker ps -a --filter volume=pgdata
docker system df -v                              # dimensiunea fiecărui volum
docker volume rm pgdata                          # eșuează dacă e folosit
docker volume prune                              # volume anonime nefolosite
docker volume prune -a                           # și cele cu nume

Ce trebuie știut:

  • Volumele locale stau sub /var/lib/docker/volumes/ pe host (pe Docker Desktop, în mașina virtuală). Nu modifici direct acele fișiere cât timp containerul rulează.
  • docker volume rm refuză un volum folosit de un container, chiar oprit.
  • Începând cu Docker 23, docker volume prune șterge implicit doar volumele anonime; pentru toate cele nefolosite ai nevoie de -a. Pe versiuni mai vechi, comanda ștergea toate volumele nefolosite, inclusiv cele cu nume, ceea ce a dus la pierderi de date.
  • Etichetele ajută la curățenia selectivă: docker volume create --label proiect=blog blog-db, apoi docker volume prune --filter label=proiect=blog.
  • Un volum nou montat într-un folder al imaginii care conține deja fișiere este populat cu acele fișiere la prima montare. Bind mount-urile nu au acest comportament.

Înainte de orice ștergere pe un server, faci backup și verifici de două ori ce containere folosesc volumul.

Ce urmărește intervievatorul: Se verifică familiaritatea cu administrarea volumelor. Diferența de comportament a lui prune între versiuni este un detaliu care arată experiență.

Eroarea, în practică:remove pgdata: volume is in useget magazin-date: no such volume

69 Junior

Care e diferența dintre -v și --mount și cum montezi un fișier de configurație doar pentru citire?

Răspuns scurt: Ambele montează volume sau foldere de pe host. -v are sintaxa scurtă sursă:destinație:opțiuni și creează automat folderul lipsă pe host, iar --mount folosește perechi cheie-valoare explicite și dă eroare dacă sursa nu există. Doar-citire se cere cu :ro sau readonly.

BASH
# sintaxa scurtă
docker run -d -v "$(pwd)/nginx.conf:/etc/nginx/nginx.conf:ro" nginx:1.27
docker run -d -v pgdata:/var/lib/postgresql/data postgres:16

# sintaxa explicită
docker run -d \
  --mount type=bind,source="$(pwd)"/nginx.conf,target=/etc/nginx/nginx.conf,readonly \
  --mount type=volume,source=pgdata,target=/var/lib/postgresql/data \
  --mount type=tmpfs,target=/tmp,tmpfs-size=64m \
  nginx:1.27

Diferențe practice:

  • Cu -v, dacă sursa începe cu / sau ./, e bind mount; altfel e numele unui volum. O greșeală de cale poate crea fără avertisment un volum nou sau un folder gol pe host.
  • Cu -v, o cale de pe host care nu există e creată ca folder. Dacă voiai să montezi un fișier inexistent, ajungi cu un folder nginx.conf, iar nginx dă o eroare greu de înțeles. --mount dă eroare clară.
  • --mount e mai lizibil și suportă opțiuni suplimentare (tmpfs, opțiuni de driver de volum).

Doar-citire (:ro, readonly) contează din două motive: aplicația nu poate modifica configurația sau codul de pe host, iar o compromitere a containerului nu poate scrie în acel loc. Pentru containere foarte restrânse combini --read-only (tot sistemul de fișiere al containerului doar pentru citire) cu un tmpfs pe /tmp.

În Compose ai aceeași alegere: forma scurtă ./nginx.conf:/etc/nginx/nginx.conf:ro sau forma lungă cu type, source, target, read_only.

Ce urmărește intervievatorul: Se verifică atenția la detalii de sintaxă care produc bug-uri reale. Folderul creat în locul fișierului este o capcană clasică.

Eroarea, în practică:bind source path does not existAre you trying to mount a directory onto a file?

70 Junior

Cum dai variabile de mediu unui container și ce problemă de securitate are docker run -e DB_PASSWORD=...?

Răspuns scurt: Cu -e CHEIE=valoare, -e CHEIE (preia valoarea din shell) sau --env-file fișier. Valorile rămân vizibile în docker inspect, în istoricul shell-ului și pentru orice proces cu acces la mediul containerului, deci nu sunt un loc sigur pentru secrete.

BASH
docker run -d -e NODE_ENV=production -e PORT=3000 app
export API_KEY=abc && docker run -d -e API_KEY app    # preia valoarea din shell
docker run -d --env-file ./prod.env app

prod.env:

NODE_ENV=production
DB_HOST=db
DB_USER=app

Reguli pentru fișier: o variabilă pe linie, fără export, fără ghilimele interpretate (ghilimelele devin parte din valoare la docker run; în Compose regulile sunt diferite), comentariile încep cu #.

Precedența: -e din comandă suprascrie valorile din --env-file, iar ambele suprascriu ENV din imagine.

Problemele cu secretele în variabile:

  • docker inspect -f '{{.Config.Env}}' app afișează toate valorile, deci oricine are acces la socket-ul Docker le vede.
  • -e DB_PASSWORD=parola rămâne în istoricul shell-ului și apare în lista de procese cât timp rulează comanda.
  • Aplicația poate scrie mediul în loguri, în rapoarte de erori sau poate trece variabilele proceselor copil.
  • Fișierele .env ajung ușor în Git sau în imagine, fără .gitignore și .dockerignore.

Pentru dezvoltare locală, un .env exclus din Git e acceptabil. Pentru producție sunt preferate secretele montate ca fișiere (Compose secrets, Kubernetes Secrets, un manager de secrete precum Vault sau serviciile cloud), iar aplicația citește fișierul. Multe imagini oficiale acceptă variante _FILE, de exemplu POSTGRES_PASSWORD_FILE.

Ce urmărește intervievatorul: Se verifică atât mecanica, cât și conștiința de securitate. Mulți nu știu că docker inspect afișează parolele.

71 Junior

Cum copiezi fișiere între host și un container și când e docker cp alegerea potrivită?

Răspuns scurt: docker cp sursă container:cale și docker cp container:cale destinație copiază în ambele sensuri, inclusiv pe un container oprit. E potrivit pentru operații punctuale: extragi un log, un dump sau un artefact de build. Pentru date folosite constant, folosești volume sau bind mounts.

BASH
docker cp ./config.json api:/app/config.json      # host -> container
docker cp api:/app/logs/error.log ./error.log     # container -> host
docker cp api:/app/reports/. ./reports/           # conținutul folderului
docker cp - api:/tmp < arhiva.tar                 # din stdin, ca arhivă tar

Detalii:

  • Funcționează și pe containere oprite, util când un container a căzut și vrei fișierele lui. Fișierele din volume montate se copiază și ele.
  • Regula pentru foldere seamănă cu cp -a: folder copiază folderul însuși, folder/. copiază conținutul.
  • Fișierele copiate în container primesc implicit proprietarul root (sau UID-ul utilizatorului de pe host, în sens invers). Dacă aplicația rulează ca alt utilizator și trebuie să le scrie, ajustezi permisiunile; există opțiunea -a pentru păstrarea UID/GID.
  • Modificările făcute astfel în stratul writable se pierd când containerul e recreat.

Când e potrivit:

  • extragi rezultatul unui build dintr-o imagine: docker create --name tmp img && docker cp tmp:/out ./out && docker rm tmp;
  • iei loguri sau un dump de memorie pentru analiză;
  • testezi rapid o configurație înainte să o pui în Dockerfile.

Când nu e potrivit: ca metodă de deploy sau de configurare permanentă. Un container modificat manual nu mai corespunde imaginii, iar următorul deploy șterge schimbarea. Pentru a extrage artefacte la build există și docker build --output type=local,dest=./out.

Ce urmărește intervievatorul: Se verifică diferența dintre operații punctuale și configurație reproductibilă. Răspunsul slab folosește docker cp pentru deploy.

Eroarea, în practică:Could not find the file ... in container

72 Mid

Scrie comenzile pentru backup-ul și restaurarea unui volum Docker care conține datele unei aplicații.

Răspuns scurt: Pornești un container temporar care montează volumul și un folder de pe host, iar în el arhivezi conținutul cu tar. Restaurarea face invers, într-un volum nou sau gol. Pentru baze de date, preferi un dump logic, făcut cu unealta bazei de date.

Backup la nivel de fișiere:

BASH
docker stop app
docker run --rm \
  -v app-data:/data:ro \
  -v "$(pwd)":/backup \
  alpine tar czf /backup/app-data-$(date +%F).tar.gz -C /data .
docker start app

Restaurare:

BASH
docker volume create app-data-restore
docker run --rm \
  -v app-data-restore:/data \
  -v "$(pwd)":/backup:ro \
  alpine sh -c "tar xzf /backup/app-data-2026-10-30.tar.gz -C /data"

De ce așa:

  • Containerul temporar nu are nevoie de acces direct la /var/lib/docker, deci funcționează la fel pe Linux și pe Docker Desktop.
  • -C /data . arhivează conținutul cu căi relative, deci arhiva se poate restaura în orice volum.
  • tar păstrează proprietarii și permisiunile, importante pentru aplicațiile care rulează ca utilizator neprivilegiat.
  • Oprirea aplicației asigură consistența; o copiere a fișierelor unei baze de date în timpul scrierilor poate produce un backup corupt.

Pentru baze de date, metoda corectă este dump-ul logic, care nu cere oprirea:

BASH
docker exec db pg_dump -U app -Fc appdb > appdb.dump
docker exec -i db pg_restore -U app -d appdb --clean < appdb.dump
docker exec db mysqldump -u root -p"$PASS" --single-transaction appdb > appdb.sql

Un backup este valid doar după ce ai testat restaurarea. Automatizezi cu un job programat, copiezi arhivele în afara serverului și păstrezi mai multe generații.

Ce urmărește intervievatorul: Se verifică o sarcină practică des cerută. Greșeala frecventă este copierea fișierelor unei baze de date pornite, fără dump.

73 Mid

În dezvoltare montezi codul cu -v $(pwd):/app, iar aplicația Node dă „Cannot find module 'express'”, deși imaginea a rulat npm ci. De ce, și cum repari?

Răspuns scurt: Bind mount-ul acoperă tot folderul /app din imagine, inclusiv node_modules instalat la build. Containerul vede folderul de pe laptop, fără node_modules sau cu module compilate pentru alt sistem. Adaugi un volum separat pe /app/node_modules, care are prioritate față de bind mount.

Un mount ascunde complet ce exista la acea cale în imagine. Imaginea are /app/node_modules, dar după -v $(pwd):/app procesul vede doar fișierele de pe host. Dacă pe laptop nu ai rulat npm install, modulul lipsește. Dacă l-ai rulat pe macOS, modulele native (de exemplu bcrypt, sharp) sunt compilate pentru alt sistem și dau erori la încărcare.

Soluția clasică este un volum pe subfolder:

BASH
docker run -it --rm -p 3000:3000 \
  -v "$(pwd)":/app \
  -v app_node_modules:/app/node_modules \
  app:dev npm run dev

În Compose:

YAML
services:
  web:
    build: { context: ., target: dev }
    volumes:
      - .:/app
      - node_modules:/app/node_modules
volumes:
  node_modules:

Mount-ul mai specific (/app/node_modules) se aplică peste cel general. Un volum nou, gol, montat peste un folder din imagine este populat la prima pornire cu fișierele din imagine, deci primește node_modules de la build.

Capcana următoare: când adaugi o dependență, volumul păstrează versiunea veche. Reconstruiești imaginea și recreezi volumul (docker compose down -v pentru acel proiect sau docker volume rm), ori rulezi npm install în container.

Alternativa modernă este develop.watch din Compose, care sincronizează doar sursele în container și reconstruiește imaginea când se schimbă package.json, fără bind mount pe tot proiectul.

Ce urmărește intervievatorul: Se verifică înțelegerea suprapunerii mount-urilor. Este o problemă foarte frecventă în mediile de dezvoltare cu Docker.

Eroarea, în practică:Error: Cannot find module 'express'

74 Mid

De ce nu este ideal să dai parola bazei de date prin variabile de mediu în producție și cum folosești secretele montate ca fișiere în Compose?

Răspuns scurt: Variabilele de mediu se văd în docker inspect, se moștenesc de procesele copil și ajung ușor în loguri. Secretele din Compose sunt montate ca fișiere în /run/secrets/, cu acces controlat, iar aplicația sau imaginea le citește din fișier, de exemplu prin POSTGRES_PASSWORD_FILE.

YAML
services:
  db:
    image: postgres:16
    environment:
      POSTGRES_USER: app
      POSTGRES_PASSWORD_FILE: /run/secrets/db_password
    secrets:
      - db_password
  api:
    image: firma/api:1.4
    environment:
      DB_PASSWORD_FILE: /run/secrets/db_password
    secrets:
      - db_password
secrets:
  db_password:
    file: ./secrets/db_password.txt

În aplicație:

PYTHON
import os
from pathlib import Path

def secret(nume):
    cale = os.environ.get(f"{nume}_FILE")
    if cale:
        return Path(cale).read_text().strip()
    return os.environ[nume]

parola = secret("DB_PASSWORD")

De ce fișierele sunt preferate:

  • nu apar în docker inspect și nici în mediul proceselor copil;
  • se pot monta doar în serviciile care au nevoie de ele;
  • se pot roti prin înlocuirea fișierului, iar sursa poate fi un manager de secrete;
  • mai greu de afișat accidental într-un log de erori care tipărește mediul.

Limitări de știut: în Compose fără Swarm, un secret din file: este practic un bind mount al fișierului de pe host, deci securitatea depinde de permisiunile acelui fișier, care nu se pune în Git. În Swarm, secretele sunt criptate și distribuite doar nodurilor care rulează serviciul. În Kubernetes, conceptul echivalent este Secret montat ca volum.

.strip() contează: fișierele au adesea o linie nouă la final, care altfel devine parte din parolă.

Ce urmărește intervievatorul: Se verifică diferența practică dintre configurație și secret. Detaliul cu linia nouă de la final arată experiență reală.

Eroarea, în practică:SecretsUsedInArgOrEnv: sensitive data in ARG/ENV

75 Senior

Containerul scrie fișiere într-un bind mount, iar pe host acestea apar ca proprietatea lui root și nu le poți modifica. Pe de altă parte, un container care rulează ca utilizator neprivilegiat nu poate scrie în folderul montat. Cum rezolvi ambele probleme?

Răspuns scurt: Permisiunile se aplică după UID/GID numerice, comune host-ului și containerului. Rulezi containerul cu UID-ul tău (--user $(id -u):$(id -g)) sau construiești imaginea cu un utilizator al cărui UID coincide cu cel de pe host; pentru volume, dai drepturi folderului în imagine sau la inițializare.

Kernelul nu știe de nume de utilizatori, doar de numere. Dacă procesul din container rulează ca root (UID 0), fișierele create în bind mount aparțin lui root și pe host. Dacă rulează ca app cu UID 1001, iar folderul de pe host aparține utilizatorului tău cu UID 1000 și are permisiuni 755, procesul nu poate scrie.

Variante:

BASH
docker run --rm --user "$(id -u):$(id -g)" -v "$(pwd)":/work -w /work node:20 npm run build
  • --user la rulare: simplu pentru unelte și build-uri locale. Utilizatorul poate să nu existe în /etc/passwd din container, ceea ce deranjează unele programe care caută folderul home; setezi -e HOME=/tmp.
  • UID configurabil la build:
ARG UID=1000
ARG GID=1000
RUN groupadd -g $GID app && useradd -u $UID -g $GID -m app
USER app
  • Pentru volume Docker (nu bind mounts), creezi folderul în imagine cu proprietarul corect înainte de VOLUME sau de montare: la prima utilizare, volumul gol preia proprietarul și permisiunile din imagine.
  • Unele imagini oficiale pornesc ca root, ajustează permisiunile pe folderul de date în entrypoint, apoi trec la un utilizator neprivilegiat cu gosu sau su-exec.

Pe Docker Desktop, partajarea de fișiere traduce de obicei proprietarii, deci problema apare mai ales pe Linux. Soluțiile de tip chmod 777 pe folderul montat „merg”, dar deschid folderul oricui de pe host și ascund problema, nu o rezolvă. Varianta robustă pe servere este modul rootless sau user namespaces (userns-remap), care mapează root din container pe un UID neprivilegiat de pe host.

Ce urmărește intervievatorul: Se verifică înțelegerea UID-urilor numerice partajate. Răspunsul cu chmod 777 este semnalul unui candidat care nu a înțeles problema.

Eroarea, în practică:PermissionError: [Errno 13] Permission denied

76 Senior

Ai rula baza de date de producție într-un container Docker pe un server? Ce condiții ai pune?

Răspuns scurt: Se poate, cu date pe un volum dedicat, backup automat testat, monitorizare, limite de resurse și o procedură de upgrade. Pentru multe echipe, un serviciu gestionat (de exemplu Amazon RDS) rămâne mai sigur, pentru că preia backup-ul, failover-ul și patch-urile.

Containerul nu face baza de date mai puțin stabilă; riscurile vin din operare. Răspunsul bun discută condițiile, nu un „da” sau „nu” absolut.

Condiții minime:

  • Stocare: date pe un volum cu nume sau pe un disc dedicat, montat în container, niciodată în stratul writable. Știi exact unde e volumul și ce se întâmplă la docker compose down -v.
  • Backup: dump-uri logice programate și, pentru PostgreSQL sau MySQL, eventual arhivare continuă a jurnalelor (WAL, binlog) pentru restaurare la un moment dat. Copiile pleacă de pe server, iar restaurarea e testată periodic.
  • Versiuni: tag fixat (postgres:16.4), nu latest. Un upgrade major (de exemplu de la 15 la 16) cere pg_upgrade sau dump și restore; schimbarea tag-ului pe un volum vechi nu funcționează.
  • Resurse: limite de memorie corelate cu configurația bazei (shared_buffers, innodb_buffer_pool_size), ca OOM killer-ul să nu omoare serverul în mijlocul scrierilor.
  • Oprire: stop_grace_period suficient de lung, ca baza de date să termine checkpoint-ul.
  • Rețea: portul nepublicat sau legat doar de localhost, parole din secrete.
  • Monitorizare: spațiu pe disc, conexiuni, replicare, interogări lente.

Când aș alege un serviciu gestionat: date critice, nevoie de failover automat, echipă fără un responsabil clar pentru baza de date. Pentru medii de dezvoltare, test și staging, containerele sunt alegerea evidentă: pornesc instant, sunt identice între colegi și se resetează ușor.

Ce urmărește intervievatorul: Intervievatorul verifică judecata, nu o regulă memorată. Greșeala tipică este un răspuns absolut, fără condiții operaționale.

Docker Compose

77 Junior

Ce este Docker Compose și ce fac comenzile up, ps, logs și down? Care e diferența dintre docker compose și docker-compose?

Răspuns scurt: Compose descrie într-un fișier YAML (compose.yaml) serviciile, rețelele și volumele unei aplicații și le gestionează împreună. up creează și pornește, ps listează, logs afișează jurnalele, down oprește și șterge containerele și rețelele. docker compose este Compose v2, plugin al CLI-ului; docker-compose e vechiul v1, abandonat.

Un fișier minimal:

YAML
services:
  web:
    image: nginx:1.27
    ports:
      - "8080:80"
  cache:
    image: redis:7.4
BASH
docker compose up -d          # creează rețeaua, pornește serviciile în fundal
docker compose ps             # starea serviciilor proiectului
docker compose logs -f web    # jurnalul unui serviciu, în timp real
docker compose down           # oprește și șterge containerele și rețeaua

Ce face Compose în spate: aceleași operații ca docker network create și docker run, dar declarativ și repetabil. La un nou up, compară configurația cu containerele existente și le recreează doar pe cele schimbate.

Despre versiuni:

  • docker-compose (cu cratimă) este Compose v1, scris în Python. Nu mai primește actualizări din 2023.
  • docker compose (cu spațiu) este Compose v2, scris în Go, distribuit ca plugin al CLI-ului Docker.
  • Câmpul version: "3.8" din vârful fișierului este ignorat de v2 și poate fi omis. Fișierul se numește de preferință compose.yaml, deși docker-compose.yml e încă recunoscut.

Unde e util: mediul de dezvoltare local cu toate dependențele, testele de integrare în CI, aplicații mici pe un singur server. Compose nu distribuie containere pe mai multe mașini; pentru asta există orchestratoare.

Ce urmărește intervievatorul: Se verifică familiaritatea de bază cu Compose. Mențiunea diferenței v1/v2 arată că folosești unelte actuale.

Eroarea, în practică:no configuration file provided: not founddocker: 'compose' is not a docker command

78 Junior

Ai modificat codul unui serviciu care are build: . în compose.yaml. De ce docker compose up -d nu vede modificarea și ce rulezi?

Răspuns scurt: Compose construiește imaginea doar dacă nu există; la următoarele up o refolosește, chiar dacă sursele s-au schimbat. Rulezi docker compose up -d --build sau docker compose build urmat de up -d, iar Compose recreează containerele cu imaginea nouă.

YAML
services:
  api:
    build:
      context: ./api
      dockerfile: Dockerfile
      target: prod
      args:
        APP_VERSION: "1.4.0"
    image: firma/api:dev
    ports:
      - "8000:8000"
BASH
docker compose up -d --build api     # reconstruiește și recreează doar api
docker compose build --no-cache api  # build curat, fără cache
docker compose up -d --force-recreate api

Cum decide Compose:

  • La up, dacă imaginea serviciului există local, o folosește. Nu verifică dacă fișierele din context s-au schimbat.
  • Cu --build, rulează build-ul. Datorită cache-ului de straturi, dacă nimic nu s-a schimbat, durează câteva secunde.
  • După build, containerul e recreat doar dacă imaginea sau configurația diferă. --force-recreate îl recreează oricum.

Câmpuri utile:

  • image: alături de build: dă un nume imaginii construite, util pentru docker compose push.
  • target: alege etapa dintr-un Dockerfile multi-stage.
  • pull_policy: build forțează build-ul la fiecare up.
  • docker compose up --pull always actualizează imaginile luate din registry pentru serviciile fără build.

În dezvoltare, pentru a vedea codul nou fără rebuild, se folosește un bind mount sau develop.watch. Rebuild-ul rămâne necesar când se schimbă dependențele sau Dockerfile-ul.

Ce urmărește intervievatorul: Este o capcană frecventă la cei care încep cu Compose. Intervievatorul verifică dacă știi când se face build și când se recreează containerul.

79 Junior

Ce valori ajung în container pentru PORT, DEBUG și TAG în exemplul de mai jos? Care e diferența dintre fișierul .env și env_file:?

# .env
TAG=1.4
PORT=9000
# api.env
DEBUG=true
PORT=8000
YAML
services:
  api:
    image: firma/api:${TAG}
    env_file: api.env
    environment:
      PORT: 8080

Răspuns scurt: În container, PORT=8080 (din environment, care are prioritate față de env_file) și DEBUG=true. TAG nu ajunge în container: .env servește la interpolarea variabilelor din compose.yaml, deci imaginea devine firma/api:1.4.

Sunt două mecanisme diferite, care se confundă des:

  • .env din folderul proiectului: citit de Compose însuși, pentru a înlocui ${VAR} în fișierul YAML. Valorile nu sunt trimise automat în containere. Variabilele din shell au prioritate față de .env, deci TAG=2.0 docker compose up folosește 2.0.
  • env_file:: listă de fișiere ale căror variabile sunt puse în mediul containerului.
  • environment:: variabile setate direct; au prioritate față de env_file.

Pentru exemplu:

  • PORT din .env (9000) nu contează, pentru că .env nu ajunge în container. api.env dă 8000, environment dă 8080, iar câștigă environment.
  • DEBUG=true vine din api.env.
  • TAG este folosit doar la interpolare.

Verifici rezultatul final fără să pornești nimic:

BASH
docker compose config          # YAML-ul rezolvat
docker compose run --rm api env | sort

Dacă vrei ca o valoare din .env să ajungă în container, o referi explicit:

YAML
environment:
  PORT: ${PORT}

Alte detalii: .env se pune în .gitignore, iar în repository păstrezi un .env.example. Poți alege alt fișier cu docker compose --env-file prod.env up. Valorile yes, no, true necitate în YAML pot fi interpretate ca booleeni; pentru siguranță le pui între ghilimele.

Ce urmărește intervievatorul: Se verifică o confuzie foarte frecventă între interpolare și mediul containerului. Majoritatea candidaților cred că .env ajunge automat în container.

Eroarea, în practică:The "DB_PAROLA" variable is not setenv file .env not found

80 Junior

Care e diferența dintre docker compose exec api sh și docker compose run --rm api sh? Când o folosești pe fiecare?

Răspuns scurt: exec rulează comanda în containerul deja pornit al serviciului. run creează un container nou din configurația serviciului, fără porturile publicate implicit, iar cu --rm îl șterge la final. exec e pentru inspectarea unui serviciu care rulează, run pentru comenzi punctuale: migrări, teste, scripturi.

BASH
docker compose exec api sh                        # intri în containerul pornit
docker compose exec db psql -U app appdb          # client în baza de date
docker compose exec -u root api sh                # ca alt utilizator
docker compose run --rm api python manage.py migrate
docker compose run --rm --service-ports api       # cu porturile din ports
docker compose run --rm --no-deps api pytest      # fără să pornească dependențele

Diferențe:

  • exec cere ca serviciul să ruleze. Vezi exact procesul și fișierele containerului în funcțiune, inclusiv ce a scris aplicația în stratul writable. Ce modifici acolo se pierde la recrearea containerului.
  • run pornește un container nou, cu aceeași imagine, aceleași volume, rețele și variabile. Implicit pornește și serviciile din depends_on, nu publică porturile din ports (ca să nu intre în conflict cu serviciul care rulează) și înlocuiește comanda serviciului cu cea primită.

Când aleg:

  • depanez un serviciu care rulează (loguri locale, fișiere, conexiuni): exec;
  • rulez o migrare, un seed, un script de administrare sau testele: run --rm;
  • serviciul nu pornește deloc, deci exec nu are unde intra: run --rm --entrypoint sh api.

Fără --rm, fiecare run lasă în urmă un container oprit, cu nume de tipul proiect-api-run-<id>. În CI se folosește -T cu exec pentru a dezactiva alocarea de TTY.

Ce urmărește intervievatorul: Se verifică diferența între containerul existent și unul nou. Mulți folosesc doar exec și nu știu cum să ruleze o migrare când serviciul e oprit.

Eroarea, în practică:Error response from daemon: container is not running

81 Junior

Ce diferență este între docker compose stop, docker compose down, down -v și down --rmi all? Care dintre ele șterge datele bazei de date?

Răspuns scurt: stop doar oprește containerele. down le șterge, împreună cu rețelele proiectului, dar păstrează volumele. down -v șterge și volumele declarate și pe cele anonime, deci datele bazei de date. --rmi all șterge și imaginile serviciilor.

BASH
docker compose stop          # containerele rămân, pornesc la loc cu start
docker compose start
docker compose down          # șterge containerele și rețelele proiectului
docker compose down -v       # + volumele proiectului: date pierdute
docker compose down --rmi local   # + imaginile construite local (fără tag propriu)
docker compose down --rmi all     # + toate imaginile serviciilor
docker compose down --remove-orphans

Ce trebuie reținut:

  • După stop, stratul writable al containerelor rămâne. După down, nu, dar volumele, deci datele bazei, rămân și vor fi refolosite la următorul up.
  • down -v este util când vrei un mediu complet curat (de exemplu după ce ai schimbat parola inițială a bazei, care se aplică doar pe un volum gol). Pe un server, aceeași comandă înseamnă pierderea datelor. Unele echipe declară volumele critice ca external: true; Compose nu le creează și nu le șterge.
  • --remove-orphans șterge containerele unor servicii pe care le-ai eliminat între timp din fișier.
  • --rmi local șterge doar imaginile fără un nume personalizat, deci pe cele construite de Compose fără image:.

Volumele declarate external se creează manual (docker volume create pgdata) și se referă așa:

YAML
volumes:
  pgdata:
    external: true

La interviu, merită spus explicit că down -v este o comandă distructivă, care nu trebuie să apară în scripturile de deploy.

Ce urmărește intervievatorul: Se verifică dacă știi ce comandă distruge date. Confuzia dintre down și down -v a costat multe baze de date de test și uneori de producție.

82 Mid

Aplicația are nevoie ca migrările bazei de date să ruleze o singură dată, după ce PostgreSQL e pregătit și înainte de pornirea API-ului. Cum exprimi asta în Compose?

Răspuns scurt: Folosești forma lungă a lui depends_on: migrate așteaptă db cu condition: service_healthy, iar api așteaptă migrate cu condition: service_completed_successfully. Baza de date are un healthcheck cu pg_isready.

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

  migrate:
    image: firma/api:1.4
    command: ["python", "manage.py", "migrate", "--noinput"]
    depends_on:
      db:
        condition: service_healthy

  api:
    image: firma/api:1.4
    ports:
      - "8000:8000"
    depends_on:
      migrate:
        condition: service_completed_successfully
      db:
        condition: service_healthy

volumes:
  pgdata:

Cum funcționează condițiile:

  • service_started (implicit, forma scurtă): așteaptă doar ca containerul să fie pornit, nu ca serviciul să fie pregătit.
  • service_healthy: așteaptă starea healthy dată de healthcheck.
  • service_completed_successfully: așteaptă ca serviciul să se termine cu codul 0. Dacă migrarea eșuează, api nu pornește, iar docker compose up raportează eroarea.

Limite: depends_on controlează doar ordinea la pornire. Dacă baza de date repornește mai târziu, API-ul trebuie să-și refacă singur conexiunile. Opțiunea restart: true din depends_on (Compose 2.17+) repornește dependentul când dependența e recreată de Compose. Containerul migrate rămâne în starea exited (0), ceea ce este normal.

Ce urmărește intervievatorul: Se verifică ordinea reală a pornirii, nu doar depends_on simplu. Puțini candidați cunosc service_completed_successfully.

Eroarea, în practică:dependency failed to start: container is unhealthycontainer has no healthcheck configured

83 Mid

Cum alege Compose numele containerelor, al rețelei și al volumelor? Cum rulezi două copii independente ale aceluiași proiect pe aceeași mașină?

Răspuns scurt: Compose prefixează totul cu numele proiectului, implicit numele folderului: rețeaua proiect_default, volumul proiect_pgdata, containerele proiect-api-1. Pentru două copii independente, dai nume de proiect diferite cu -p sau COMPOSE_PROJECT_NAME și eviți porturile fixe pe host.

Pentru un folder magazin cu serviciile api și db și volumul pgdata:

rețea:      magazin_default
volum:      magazin_pgdata
containere: magazin-api-1, magazin-db-1

În rețeaua default, fiecare serviciu e accesibil după numele lui (db), indiferent de numele containerului. Compose pune și etichete (com.docker.compose.project, com.docker.compose.service), după care își recunoaște resursele.

Două copii, de exemplu pentru două ramuri sau pentru teste în paralel în CI:

BASH
docker compose -p magazin-pr42 up -d
docker compose -p magazin-pr57 up -d
docker compose -p magazin-pr42 down -v

Fiecare proiect are rețea, volume și containere separate. Ce poate intra în conflict:

  • porturile publicate fix ("8000:8000"): le parametrizezi ("${API_PORT:-8000}:8000") sau lași Docker să aleagă ("8000", apoi docker compose port api 8000);
  • container_name: fix în fișier: împiedică și scalarea, și copiile multiple, deci e mai bine să lipsească;
  • volumele sau rețelele external, care sunt partajate intenționat.

Numele proiectului se poate fixa și în fișier, cu cheia name: de la nivelul de sus, util când folderul are un nume generic precum app. Atenție: două foldere cu același nume în locuri diferite vor folosi același proiect și își pot suprascrie containerele.

Ce urmărește intervievatorul: Se verifică înțelegerea izolării pe proiecte. Mulți folosesc container_name fără să știe ce limitări introduce.

Eroarea, în practică:get magazin-date: no such volumecan't set container_name and replicas

84 Mid

Cum folosești profilele și fișierele override în Compose ca să ai unelte de dezvoltare (Adminer, Mailpit) disponibile doar la cerere și setări diferite local față de server?

Răspuns scurt: Serviciile cu profiles: [debug] nu pornesc la up decât dacă activezi profilul cu --profile debug. compose.override.yaml este combinat automat cu compose.yaml, iar cu -f alegi explicit fișierele pentru fiecare mediu.

YAML
# compose.yaml
services:
  api:
    image: firma/api:${TAG:-latest}
    environment:
      DB_HOST: db
  db:
    image: postgres:16
  adminer:
    image: adminer:4
    ports: ["8081:8080"]
    profiles: [debug]
  mailpit:
    image: axllent/mailpit
    ports: ["8025:8025"]
    profiles: [debug]
YAML
# compose.override.yaml (doar local, aplicat automat)
services:
  api:
    build: .
    volumes:
      - .:/app
    ports: ["8000:8000"]
    environment:
      DEBUG: "1"
BASH
docker compose up -d                          # api + db, cu override-ul local
docker compose --profile debug up -d          # + adminer și mailpit
docker compose -f compose.yaml -f compose.prod.yaml up -d   # pe server

Reguli de combinare: valorile simple se suprascriu, environment și labels se combină pe chei, iar ports și volumes se adaugă la cele din fișierul de bază. Ordinea fișierelor din -f contează: ultimul câștigă.

Alternative și detalii:

  • COMPOSE_PROFILES=debug în .env activează profilul implicit pentru un coleg.
  • Un serviciu fără profiles pornește mereu; dacă unul din profil depinde de el, e pornit automat.
  • include: (Compose 2.20+) permite compunerea din mai multe fișiere ale unor echipe diferite.
  • Pe server nu vrei bind mount-uri pe cod și porturi de depanare, deci compose.override.yaml nu se copiază acolo sau folosești -f explicit.

Ce urmărește intervievatorul: Se verifică organizarea unui mediu Compose real, cu mai multe medii. Greșeala tipică este duplicarea completă a fișierului pentru fiecare mediu.

85 Mid

Ce face docker compose config și cum folosești interpolarea ${VAR:-implicit} și ${VAR:?mesaj} ca să eviți configurații greșite?

Răspuns scurt: docker compose config validează fișierul și afișează configurația finală, după combinarea fișierelor și înlocuirea variabilelor. ${VAR:-x} folosește x când variabila lipsește sau e goală, iar ${VAR:?mesaj} oprește Compose cu eroare, deci o variabilă obligatorie nu poate lipsi neobservat.

YAML
services:
  api:
    image: firma/api:${TAG:?Setează TAG, de exemplu TAG=1.4.0}
    ports:
      - "${API_PORT:-8000}:8000"
    environment:
      LOG_LEVEL: ${LOG_LEVEL:-info}
      SENTRY_DSN: ${SENTRY_DSN-}
BASH
docker compose config                 # tot fișierul rezolvat
docker compose config --services      # doar numele serviciilor
docker compose config --quiet && echo valid
TAG= docker compose config            # eroare: Setează TAG...

Variante de interpolare:

  • ${VAR} sau $VAR: valoarea, sau șir gol cu un avertisment dacă lipsește.
  • ${VAR:-x}: x dacă variabila lipsește sau e goală; ${VAR-x} doar dacă lipsește.
  • ${VAR:?mesaj}: eroare dacă lipsește sau e goală; ${VAR?mesaj} doar dacă lipsește.
  • $$: un $ literal, necesar în comenzi care folosesc variabile ale shell-ului din container, de exemplu command: sh -c "echo $$HOSTNAME".

De ce contează:

  • Fără :?, un TAG uitat în CI produce firma/api: sau trage latest, iar deploy-ul pare reușit.
  • config în pipeline prinde erorile de indentare și cheile scrise greșit înainte de deploy.
  • La depanare, config arată exact ce primește Docker după combinarea override-urilor, deci nu mai ghicești care fișier a câștigat.

Atenție: config afișează și valorile secrete interpolate; nu-i salva ieșirea în loguri publice.

Ce urmărește intervievatorul: Se verifică folosirea defensivă a configurației. Lipsa lui $$ în comenzi și tag-urile goale sunt erori întâlnite des.

Eroarea, în practică:The "DB_PAROLA" variable is not set

86 Mid

Ce este develop.watch în Docker Compose și prin ce diferă de un bind mount pentru dezvoltare?

Răspuns scurt: develop.watch (Compose 2.22+) urmărește fișierele locale și, la modificare, le sincronizează în container (sync), reconstruiește imaginea (rebuild) sau repornește serviciul (sync+restart). Spre deosebire de un bind mount, nu suprapune folderul întreg și reacționează diferit după tipul fișierului.

YAML
services:
  web:
    build: .
    ports: ["3000:3000"]
    command: ["npm", "run", "dev"]
    develop:
      watch:
        - action: sync
          path: ./src
          target: /app/src
          ignore:
            - "**/*.test.js"
        - action: rebuild
          path: package.json
        - action: sync+restart
          path: ./config
          target: /app/config
BASH
docker compose watch
# sau
docker compose up --watch

Acțiunile:

  • sync: copiază fișierele modificate în container; serverul de dezvoltare cu hot reload le preia imediat.
  • rebuild: reconstruiește imaginea și recreează containerul, potrivit când se schimbă dependențele.
  • sync+restart: copiază și repornește containerul, util pentru configurații citite doar la pornire.

Comparativ cu bind mount-ul:

  • node_modules și alte foldere din imagine rămân neatinse, deci dispare problema modulelor ascunse sau compilate pentru alt sistem.
  • Pe macOS și Windows evită costul de performanță al partajării continue a fișierelor între sistem și mașina virtuală.
  • Sincronizarea e într-un singur sens, de la host la container. Fișierele generate în container (de exemplu migrări create de framework) nu apar automat pe laptop; pentru acelea un bind mount rămâne util.
  • Containerul trebuie să conțină în imagine tot ce e necesar ca să pornească, inclusiv codul.

Pentru proiecte mari, ignore contează, ca să nu sincronizezi foldere de build sau fișiere temporare.

Ce urmărește intervievatorul: Se verifică familiaritatea cu fluxurile de dezvoltare actuale. Candidații care au lucrat doar cu bind mount-uri descriu de obicei problemele, nu și această alternativă.

87 Senior

Ai folosi Docker Compose în producție? În ce situații da și ce limite are față de un orchestrator precum Kubernetes?

Răspuns scurt: Da, pentru aplicații mici sau medii pe un singur server, unde simplitatea contează mai mult decât disponibilitatea ridicată. Limitele: rulează pe o singură mașină, nu are rolling update sau autoscalare, iar repornirea după erori se reduce la politicile de restart.

Unde Compose e o alegere rezonabilă în producție:

  • un produs intern sau un site cu trafic modest, pe un singur VPS;
  • o echipă mică, fără cineva care să administreze un cluster;
  • medii de staging sau demo identice cu mediul local.

Ce trebuie adăugat ca să fie solid:

  • restart: unless-stopped pe toate serviciile și healthcheck pe cele importante;
  • imagini cu tag-uri fixe, construite în CI, nu build: pe server;
  • un reverse proxy cu TLS (Caddy, Traefik, nginx) ca singurul serviciu cu porturi publicate;
  • limite de resurse (deploy.resources.limits, respectate de Compose v2), rotația logurilor, monitorizare și backup-uri externe;
  • deploy prin docker compose pull && docker compose up -d, eventual cu un script care verifică sănătatea după.

Limitele față de Kubernetes:

  • O singură mașină: dacă serverul cade, cade tot. Nu există mutarea automată a containerelor pe alt nod.
  • Deploy: up -d recreează containerul, cu o scurtă întrerupere; rolling update-ul fără downtime trebuie construit manual.
  • Sănătate: un container unhealthy nu este înlocuit automat.
  • Scalare: --scale pe același host, fără autoscalare și fără echilibrare inclusă.
  • Secrete și configurație: mai rudimentare decât Secrets, ConfigMaps și RBAC.

Între cele două extreme există Docker Swarm, care folosește un format apropiat de Compose pe mai multe noduri, dar e mult mai puțin adoptat. Decizia bună pornește de la cerințele de disponibilitate și de la capacitatea echipei, nu de la popularitatea uneltei.

Ce urmărește intervievatorul: Se verifică judecata arhitecturală. Răspunsurile slabe sunt dogmatice: „Compose e doar pentru dezvoltare” sau „Kubernetes pentru orice”.

Depanare, securitate și producție

Exersează capitolul cu exerciții reale: Curs Docker →
88 Junior

Containerul API intră în buclă de reporniri (Restarting (1)). Cum depanezi pas cu pas?

Răspuns scurt: Citești logurile containerului și codul de ieșire, verifici configurația primită (variabile, mount-uri, comandă) cu docker inspect, apoi pornești imaginea cu un shell în loc de aplicație și rulezi manual comanda de pornire, ca să vezi eroarea direct.

Un plan structurat, de spus cu voce tare la interviu:

1. Ce spune containerul:

BASH
docker ps -a --filter name=api
docker logs --tail 100 api
docker inspect -f 'Exit={{.State.ExitCode}} OOM={{.State.OOMKilled}} Err={{.State.Error}}' api

Codul de ieșire restrânge căutarea: 1 eroare de aplicație, 127 comandă inexistentă, 137 OOM sau kill.

2. Ce a primit: comanda reală, variabilele și volumele.

BASH
docker inspect -f '{{json .Config.Cmd}} {{json .Config.Entrypoint}}' api
docker inspect -f '{{json .Config.Env}}' api
docker inspect -f '{{json .Mounts}}' api

Cauze frecvente: o variabilă obligatorie lipsă, un fișier de configurație montat ca folder, un secret cu altă cale.

3. Reproduce manual: oprești bucla (docker update --restart no api sau docker stop api) și pornești imaginea cu shell:

BASH
docker run --rm -it --env-file api.env --entrypoint sh firma/api:1.4
# în container: rulezi comanda din CMD și vezi eroarea

4. Dependențe: baza de date sau alt serviciu nu e accesibil (DNS, rețea, parolă). Testezi conexiunea din aceeași rețea.

5. Ce s-a schimbat: imaginea nouă față de cea veche (docker history, diferențe de tag), configurația sau mediul. Revii la versiunea anterioară dacă e producție și investighezi după.

Esențial: nu modifici containerul în producție ca să-l faci să pornească. Corectura ajunge în imagine sau în configurație, prin procesul normal de deploy.

Ce urmărește intervievatorul: Intervievatorul urmărește metoda: de la observație la ipoteză și verificare. Greșeala tipică este să repornești în continuu sau să reconstruiești fără să citești logurile.

Eroarea, în practică:Containerul se oprește imediat: Exited (1)

89 Junior

Unde ajung logurile unei aplicații din container, cum le citești eficient și de ce pot umple discul serverului?

Răspuns scurt: Docker colectează ce scrie procesul principal pe stdout și stderr, prin driverul de logging, implicit json-file, în fișiere pe host. Le citești cu docker logs -f --tail --since. Fără rotație, fișierele cresc nelimitat, deci configurezi max-size și max-file.

BASH
docker logs -f --tail 200 api          # ultimele 200 de linii, apoi în timp real
docker logs --since 30m -t api         # ultimele 30 de minute, cu timestamp
docker logs api 2>&1 | grep -i error
docker compose logs -f --tail 50 api worker

Reguli pentru aplicație:

  • Scrie logurile pe stdout/stderr, nu în fișiere din container. Altfel, docker logs e gol, iar fișierele se pierd la recrearea containerului sau umplu stratul writable. Imaginea oficială nginx, de exemplu, leagă fișierele de log de /dev/stdout și /dev/stderr.
  • Preferă formatul structurat (JSON), ușor de procesat de un sistem central.

Rotația, implicit pentru tot daemonul, în /etc/docker/daemon.json:

JSON
{
  "log-driver": "local",
  "log-opts": { "max-size": "20m", "max-file": "5" }
}

sau per serviciu în Compose:

YAML
logging:
  driver: json-file
  options:
    max-size: "20m"
    max-file: "5"

Setările din daemon.json se aplică doar containerelor create după repornirea daemonului. Driverul local are rotație implicită și un format mai compact.

Alte drivere trimit logurile direct în altă parte: journald, syslog, fluentd, awslogs, gcplogs. Pentru infrastructuri cu multe servere, logurile se colectează centralizat. Pe drivere de la distanță, docker logs poate să nu mai funcționeze, în funcție de driver și de modul „dual logging” al daemonului.

Ce urmărește intervievatorul: Se verifică atât folosirea zilnică, cât și operarea. Un server cu discul plin din cauza logurilor Docker este un incident clasic.

90 Junior

Scrie comenzile docker inspect cu --format care afișează adresa IP a unui container, volumele montate, variabilele de mediu și ora la care a pornit.

Răspuns scurt: --format primește un template Go aplicat pe JSON-ul din inspect. Câmpurile utile sunt .NetworkSettings.Networks, .Mounts, .Config.Env și .State.StartedAt; cu range iterezi listele, iar cu json afișezi structuri întregi.

BASH
# IP-ul în fiecare rețea
docker inspect -f '{{range $net, $cfg := .NetworkSettings.Networks}}{{$net}}: {{$cfg.IPAddress}}{{"\n"}}{{end}}' api

# mount-urile: tip, sursă, destinație, doar-citire
docker inspect -f '{{range .Mounts}}{{.Type}} {{.Source}} -> {{.Destination}} rw={{.RW}}{{"\n"}}{{end}}' api

# variabilele de mediu, câte una pe linie
docker inspect -f '{{range .Config.Env}}{{println .}}{{end}}' api

# starea și ora pornirii
docker inspect -f '{{.State.Status}} pornit la {{.State.StartedAt}} restarts={{.RestartCount}}' api

# o structură întreagă, formatată
docker inspect -f '{{json .HostConfig.RestartPolicy}}' api
docker inspect api | jq '.[0].HostConfig.Memory'

Ce trebuie știut:

  • docker inspect funcționează pe containere, imagini, volume și rețele; cu --type eviți ambiguitatea când un nume există în mai multe categorii.
  • Template-ul Go are funcții utile: json, index, join, upper, println. De exemplu {{join .Config.Cmd " "}}.
  • Aceleași template-uri merg la docker ps --format și docker images --format, de exemplu docker ps --format 'table {{.Names}}\t{{.Status}}\t{{.Ports}}'.
  • Pentru scripturi, jq pe JSON-ul complet e adesea mai lizibil decât un template lung.

Atenție: variabilele afișate pot conține parole. Nu lipi ieșirea în tichete sau canale de chat fără să o verifici.

Ce urmărește intervievatorul: Se verifică abilitatea de a extrage rapid informații în timpul unei depanări. Mulți candidați citesc tot JSON-ul manual.

Eroarea, în practică:template: map has no entry for key

91 Junior

De ce este riscant să rulezi aplicația ca root într-un container, dacă ea e oricum izolată? Cum verifici cu ce utilizator rulează un container?

Răspuns scurt: Fără user namespaces, root din container este UID 0 și pe host. O vulnerabilitate a aplicației, combinată cu un mount greșit, o capability în plus sau un bug de kernel, poate deveni root pe server. Verifici cu docker exec <c> id.

Izolarea containerului reduce riscul, dar nu îl elimină. Root în container înseamnă:

  • Același UID cu root de pe host: orice fișier de pe host montat în container (un bind mount, un socket) poate fi citit și modificat ca root.
  • Capabilities: Docker oferă implicit un set restrâns, dar root le are pe toate cele permise. Un neprivilegiat nu le are deloc implicit.
  • Ieșirea din container: vulnerabilitățile de tip container escape, din runtime sau din kernel, sunt mult mai ușor de exploatat de un proces root.
  • Modificarea containerului: un atacator care obține execuție de cod poate instala unelte, modifica binarele și persista în container.

Verificări:

BASH
docker exec api id
docker inspect -f 'User="{{.Config.User}}"' api   # gol = root
docker top api -eo user,pid,cmd

Remedieri, de la cea mai simplă:

  • USER în Dockerfile, cu un UID fix neprivilegiat;
  • docker run --user 1001:1001 pentru imagini terțe care suportă asta;
  • imagini care rulează deja neprivilegiat (nginxinc/nginx-unprivileged, distroless nonroot);
  • la nivel de daemon: modul rootless sau userns-remap, unde root din container este mapat pe un UID fără drepturi pe host.

Consecințe practice: aplicația ascultă pe un port peste 1024 și scrie doar în foldere care îi aparțin. În Kubernetes, politicile de securitate pot refuza containerele root (runAsNonRoot: true), deci imaginea trebuie pregătită din start.

Ce urmărește intervievatorul: Se verifică înțelegerea modelului de amenințare, nu doar regula. Răspunsul slab este „pentru că e o bună practică”.

92 Mid

Ce fac opțiunile --cap-drop ALL, --cap-add NET_BIND_SERVICE, --read-only și --security-opt no-new-privileges? De ce --privileged e periculos?

Răspuns scurt: Capabilities împart puterile lui root în drepturi separate; --cap-drop ALL le elimină pe toate, iar --cap-add le adaugă doar pe cele necesare. --read-only face sistemul de fișiere al containerului imutabil, iar no-new-privileges blochează escaladarea prin binare setuid. --privileged dă aproape toate drepturile host-ului.

BASH
docker run -d --name web \
  --cap-drop ALL --cap-add NET_BIND_SERVICE \
  --read-only --tmpfs /tmp --tmpfs /var/cache/nginx --tmpfs /var/run \
  --security-opt no-new-privileges \
  -p 80:80 nginx:1.27
  • Capabilities: în loc de „root poate orice”, kernelul are drepturi separate: NET_BIND_SERVICE (porturi sub 1024), CHOWN, NET_ADMIN (configurare rețea), SYS_ADMIN (montări și multe altele) etc. Docker pornește containerele cu un set implicit redus. --cap-drop ALL plus adăugarea punctuală reduce și mai mult ce poate face un atacator.
  • --read-only: rădăcina containerului devine doar pentru citire. Aplicația scrie doar în volume și tmpfs declarate explicit. Un atacator nu poate modifica binarele sau lăsa fișiere.
  • no-new-privileges: un proces nu poate câștiga drepturi noi prin setuid sau setgid (de exemplu sudo).
  • Docker aplică implicit și un profil seccomp, care blochează zeci de apeluri de sistem periculoase, și AppArmor sau SELinux, unde sunt disponibile.

--privileged dezactivează majoritatea acestor protecții: toate capabilities, acces la toate dispozitivele din /dev, fără seccomp și fără AppArmor. Un proces root dintr-un astfel de container poate monta discul host-ului și poate prelua controlul serverului. E justificat doar pentru cazuri speciale (Docker-in-Docker, unele unelte de sistem) și chiar și atunci se caută alternative.

Pornești strict și adaugi doar ce cere aplicația, testând că funcționează; în Compose există cap_drop, cap_add, read_only, security_opt.

Ce urmărește intervievatorul: Se verifică cunoașterea mecanismelor concrete de întărire a containerelor. Candidații de nivel mid ar trebui să știe ce face --privileged în realitate.

Eroarea, în practică:Read-only file system în container

93 Mid

Scanerul raportează zeci de vulnerabilități în imaginea aplicației. Cum le prioritizezi și cum previi acumularea lor?

Răspuns scurt: Separi vulnerabilitățile din imaginea de bază de cele din dependențele aplicației, prioritizezi după severitate, existența unei remedieri și dacă pachetul e folosit efectiv. Previi acumularea prin imagini de bază mici, actualizate automat, scanare în CI și rebuild periodic.

Unelte uzuale: docker scout cves imagine, Trivy (trivy image firma/api:1.4), Grype, sau scanarea integrată în registry.

Prioritizare:

  • Sursa: pachet de sistem din imaginea de bază (OpenSSL, glibc) sau dependență a aplicației (o bibliotecă npm, un jar)?
  • Severitate și exploatabilitate: critic și high întâi, dar contează dacă există un exploit cunoscut și dacă vulnerabilitatea e accesibilă din rețea.
  • Remediere disponibilă: multe rapoarte conțin vulnerabilități fără patch. Filtrezi cu trivy image --ignore-unfixed.
  • Relevanța: un CVE într-un utilitar care nu rulează niciodată contează mai puțin decât unul în biblioteca HTTP. Documentezi excepțiile acceptate, cu dată de revizuire.

Remedieri:

  • reconstruiești cu --pull pe aceeași bază, ca să intre patch-urile;
  • treci la o variantă mai mică (slim, distroless), care elimină pachetele inutile și, odată cu ele, vulnerabilitățile;
  • actualizezi dependența aplicației sau versiunea runtime-ului.

Prevenire:

  • scanare în CI, cu prag de blocare (de exemplu niciun critic cu remediere disponibilă);
  • Renovate sau Dependabot pentru imaginile de bază și dependențe;
  • rebuild programat al imaginilor, chiar fără schimbări de cod, pentru că vulnerabilitățile se descoperă după publicare;
  • SBOM generat la build, ca la un CVE nou să afli rapid ce imagini sunt afectate.

Scopul nu e un raport cu zero linii, ci un proces prin care riscul real e cunoscut și scade.

Ce urmărește intervievatorul: Se verifică abordarea pragmatică a securității. Greșeala tipică este fie ignorarea rapoartelor, fie blocarea tuturor build-urilor pentru vulnerabilități fără remediere.

94 Mid

Un coleg care știe Docker te întreabă ce înseamnă trecerea aplicației pe Kubernetes. Cum îi explici, legând conceptele Kubernetes de ce știe deja?

Răspuns scurt: Imaginea rămâne aceeași; Kubernetes doar o rulează pe un cluster. Containerul ajunge în Pod, serviciul din Compose devine Deployment plus Service, variabilele devin ConfigMap și Secret, volumele devin PersistentVolumeClaim, iar healthcheck devine probe. Diferența mare: starea dorită e menținută automat.

Aș porni de la un compose.yaml pe care îl cunoaște și aș face corespondența:

  • imaginea: aceeași imagine OCI, din același registry. Bunele practici (tag-uri imuabile, utilizator neprivilegiat, loguri pe stdout) contează și mai mult.
  • container / docker run: un Pod, cea mai mică unitate, care poate avea unul sau mai multe containere ce împart rețeaua.
  • serviciu din Compose cu --scale: un Deployment, care ține un număr dorit de replici și face rolling update.
  • numele serviciului în rețeaua Compose: un Service, cu nume DNS și adresă stabilă, care echilibrează traficul între pod-uri.
  • ports publicate și reverse proxy-ul: Service de tip LoadBalancer sau un Ingress.
  • environment, env_file, secrets: ConfigMap și Secret.
  • volumele cu nume: PersistentVolumeClaim.
  • healthcheck: probele liveness, readiness și startup, care chiar acționează.
  • limitele de resurse: requests și limits.
  • restart: unless-stopped: comportamentul implicit al controller-elor.

Diferența de mentalitate: în Compose dai comenzi pe o mașină; în Kubernetes descrii starea dorită, iar controller-ele o mențin pe tot clusterul, mutând pod-urile când un nod cade.

Ce nu se schimbă: Kubernetes rulează containerele prin containerd, nu prin daemonul Docker, dar imaginile construite cu docker build funcționează la fel. Pentru început i-aș recomanda un cluster local (kind, minikube sau Kubernetes din Docker Desktop) și să traducă propriul compose.yaml.

Ce urmărește intervievatorul: Se verifică atât înțelegerea conceptelor, cât și capacitatea de a explica. Intervievatorul urmărește dacă pornești de la ce știe colegul.

95 Mid

Un coleg junior a reparat un bug intrând cu docker exec în containerul de producție și modificând un fișier, iar apoi a salvat containerul cu docker commit. Cum îi explici ce e greșit și ce ar trebui să facă?

Răspuns scurt: Îi explic, fără să-l învinovățesc, că modificarea se pierde la următorul deploy, că imaginea creată cu commit nu e reproductibilă și nu corespunde codului din Git. Corectura corectă trece prin cod, Dockerfile, CI și deploy, iar exec rămâne pentru diagnostic.

Structura răspunsului:

Contextul: recunosc că a rezolvat rapid o problemă reală, iar intenția a fost bună. Discuția are loc în privat și pornește de la proces, nu de la persoană.

Ce e problematic:

  • Containerul e efemer. La următorul docker compose up sau la orice recreare, modificarea dispare, iar bug-ul revine fără ca cineva să știe de ce.
  • O imagine făcută cu docker commit nu are Dockerfile: nimeni nu știe exact ce conține, nu se poate reconstrui, iar scanarea și review-ul nu au ce verifica. Poate include fișiere temporare, istoric de shell sau secrete.
  • Codul din Git nu mai corespunde cu ce rulează în producție, deci următoarea depanare pornește de la premise greșite.
  • Ocolirea pipeline-ului sare peste teste și peste aprobări.

Ce ar trebui făcut:

  • docker exec pentru a înțelege problema (loguri, fișiere, conexiuni);
  • corectura în cod sau în Dockerfile, cu un test care reproduce bug-ul;
  • pull request, build în CI, imagine nouă cu tag nou, deploy;
  • dacă e urgent, un hotfix rapid tot prin pipeline, nu în afara lui.

Pași de urmărit: verificăm împreună că fix-ul e în Git și că imaginea modificată manual nu mai e folosită. Dacă pipeline-ul e prea lent pentru urgențe, asta e o problemă separată de rezolvat, nu un motiv să-l ocolim.

Închei cu o regulă ușor de reținut: containerele se înlocuiesc, nu se repară.

Ce urmărește intervievatorul: Întrebarea comportamentală verifică dacă poți explica principiul imuabilității și dacă o faci constructiv. Răspunsul slab fie e prea dur, fie consideră commit acceptabil.

96 Senior

De ce montarea /var/run/docker.sock într-un container (de exemplu pentru un agent de CI sau un dashboard) este o problemă de securitate? Ce alternative ai?

Răspuns scurt: Socket-ul dă acces complet la API-ul daemonului Docker, care rulează ca root. Cine îl poate folosi poate porni un container --privileged cu discul host-ului montat, deci practic are root pe server. Alternativele: socket proxy cu drepturi limitate, Docker rootless, builder-e fără daemon sau runner-e izolate.

Un container cu socket-ul montat poate rula:

BASH
docker run --rm -it --privileged -v /:/host alpine chroot /host sh

și obține un shell root pe host. Nu contează că procesul din container rulează ca utilizator neprivilegiat, dacă are drept de scriere pe socket. Montarea cu :ro nu ajută: ro se referă la fișier, nu la cererile trimise prin socket.

Când apare: Traefik și Portainer (citesc containerele), agenți de CI care construiesc imagini, unelte de monitorizare, Watchtower.

Alternative, după caz:

  • Doar citire a stării: un socket proxy (de exemplu tecnativa/docker-socket-proxy) care permite doar anumite endpoint-uri, cum ar fi listarea containerelor, și blochează crearea de containere sau exec.
  • Build de imagini în CI: BuildKit rootless, Buildah, Kaniko sau un builder remote, fără acces la daemonul host-ului. Docker-in-Docker cu --privileged este și el riscant, doar mută problema.
  • Daemon rootless: atacatorul ajunge la un utilizator neprivilegiat, nu la root.
  • Izolare: runner-e CI efemere, în mașini virtuale dedicate, care se distrug după fiecare job.
  • API-ul de la distanță: dacă e expus prin TCP, doar cu TLS mutual, niciodată pe 2375 fără autentificare.

Același raționament se aplică pentru utilizatorii adăugați în grupul docker pe host: apartenența la grup echivalează practic cu acces root. Accesul se acordă conștient și se documentează.

Ce urmărește intervievatorul: Se verifică înțelegerea unui vector de atac foarte răspândit. Mulți candidați cred că montarea doar pentru citire este suficientă.

Eroarea, în practică:permission denied ... Docker daemon socket

97 Senior

Aplicația merge local cu docker compose up, dar pe serverul de producție containerul pornește și nu răspunde pe port. Cum procedezi?

Răspuns scurt: Lucrezi din interior spre exterior: aplicația rulează și ascultă pe interfața corectă, portul e publicat pe adresa potrivită, nimic altceva nu ocupă portul, firewall-ul și proxy-ul lasă traficul să treacă. Compari apoi configurația efectivă de pe server cu cea locală.

Un plan pe care l-aș spune explicit:

1. Aplicația din container:

BASH
docker compose ps
docker compose logs --tail 100 api
docker compose exec api sh -c 'wget -qO- http://127.0.0.1:8000/health || curl -fsS http://127.0.0.1:8000/health'

Dacă nu răspunde nici din interior, problema e la aplicație: configurație, dependențe, migrări.

2. Interfața de ascultare: răspunde pe 127.0.0.1, dar nu pe IP-ul containerului? Aplicația ascultă doar pe loopback (o variabilă de mediu de producție poate schimba HOST).

3. Publicarea:

BASH
docker compose port api 8000
sudo ss -ltnp | grep 8000
curl -v http://127.0.0.1:8000/health    # de pe server

Fișierul de pe server poate fi diferit: un override lipsă, port legat de 127.0.0.1, alt port în .env.

4. Exteriorul: firewall-ul furnizorului de cloud, regulile proxy-ului din față (nginx, Traefik), certificatul TLS, DNS-ul care indică alt server.

5. Diferențele dintre medii: docker compose config local față de server, aceeași imagine (compari digesturile), aceeași arhitectură (amd64 sau arm64), variabilele de producție.

Pe parcurs notez ce am verificat, ca să pot raporta clar. După rezolvare, propun o verificare automată post-deploy pe endpoint-ul de sănătate, ca problema să fie prinsă înainte să o observe utilizatorii.

Ce urmărește intervievatorul: Intervievatorul urmărește o metodă de eliminare pe straturi. Greșeala tipică este să sari direct la firewall sau să reconstruiești imaginea fără date.

Eroarea, în practică:curl: (7) Failed to connect to localhost port 8080

98 Senior

Primești o alertă: discul serverului pe care rulează Docker este aproape plin. Ce faci imediat și ce schimbi ca să nu se repete?

Răspuns scurt: Afli ce ocupă spațiul cu docker system df -v și du: imagini vechi, cache de build, containere oprite, loguri fără rotație. Eliberezi sigur ce nu e folosit, fără să atingi volumele cu date, apoi configurezi rotația logurilor, curățenia programată și alertele.

Acțiuni imediate, de la cea mai sigură:

BASH
df -h
docker system df -v
sudo du -sh /var/lib/docker/* | sort -h
sudo find /var/lib/docker/containers -name '*-json.log' -size +500M -exec ls -lh {} \;
  • Loguri uriașe ale unui container: cauza cea mai frecventă. Pe termen scurt poți goli fișierul cu truncate -s 0 (nu rm, care nu eliberează spațiul cât timp fișierul e deschis), apoi configurezi rotația.
  • Cache de build pe mașinile de build: docker builder prune --filter until=72h.
  • Imagini vechi după multe deploy-uri: docker image prune -a --filter until=168h, dacă poți descărca din nou ce ai nevoie.
  • Containere oprite: docker container prune.
  • Volume orfane: le verifici unul câte unul înainte de ștergere; pot conține singura copie a unor date.
  • Stratul writable mare al unui container (docker ps -s): aplicația scrie fișiere în container, care trebuie mutate pe un volum.

Prevenire:

  • rotația logurilor în daemon.json, aplicată la recrearea containerelor;
  • un job programat de curățenie a imaginilor și a cache-ului, cu filtre de vârstă;
  • alerte pe ocuparea discului la un prag care lasă timp de reacție;
  • eventual /var/lib/docker pe un disc separat, ca un Docker plin să nu blocheze sistemul de operare.

Raportez apoi echipei cauza și schimbările, ca incidentul să nu se repete pe alte servere.

Ce urmărește intervievatorul: Situația verifică prioritizarea sigură sub presiune. Greșeala gravă este un docker system prune -a --volumes rulat în grabă.

Eroarea, în practică:no space left on device

99 Senior

Un coleg propune să rulați un container cu --privileged pentru că aplicația dă „operation not permitted”. Cum gestionezi discuția?

Răspuns scurt: Recunosc problema și urgența, dar propun să aflăm întâi ce operație anume e refuzată și să acordăm doar dreptul necesar: o capability, un dispozitiv sau o ajustare de configurație. --privileged rămâne ultima opțiune, documentată și aprobată, nu o scurtătură.

Structura răspunsului (situație, abordare, rezultat):

Înțeleg obiectivul: colegul vrea să deblocheze o funcționalitate, poate sub presiune de timp. Nu resping propunerea direct, ci o tratez ca pe o problemă de rezolvat împreună.

Explic riscul pe scurt și concret: --privileged dă containerului acces la toate dispozitivele host-ului și dezactivează seccomp și AppArmor. Dacă aplicația are o vulnerabilitate, atacatorul poate prelua serverul, nu doar containerul.

Investigăm împreună ce lipsește:

  • Ce comandă dă eroarea? De exemplu, ping cere NET_RAW, ascultarea pe portul 80 ca neprivilegiat cere NET_BIND_SERVICE, o unealtă de rețea cere NET_ADMIN, iar accesul la un dispozitiv USB cere --device.
  • Uneori nu e nevoie de niciun drept nou: aplicația poate asculta pe 8080, iar un sysctl poate fi setat per container cu --sysctl.
  • Testăm pe un mediu de test cu --cap-add minim și confirmăm că merge.

Rezultatul: configurația finală acordă doar dreptul necesar, documentat în Compose sau în manifeste, cu un comentariu despre motiv. Dacă rămâne un caz real pentru --privileged, de exemplu o unealtă de sistem, decizia se ia explicit, cu acordul celui responsabil de securitate, pe un host izolat.

Ce las în urmă: o notă în documentația echipei despre capabilities și cum diagnostichezi „operation not permitted”, ca data viitoare să nu mai fie nevoie de discuție.

Ce urmărește intervievatorul: Întrebarea comportamentală verifică echilibrul dintre livrare și securitate și felul în care colaborezi. Răspunsul slab este fie „accept”, fie un refuz fără alternativă.

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

100 Senior

Intri într-o echipă care rulează aplicațiile instalate manual pe servere. Ți se cere să introduci Docker. Cum planifici trecerea?

Răspuns scurt: Pornesc cu un serviciu cu risc mic, îl containerizez împreună cu echipa, încep cu mediul local și CI, apoi testarea, abia la final producția, cu plan de revenire. Stabilesc devreme standardele (imagini de bază, tag-uri, registry, loguri, secrete) și măsor beneficiile pe parcurs.

Un plan în etape:

1. Înțelegerea situației: ce aplicații există, cum se instalează azi, ce dependențe au, unde stau datele, cine face deploy și cât de des. Identific durerile reale: onboarding lent, diferențe între medii, deploy-uri manuale riscante.

2. Un pilot cu risc mic: un serviciu stateless, bine înțeles, fără date critice. Scriu Dockerfile-ul împreună cu cei care îl întrețin, ca să nu devină „cutia neagră a noului coleg”.

3. Dezvoltarea locală întâi: un compose.yaml cu aplicația și dependențele ei (baza de date, Redis). Câștigul se vede imediat la onboarding și nu atinge producția.

4. CI: build-ul imaginii, testele în container, scanarea și publicarea într-un registry, cu tag-uri legate de commit.

5. Standarde comune: imagini de bază aprobate, utilizator neprivilegiat, loguri pe stdout, configurație prin variabile, secrete în afara imaginii, limite de resurse, healthcheck. Le scriu într-un document scurt și într-un șablon de repository.

6. Producția, treptat: staging întâi, apoi producția pentru pilot, cu monitorizare și cu vechea instalare păstrată ca variantă de revenire o perioadă. Bazele de date rămân la început unde sunt.

7. Extinderea: serviciu cu serviciu, cu sesiuni scurte de învățare pentru echipă. Abia când sunt multe servicii și nevoi de disponibilitate discutăm despre un orchestrator.

Pe tot parcursul măsor ce s-a îmbunătățit (timpul de onboarding, durata deploy-ului, incidentele de configurație) și ajustez planul după feedback.

Ce urmărește intervievatorul: Se verifică abilitatea de a conduce o schimbare tehnică într-o echipă. Răspunsul slab propune migrarea a tot, direct pe Kubernetes, într-un singur pas.

Î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 Docker, de la junior la mid, iar pe JoburiIT.ro îți poți certifica apoi cunoștințele.

Învață Docker scriind cod, nu doar citind

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