PricingLoginStart free
Grunderna i Docker och DevOps · Lektion

Flerstegsbyggen för effektivitet

Använd flerstegsbyggen för att skapa mindre och säkrare produktionsimages genom att separera bygg- och körningsberoenden.

Lektion 1 av 412 steg

Flerstegsbyggen för effektivitet är en gratis lektion i Grunderna i Docker och DevOps på CoddyKit. Detta är lektion 1 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Grunderna i Docker och DevOps, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Grunderna i Docker och DevOps innehåller totalt 4 lektioner.

Introduktion till byggen i flera steg

Välkommen till avancerad optimering av Dockerfile! I dag utforskar vi byggen i flera steg, en kraftfull teknik för att skapa mindre och effektivare Docker-avbildningar.

Mindre avbildningar leder till snabbare nedladdningar, förbättrad säkerhet och bättre resursutnyttjande.

Flerstegsbyggen för effektivitet — illustration 1

Varför mindre avbildningar är viktiga

När Ni bygger en Docker-avbildning innehåller den ofta verktyg och beroenden som bara behövs under byggprocessen, inte när den färdiga applikationen körs.

  • Snabbare hämtning: Mindre avbildningar laddas ned snabbare.
  • Mindre diskutrymme: Sparar lagringsutrymme i register och på värdar.
  • Mindre attackyta: Färre komponenter innebär färre potentiella sårbarheter.
  • Förbättrad säkerhet: Produktionsavbildningen innehåller endast det som behövs.

Problemet med ett steg

Föreställ Er en kompilerad applikation, till exempel en som är skriven i Go. En traditionell Dockerfile med ett enda steg skulle inkludera hela Go-kompilatorn och alla utvecklingsberoenden i den färdiga avbildningen.

Det gör den färdiga avbildningen mycket större än nödvändigt, eftersom kompilatorn inte behövs för att köra den kompilerade binärfilen.

Exempel med ett steg (Go)

Här är en enkel Go-applikation och en Dockerfile som bygger den i ett enda steg. Observera att byggmiljön inkluderas i den färdiga avbildningen.

main.go:

package main

import "fmt"

func main() {
    fmt.Println("Hello from Single-Stage Docker!")
}

Dockerfile med ett steg

Den här Dockerfile använder `golang:1.21-alpine` som bas. När applikationen har byggts finns den stora basavbildningen, tillsammans med alla byggverktyg, kvar i den färdiga avbildningen.

FROM golang:1.21-alpine
WORKDIR /app
COPY main.go .
RUN go build -o myapp main.go
EXPOSE 8080
CMD ["./myapp"]

Byggen i flera steg – uppbyggnad

Byggen i flera steg löser detta genom att Ni kan definiera flera `FROM`-instruktioner i en enda Dockerfile. Varje `FROM` startar ett nytt byggsteg.

  • Använd nyckelordet AS för att namnge ett steg (till exempel FROM golang:1.21-alpine AS builder).
  • Därefter kan Ni kopiera artefakter från ett tidigare steg med hjälp av COPY --from=<stage_name>.

Endast det sista steget sparas som avbildning.

Struktur för byggen i flera steg

En typisk Dockerfile med flera steg har minst två steg:

  • Byggsteg: Innehåller alla verktyg och all källkod som behövs för att kompilera applikationen.
  • Körningssteg: En minimal basavbildning som endast innehåller den kompilerade applikationen och dess körningsberoenden.

Byggstegets mellanliggande avbildning tas bort, vilket lämnar en slimmad slutavbildning.

Exempel på bygge i flera steg (Go)

Vi skriver om Dockerfile för vår Go-applikation med en metod i flera steg. Vi bygger applikationen i det första steget och kopierar sedan endast den kompilerade binärfilen till en mycket mindre `alpine`-basavbildning.

# Stage 1: Build the application
FROM golang:1.21-alpine AS builder
WORKDIR /app
COPY main.go .
RUN go build -o myapp main.go

# Stage 2: Create the final lightweight image
FROM alpine:latest
WORKDIR /app
COPY --from=builder /app/myapp .
EXPOSE 8080
CMD ["./myapp"]

Köra ett bygge i flera steg

När Ni bygger denna Dockerfile kör Docker varje steg. Den slutliga avbildningen består dock endast av innehållet i den sista `FROM`-instruktionen, tillsammans med filer som kopierats från tidigare steg.

Detta ger en betydligt mindre avbildning jämfört med ett bygge i ett enda steg, eftersom Go-kompilatorn och byggverktygen lämnas kvar.

Fördelar med byggen i flera steg

Byggen i flera steg är mycket användbara för:

  • Kompilerade språk: Go, Java, C++ och Rust.
  • Frontend-ramverk: Bygga React-/Angular-appar och leverera statiska resurser med Nginx.
  • Node.js-applikationer: Installera `node_modules` i ett byggsteg och sedan kopiera endast `package.json`, `package-lock.json` och den byggda applikationen till en slimmad körningsavbildning.

Kontrollera Era kunskaper

Vilka av följande är de främsta fördelarna med att använda Docker-byggen i flera steg?

Besvara frågan i den interaktiva lektionen

Sammanfattning: effektivitet med flera steg

Ni har lärt Er om Docker-byggen i flera steg!

  • De använder flera FROM-instruktioner i en enda Dockerfile.
  • Nyckelordet AS namnger steg, och COPY --from= överför artefakter.
  • Den viktigaste fördelen är betydligt mindre, säkrare och effektivare slutavbildningar.

Den här tekniken är avgörande för att optimera Era containeriserade applikationer. Därefter tittar vi på hur byggcache kan utnyttjas!

Gratis att börja

Lär dig Grunderna i Docker och DevOps med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser
12
Lektioner
48
Börja lära dig gratisVisa hela kursen

Vanliga frågor

Är lektionen ”Flerstegsbyggen för effektivitet” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Grunderna i Docker och DevOps, inklusive ”Flerstegsbyggen för effektivitet”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Grunderna i Docker och DevOps innehåller totalt 4 lektioner.

Vad lär jag mig i ”Flerstegsbyggen för effektivitet”?

Använd flerstegsbyggen för att skapa mindre och säkrare produktionsimages genom att separera bygg- och körningsberoenden. Ni övar på Grunderna i Docker och DevOps med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Grunderna i Docker och DevOps?

Du behöver inga förkunskaper. Utbildningen i Grunderna i Docker och DevOps på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.

Hur lång tid tar lektionen ”Flerstegsbyggen för effektivitet”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Grunderna i Docker och DevOps-lektionen?

Ja. Varje Grunderna i Docker och DevOps-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

  1. Flerstegsbyggen för effektivitet
  2. Utnyttja byggcachning
  3. Bästa praxis för Dockerfile-säkerhet
  4. Minimera avbildningsstorleken med Slim- och Distroless-baser
← Tillbaka till Grunderna i Docker och DevOps