0Pricing
DevOps Bootcamp · Lezione

Build multi-stage per l’efficienza

Utilizzi build multi-stage per creare immagini di produzione più piccole e sicure, separando le dipendenze di build e runtime.

Build multi-stage per l’efficienza è una lezione DevOps Bootcamp gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento DevOps Bootcamp, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso DevOps Bootcamp include 4 lezioni in totale.

Introduzione alle build multi-stage

Benvenuto all'ottimizzazione avanzata dei Dockerfile! Oggi esploreremo le multi-stage build, una tecnica potente per creare immagini Docker più piccole ed efficienti.

Le immagini più piccole consentono download più rapidi, maggiore sicurezza e un migliore utilizzo delle risorse.

Build multi-stage per l’efficienza — illustrazione 1

Perché le immagini più piccole sono importanti

Quando si crea un'immagine Docker, spesso include strumenti e dipendenze necessari solo durante il processo di build, ma non durante l'esecuzione finale dell'applicazione.

  • Pull più veloci: le immagini più piccole vengono scaricate più rapidamente.
  • Minore spazio su disco: si riduce lo spazio di archiviazione necessario nei registry e sugli host.
  • Superficie di attacco ridotta: un numero inferiore di componenti comporta meno potenziali vulnerabilità.
  • Maggiore sicurezza: l'immagine di produzione contiene solo ciò che è essenziale.

Il problema delle build a singolo stage

Consideri un'applicazione compilata, ad esempio una scritta in Go. Un Dockerfile tradizionale a singolo stage includerebbe nell'immagine finale l'intero compilatore Go e tutte le dipendenze di sviluppo.

Questo rende l'immagine finale molto più grande del necessario, poiché il compilatore non serve per eseguire il binario compilato.

Esempio di build a singolo stage (Go)

Ecco una semplice applicazione Go e un Dockerfile che la crea in un singolo stage. Noti che l'ambiente di build è incluso nell'immagine finale.

main.go:

package main

import "fmt"

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

Dockerfile a singolo stage

Questo Dockerfile utilizza `golang:1.21-alpine` come base. Dopo la creazione dell'applicazione, questa grande immagine di base, insieme a tutti gli strumenti di build, rimane nell'immagine finale.

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

Anatomia delle build multi-stage

Le build multi-stage risolvono questo problema consentendo di definire più istruzioni `FROM` in un singolo Dockerfile. Ogni `FROM` avvia un nuovo stage di build.

  • Utilizzare la parola chiave AS per assegnare un nome a uno stage, ad esempio FROM golang:1.21-alpine AS builder.
  • È quindi possibile copiare gli artifact da uno stage precedente utilizzando COPY --from=<stage_name>.

Solo lo stage finale viene salvato come immagine.

Struttura multi-stage

Un Dockerfile multi-stage tipico comprende almeno due stage:

  • Build Stage: contiene tutti gli strumenti e il codice sorgente necessari per compilare l'applicazione.
  • Runtime Stage: un'immagine di base minimale che include solo l'applicazione compilata e le relative dipendenze di runtime.

L'immagine intermedia dello stage di build viene eliminata, lasciando un'immagine finale leggera.

Esempio di build multi-stage (Go)

Riscriviamo il Dockerfile della nostra applicazione Go utilizzando un approccio multi-stage. Creeremo l'applicazione nel primo stage e copieremo quindi solo il binario compilato in un'immagine di base `alpine` molto più piccola.

# 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"]

Esecuzione di una build multi-stage

Quando si crea questo Dockerfile, Docker esegue ogni stage. Tuttavia, solo il contenuto dell'ultima istruzione `FROM`, insieme ai file copiati dagli stage precedenti, costituisce l'immagine finale.

Il risultato è un'immagine significativamente più piccola rispetto a una build a singolo stage, perché il compilatore Go e gli strumenti di build vengono esclusi.

Vantaggi delle build multi-stage

Le build multi-stage sono estremamente utili per:

  • Linguaggi compilati: Go, Java, C++, Rust.
  • Framework frontend: creare applicazioni React/Angular e distribuire asset statici con Nginx.
  • Applicazioni Node.js: installare `node_modules` in uno stage di build, quindi copiare solo `package.json`, `package-lock.json` e l'applicazione creata in un'immagine di runtime minimale.

Verifica delle conoscenze

Quali dei seguenti sono i principali vantaggi dell'utilizzo delle build Docker multi-stage?

Riepilogo: efficienza multi-stage

Ha imparato a utilizzare le build Docker multi-stage.

  • Prevedono più istruzioni FROM in un singolo Dockerfile.
  • La parola chiave AS assegna un nome agli stage e COPY --from= trasferisce gli artifact.
  • Il vantaggio principale consiste in immagini finali molto più piccole, sicure ed efficienti.

Questa tecnica è fondamentale per ottimizzare le applicazioni containerizzate. Ora vedremo come sfruttare la cache delle build.

Domande Frequenti

La lezione «Build multi-stage per l’efficienza» è gratuita?

Sì — il testo completo di «Build multi-stage per l’efficienza» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso DevOps Bootcamp, passa a CoddyKit PRO. Il corso DevOps Bootcamp include 4 lezioni in totale.

Cosa imparerò in «Build multi-stage per l’efficienza»?

Utilizzi build multi-stage per creare immagini di produzione più piccole e sicure, separando le dipendenze di build e runtime. Eserciti DevOps Bootcamp con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare DevOps Bootcamp?

Non è richiesta alcuna esperienza precedente. DevOps Bootcamp su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.

Quanto tempo richiede la lezione «Build multi-stage per l’efficienza»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione DevOps Bootcamp?

Sì. Ogni lezione DevOps Bootcamp include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Build multi-stage per l’efficienza
  2. Utilizzo della cache di build
  3. Best practice di sicurezza per i Dockerfile
  4. Riduzione delle immagini con basi Slim e Distroless
← Torna a DevOps Bootcamp