docker build în Docker

Imagini Docker 23.0+ (BuildKit implicit)

Construiește o imagine pe baza unui Dockerfile și a unui context de build.

Sintaxă comandă
docker build [opțiuni] -t nume:etichetă context

Ce face docker build

Comanda docker build citește instrucțiunile dintr-un Dockerfile și produce o imagine nouă. Ultimul argument este contextul de build, de obicei . (directorul curent): toate fișierele din context sunt trimise către builder și pot fi copiate în imagine cu COPY.

Începând cu Docker 23.0, build-ul folosește implicit BuildKit, care rulează pașii în paralel, afișează progresul compact ([+] Building) și păstrează în cache fiecare instrucțiune. Dacă o instrucțiune și fișierele ei nu s-au schimbat, pasul este marcat CACHED și nu se mai execută.

Opțiunea -t dă un nume și o etichetă imaginii; fără ea, imaginea primește doar un ID și apare ca <none> în docker images.

Opțiuni și argumente

Opțiune / Parametru Descriere
-t, --tag nume:etichetă Numele imaginii rezultate. Poate fi repetat pentru mai multe etichete.
-f, --file cale Folosește alt Dockerfile decât ./Dockerfile, de exemplu -f docker/Dockerfile.prod.
--build-arg NUME=valoare Setează o variabilă definită cu ARG în Dockerfile.
--target etapă Într-un build multi-stage, se oprește la etapa cu numele indicat.
--no-cache Ignoră cache-ul și reconstruiește toți pașii.
--pull Descarcă întotdeauna cea mai nouă versiune a imaginii de bază.
--platform Construiește pentru altă platformă, de exemplu linux/amd64.
--progress plain Afișează ieșirea completă a fiecărui pas (util la depanare).

Exemple

Exemplul 1: Build simplu din directorul curent

Construim imaginea dexblog/api:2.3.1 folosind Dockerfile din directorul curent.

docker build -t dexblog/api:2.3.1 .

Ieșire în terminal

[+] Building 18.4s (10/10) FINISHED                              docker:default
 => [internal] load build definition from Dockerfile                       0.0s
 => => transferring dockerfile: 312B                                       0.0s
 => [internal] load metadata for docker.io/library/python:3.12-slim        1.1s
 => [internal] load .dockerignore                                          0.0s
 => => transferring context: 94B                                           0.0s
 => [1/5] FROM docker.io/library/python:3.12-slim@sha256:2b0079146a74e23b  0.0s
 => [internal] load build context                                          0.1s
 => => transferring context: 48.21kB                                       0.1s
 => CACHED [2/5] WORKDIR /app                                              0.0s
 => [3/5] COPY requirements.txt .                                          0.1s
 => [4/5] RUN pip install --no-cache-dir -r requirements.txt              15.9s
 => [5/5] COPY . .                                                         0.2s
 => exporting to image                                                     0.9s
 => => exporting layers                                                    0.8s
 => => writing image sha256:5c1f0a7e9b42d3c8e6f1a2b4c7d9e0f1a3b5c7d9e1f2  0.0s
 => => naming to docker.io/dexblog/api:2.3.1                               0.0s

Exemplul 2: Dockerfile alternativ, argumente și mai multe etichete

Folosim un Dockerfile de producție, transmitem un ARG și punem două etichete aceleiași imagini.

docker build \
  -f docker/Dockerfile.prod \
  --build-arg APP_VERSION=2.3.1 \
  -t dexblog/api:2.3.1 \
  -t dexblog/api:latest \
  .

Exemplul 3: Build fără cache, cu ieșire completă

Util când un pas RUN eșuează și vrei să vezi tot mesajul de eroare.

docker build --no-cache --progress plain -t test .

Greșeli frecvente

  • Uitarea punctului de la final (contextul): docker build -t app dă eroarea docker buildx build requires 1 argument.
  • Context de build uriaș (de exemplu cu node_modules sau .git) care încetinește fiecare build. Folosește un fișier .dockerignore.
  • Copierea întregului cod înainte de instalarea dependențelor, ceea ce invalidează cache-ul la fiecare modificare de cod. Copiază întâi fișierul de dependențe, rulează instalarea, apoi copiază restul.

Comenzi înrudite

  • Dockerfile: FROM și WORKDIR: Alege imaginea de bază a construcției și setează directorul curent de lucru în imagine.
  • .dockerignore: Exclude fișiere și directoare din contextul trimis la docker build, accelerând construcția și protejând secretele.
  • Dockerfile: Multi-stage builds: Construiește aplicația într-o etapă cu compilatoare și copiază doar rezultatul într-o imagine finală mică.
  • docker tag: Adaugă un nume nou (etichetă) unei imagini existente, fără a o copia.