Ano ba ang Multi-Stage Docker na Nagtatayo?

Ang Multi-stage Docker na mga gusali ay isang tampok na ipinakilala sa Docker 17.05 na nagpapahintulot sa iyo na gumamit ng maramihang mga pangungusap sa loob ng isang Dockerfile. Ang bawat instruksiyon ay nagsisimula ng isang bagong yugto, na maaaring magkaroon ng sarili nitong batayang larawan, dependensiya, at utos. Ang mga artefact ay maaaring mapiling kopyahin mula sa isang yugto tungo sa isa pang yugto, samantalang ang pangwakas na larawan ay nagpapanatili lamang ng kung ano ang mahigpit na kailangan para sa aplikasyon.Ang pamamaraang ito ay nag-aalis sa manufaclectylylyly Doilerfile o pagbabawas ng mga files sa mga staceps, at gumagawa ng mga enclecleclecleclecleclecations, at gumagawa ng mga composure na mga composure na mga process.

Ang pinaka-ugat na ideya ay ang paghihiwalay ng kapaligiran ng gusali mula sa kapaligiran ng runtime. Sa isang karaniwang isahang-stage na gusali, ang isang developer ay nag-install ng lahat ng mga kasangkapan (e.g., ang mga taga-ipon, manedyer ng pakete, mga balangkas ng pagsubok) sa parehong imahe na gagamitin para sa produksiyon. na nag-iinhinyero ng imahe at nagdadagdag ng ibabaw ng pag-atake. Multi-stage buildings ito ay nakalutas sa pamamagitan ng paggamit ng isang makapal, tampok na larawan ng berchardythye na imahe para sa pag-igaya at pagkatapos ay ang resulta lamang sa isang maliit na runtime na imahe tulad ng[T:2] oF.

Mga Pakinabang ng Multi-Stage na mga Pagtatayo

Ang mga kapakinabangan ng pag-aampon ng mga paggawa ng multi-stage ay higit pa sa payak na pagbabawas ng sukat. ang mga ito ay may malaking epekto sa seguridad, pagpapanatili, at bilis ng pag-aapruba.

1. Binabawasan ang Image Size

Sa pagtatapon ng mga dependensiya ng mga gusaling pang-time, ang mga gusaling multi-stage ay kadalasang nagpapaliit ng mga imahe ng 50% hanggang 90%. Halimbawa, ang isang aplikasyong Node.js na itinayo gamit ang buo na imahe (mahigit sa 300MB) ay maaaring lumiit hanggang sa ilalim ng 20MB sa pamamagitan ng pagkopya lamang ng itinayong folder sa isang base. Ang imbakang ito ay direktang nagsasalin sa mas mabilis na panahon, mas kaunting network bandwid, mas mababang halaga at j.

2. Pinahusay na Katiwasayan

Ang bawat naka-install na pakete o kasangkapan sa isang imahe ng lalagyan ay potensiyal na madededeable. Ang mga Multi-stage na mga paggawa ay nagpapahintulot sa iyo na ipuwera ang mga tagatipon, debugger, at development na mga aklatan mula sa huling imahe, na malaking binabawasan ang ibabaw ng pag-atake. Maaari ka pa ngang gumamit ng mga imahe tulad ng o para sa yugto ng pagtakbo, na na naglalaman lamang ng maikling pag-a-atake upang isagawa ang binary.

3. Proseso ng Itinayong mga Bakyum

Ang lahat ng mga hakbang ng pagtatayo ay binibigyang kahulugan sa isang solong Dockerfile, na ginagawang self-contained at madaling bersyon. ang mga tubo ng CI/CD ay nakikinabang mula sa isang nag-iisang entry point: ang Dockerfile. hindi kailangang panatilihin ang mga hiwalay na paggawa ng mga script o mga manufacturing lescation.

4. Enhanced Reproducty and Consistance

Dahil ang buong gusali ay na-create sa isang Dockerfile, ang anumang developer o sistema ay maaaring mag-reproduce ng parehong layer. Ang paggamit ng mga espesipikong mga tag ng bersyon para sa mga base imahe ay karagdagang gumagarantiya ng hindi nagbabagong mga istraktura sa ibayo ng mga kapaligiran.

Paggawa ng Multi-Stage Dockerfile: Hakbang por Hakbang

Ang paglalakad na ito ay sumasaklaw sa paglikha ng isang produksiyon na ang Production na may - kakayahang multi - calcern Dockerfile ay para sa isang Node.js at reaksyonal na pagkakapit.

Planuhin ang Iyong mga Kampaneran

Bago magsulat ng code, iplano ang mga yugtong kailangan mo, na may dalawang yugto:

  • – i-install ang lahat ng mga kasangkapan sa pagtatayo, i-install ang dependencies, at patakbuhin ang utos ng pagtatayo.
  • [Runtime stage – gumamit ng maliit na baseng imahe, kopya lamang ng mga itinayong artipakto mula sa yugto ng tagapagtayo, at nagbibigay ng kahulugan sa runtime na pag-uugali.

Para sa masalimuot na mga proyekto, maaari kang magdagdag ng panggitnang mga yugto para sa mga pagsubok, static analysis, o asset compression.

2. Isulat ang Bagsang Tagapagtayo

Magsimula sa isang baseng imahen na kinabibilangan ng kinakailangang kagamitang pang-agham. Gamitin Mga yugtong pang-pangalan na may upang tukuyin ang mga ito sa kalaunan.[Pangunahin::

FROM node:14-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production
COPY . .
RUN npm run build

Mga susing punto:

  • Gamitin para sa deterministiko, mas mabilis na pag-install ng dependency.
  • Ilagay ang mga utos bilang hiwalay na mga patong kung maaari upang mag-paverage caching.
  • Ikabit ang mga kasangkapan sa pagtatayo (katulad ng TypeScript, webpack) sa yugtong ito lamang.

3. Magdagdag ng Indibidwal na Pagsubok (Optional)

Upang ipatupad ang katangiang kodigo, magdagdag ng yugto na nagpapatakbo ng mga pagsubok. Ang yugtong ito ay maaaring muling gamitin ang imaheng tagapagtayo o magluklok ng karagdagang mga kasangkapan. dahil hindi ito ang huling yugto, ang mga kabiguan sa pagsubok ay hindi na makikita sa huling larawan.

FROM builder AS test
RUN npm run test

Maaari mong patakbuhin ang yugtong ito sa iyong CI pipeline na may upang maabutan ng mga kabiguan nang maaga nang hindi itinatayo ang buong pangwakas na larawan.

4. Ipaliwanag ang Oras ng Pagtakbo

Para sa isang aplikasyong pang-reaksyon, ang runtime image ay maaaring maging isang Nginx server. Para sa isang backend API, ito ay maaaring isang walang-hanggan na baseng imahe o isang minimal na Alpine na kasama ang Node.js runtime. kopyahin lamang ang mga mahahalagang artifact gamit ang .

FROM nginx:alpine
COPY --from=builder /app/build /usr/share/nginx/html
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

Kung kailangan mo ang Node.js runtime, iwasan ang pagkopya mula sa tagapagtayo; sa halip ay maglagay muli ng mga dependensiya sa produksiyon sa runtime stage:

FROM node:14-alpine AS runtime
WORKDIR /app
COPY --from=builder /app/dist ./dist
RUN npm ci --only=production
EXPOSE 3000
CMD ["node", "dist/server.js"]

5. Itayo at Subukin ang Larawan

Gumawa ng huling larawan gamit ang pamantayang utos:

docker build -t myapp:latest .

Upang matiyak ang laki, patakbuhin at ihambing sa isang gusaling may entablado.

docker run -d -p 8080:80 myapp:latest
curl http://localhost:8080

Pinakamabuting Gawain Para sa mga Gusaling Multi-Stage

  • Use espesipikong mga baseng tag ng imahe – iwasan upang maiwasan ang mga sorpresa.[Pangunahin:23] o .
  • ] Optimize layer caching – copy at bago ang natitirang kodigo ng pinagmulan upang ang patong ay ma-sintili lamang kapag nagbago ang dependensiya.
  • Leverage contructKit – ay nagpapangyari sa BuildKit na may para sa mas mabilis na pagtatayo, inline caching, at mas mahusay na parallelism.
  • [[C] [[magkaraming mga huling yugto para sa iba't ibang mga kapaligiran – halimbawa, isang yugto ng pagpapaunlad na may mga debung kasangkapan at isang yugto ng produksiyon na may matigas na larawang base.
  • Use para sa mga pagpapatayo ng mga gusali – sa pag-unlad maaari kang huminto sa yugtong upang makakuha ng live reload at source maps, pagkatapos ay muling binuo gamit ang para sa produksiyon.
  • Itago ang mga lihim sa mga imahen – gamitin ang Docker BuildKitiviers flag kung kailangan mong magpasa ng mga kredensiyal sa panahon ng pagtatayo; huwag na huwag na huwag isama ang mga ito sa huling larawan.

Karaniwang mga Halimbawa at Paggamit ng mga Kaso

Mga Wikang Pinag - aralan (Go, Rust, C++)

Para sa mga static binaries, ang runtime stage ay maaaring gumamit (walang batayang imahe). lamang ang binary at marahil isang configuration file ang kinopya. Halimbawa para sa Go:

FROM golang:1.20-alpine AS builder
WORKDIR /app
COPY go.mod go.sum ./
RUN go mod download
COPY . .
RUN CGO_ENABLED=0 go build -o myapp .

FROM scratch
COPY --from=builder /app/myapp /myapp
ENTRYPOINT ["/myapp"]

Mga Aksiyon ng Python

Gumamit ng isang yugto ng pagtatayo na may upang maglagay ng dependencies at tipunin ang anumang karugtong ng C, pagkatapos ay kopyahin lamang ang naluklok na mga pakete sa isang runtime stage:

FROM python:3.11-slim AS builder
WORKDIR /app
COPY requirements.txt .
RUN pip install --user -r requirements.txt
COPY . .

FROM python:3.11-slim
COPY --from=builder /root/.local /root/.local
COPY --from=builder /app /app
ENV PATH=/root/.local/bin:$PATH
CMD ["python", "app.py"]

Harapan ng API Server

Magtayo ng parehong frontend at backend sa isang Dockerfile. Gamitin ang magkahiwalay na mga yugto ng pagtatayo para sa bawat isa, pagkatapos ay kopyahin ang dalawang artifact sa iisang runtime na imahe:

FROM node:14-alpine AS frontend-builder
WORKDIR /app
COPY frontend/package*.json ./
RUN npm ci
COPY frontend/ .
RUN npm run build

FROM node:14-alpine AS api-builder
WORKDIR /app
COPY api/package*.json ./
RUN npm ci
COPY api/ .
RUN npm run build

FROM node:14-alpine
WORKDIR /app
COPY --from=frontend-builder /app/build ./public
COPY --from=api-builder /app/dist ./dist
RUN npm ci --only=production
EXPOSE 3000
CMD ["node", "dist/server.js"]

Mga Gusaling Nagsasabog ng Multi-Stage

  • [Layer caching hindi gumagana – Tiyakin [kailangan ng sanggunian] bago ang source code. Gamitin upang ipuwera ang hindi kinakailangang mga files.
  • [Hindi natagpuan ang – tiyakin ang mga landas sa pangungusap . Ang yugto ng pagtatayo ay dapat na maglabas ng output sa itinakdang lokasyon. Gamitin ang upang i-debug.
  • [[Secret discedung – huwag kailanman kopyahin ang buong mga direktoryo na maaaring maglaman ng o . Explicitly copyly requiredlylylylyly finds.
  • [Large final imahe sa kabila ng multi-stage[ – suriin kung ikaw ay hindi sinasadyang kumokopya o ang buong pinagmulan. Gamitin ang upang makita ang mga sukat ng patong.

Pagsasaayos

Ang Multi-stage Docker ay gumagawa ng isang batong - panulok ng modernong lalagyan. Kanilang pinangyayari ka na ang mga larawan ay nakasandig, matatag na mga larawan samantalang pinananatiling simple at dokumentado ang proseso ng pagtatayo sa isang Dockerfile. Sa pamamagitan ng paghihiwalay ng mga pagkabahala sa pagitan ng pagtatayo at pagtakbo, maaari mong lubhang bawasan ang sukat ng larawan, pagbutihin ang seguridad, at ang mga gamit sa unahan ng CI/CD. Ang mga pamamaraan na ipinakikita rito ay kumakapit sa halos anumang salansan na kesacan kung ikaw ay nagtatayo ng Node.js, Go, Python, Java, o mga aplikasyon sa pamamagitan ng commission. Ang iyong umiiral na Dockerfile, at ang iyong mga gastos sa bilis ng paggawa, at pagbuo ng mga pamamaraan ay agad - aksiyon, at paggawa ng mga kagamitan sa bilis.

Para sa higit pang detalye, tumutukoy sa Opisyal na Docker multi-stage na paggawa ng dokumentasyon at ang Dockerfile pinakamagagaling na mga gawain.[Ang mga tunay na halimbawang pang-ekonomiya ay makukuha rin sa Docker Library docunder Expement[.