Dockerfile-generator

Dockerfile
Resultat

En Dockerfile är en av de filer som ser korta ut tills du minns detaljerna: lagrets ordning spelar roll för cachen, COPY package.json kommer före RUN npm install, och kompilerade språk tjänar på ett multi-stage-bygge. Den här generatorn skriver en färdig Dockerfile för din valda stack, med ett redan korrekt cachemönster.

Så genererar du en Dockerfile

  1. 1

    Välj stack

    Node.js, Python, PHP, Go eller Rust. Varje mall använder en lämplig basbild för språket och rätt kommando för att installera beroenden.

  2. 2

    Ställ in arbetskatalog och port

    Välj WORKDIR och den port din app lyssnar på; båda skrivs in i den genererade filen.

  3. 3

    Granska Dockerfilen

    Kontrollera att EXPOSE-raden och startkommandot stämmer med din app. Go- och Rust-mallarna använder ett multi-stage-bygge.

  4. 4

    Kopiera Dockerfilen

    Kopiera resultatet och klistra in det i rotmappen för ditt repo, bygg sedan bilden.

Varför multi-stage-byggen

En naiv Dockerfile installerar hela kompilatorverktygskedjan i slutbilden. Multi-stage-byggen ger dig ett “builder”-steg som kompilerar och ett slutsteg som bara innehåller den kompilerade artefakten:

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

FROM node:20-alpine
WORKDIR /app
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/node_modules ./node_modules
USER node
EXPOSE 3000
CMD ["node", "dist/index.js"]

Slutbilden släpper alla utvecklingsberoenden, källfiler och byggcache, vilket ofta minskar bildstorleken med 60-80 procent.

Varianter av basbild

Mallarna använder slim- eller alpinebilder där det är möjligt. Om du justerar basbilden själv är dessa de typiska alternativen:

Variant Typisk storlek När du väljer den
full 300-900 MB Utvecklingsbilder, ovanliga systemberoenden
slim 80-200 MB Produktionsstandard för de flesta språk
alpine 30-100 MB Små bilder, se upp med glibc-vs-musl-problem
distroless 20-80 MB Maximal säkerhet; inget skal, ingen pakethanterare

Regler för lager-cachning

Docker cachar varje rad; när ett lager ändras byggs allt nedanför om. Ordning från minst till mest föränderligt:

  1. Basbilden FROM (ändras sällan).
  2. Systempaket (apt-get install), sällsynta ändringar.
  3. Beroendemanifest (package.json, requirements.txt, composer.json).
  4. Installationssteget för beroenden. Körs bara när manifestet ändras.
  5. Kopiering av källkod. Det mest aktiva lagret; allt efter det byggs om vid varje commit.
  6. Kompilering och slutligt CMD.

Att bryta den här ordningen är den vanligaste orsaken till långsamma CI-byggen.

Säkerhetschecklista

  • Kör som icke-root. Sätt USER appuser (eller USER 1000) mot slutet.
  • Lås versioner. python:3.12.7-slim slår python:3.12 som slår python:latest.
  • Sätt ett tydligt WORKDIR i stället för att förlita dig på /.
  • Använd COPY, inte ADD för lokala filer; ADD har bieffekter med automatisk uppackning.
  • Lägg till en HEALTHCHECK så orkestrerare kan upptäcka en fastkörd process.
  • Rensa paketcachar på samma RUN-rad: apt-get install ... && rm -rf /var/lib/apt/lists/*.

Vanliga frågor

Slim är en säkrare standard eftersom den fortfarande bygger på glibc, precis som de flesta förkompilerade hjul från bibliotek. Alpine använder musl och orsakar ibland mystiska körtidsfel i Python (pandas, numpy) eller Node (node-gyp-native moduler). Välj alpine när bildstorleken är kritisk och du har testat stacken.

Ja, lägg till en i ditt projekt. Utan den skickar Docker hela ditt repo till daemonen som byggkontext: githistorik, node_modules, lokala .env-filer, tester. Det är långsamt, slösar cache och läcker hemligheter.

Ja. Använd docker buildx med flaggan --platform för att bygga för båda arkitekturerna samtidigt. De basbilder som mallarna använder publicerar arm64-varianter.

Nej. Val av stack, arbetskatalog och port används bara för att generera Dockerfilen på den här sidan; ingenting sparas eller delas.

Relaterade verktyg

Verktyget finns på andra språk