0Pricing
Docker & DevOps Fundamentals · Lekcja

Wielostopniowe kompilacje zwiększające wydajność

Wykorzystuj wielostopniowe kompilacje do tworzenia mniejszych i bezpieczniejszych obrazów produkcyjnych przez oddzielenie zależności kompilacji od zależności środowiska uruchomieniowego.

Wielostopniowe kompilacje zwiększające wydajność to bezpłatna lekcja Docker & DevOps Fundamentals na CoddyKit. To lekcja 1 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Docker & DevOps Fundamentals, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Docker & DevOps Fundamentals zawiera 4 lekcji w sumie.

Wprowadzenie do kompilacji wieloetapowych

Witamy w zaawansowanej optymalizacji plików Dockerfile! Dzisiaj omówimy kompilacje wieloetapowe — zaawansowaną technikę tworzenia mniejszych i wydajniejszych obrazów Docker.

Mniejsze obrazy szybciej się pobierają, zapewniają większe bezpieczeństwo i pozwalają lepiej wykorzystywać zasoby.

Wielostopniowe kompilacje zwiększające wydajność — ilustracja 1

Dlaczego mniejsze obrazy mają znaczenie

Podczas budowania obrazu Docker często zawiera on narzędzia i zależności potrzebne tylko w procesie budowania, a nie podczas uruchamiania gotowej aplikacji.

  • Szybsze pobieranie: mniejsze obrazy pobierają się szybciej.
  • Mniej miejsca na dysku: oszczędność miejsca w rejestrach i na hostach.
  • Mniejsza powierzchnia ataku: mniejsza liczba komponentów oznacza mniej potencjalnych luk w zabezpieczeniach.
  • Większe bezpieczeństwo: obraz produkcyjny zawiera tylko niezbędne elementy.

Problem kompilacji jednoetapowej

Rozważmy skompilowaną aplikację, na przykład napisaną w Go. Tradycyjny, jednoetapowy plik Dockerfile zawierałby cały kompilator Go i zależności programistyczne w obrazie końcowym.

Sprawia to, że obraz końcowy jest znacznie większy, niż jest to konieczne, ponieważ kompilator nie jest potrzebny do uruchomienia skompilowanego pliku binarnego.

Przykład kompilacji jednoetapowej (Go)

Oto prosta aplikacja w Go i plik Dockerfile, który buduje ją w jednym etapie. Zwróć uwagę, że środowisko budowania jest uwzględnione w obrazie końcowym.

main.go:

package main

import "fmt"

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

Jednoetapowy plik Dockerfile

Ten plik Dockerfile używa `golang:1.21-alpine` jako obrazu bazowego. Po zbudowaniu aplikacji ten duży obraz bazowy wraz ze wszystkimi narzędziami budowania pozostaje w obrazie końcowym.

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

Budowa kompilacji wieloetapowych

Kompilacje wieloetapowe rozwiązują ten problem, umożliwiając zdefiniowanie wielu instrukcji `FROM` w jednym pliku Dockerfile. Każda instrukcja `FROM` rozpoczyna nowy etap budowania.

  • Użyj słowa kluczowego AS, aby nadać etapowi nazwę (np. FROM golang:1.21-alpine AS builder).
  • Następnie możesz skopiować artefakty z poprzedniego etapu za pomocą COPY --from=<stage_name>.

Jako obraz zapisywany jest tylko ostatni etap.

Struktura kompilacji wieloetapowej

Typowy wieloetapowy plik Dockerfile ma co najmniej dwa etapy:

  • Build Stage: zawiera wszystkie narzędzia i kod źródłowy potrzebne do skompilowania aplikacji.
  • Runtime Stage: minimalny obraz bazowy zawierający tylko skompilowaną aplikację i jej zależności uruchomieniowe.

Pośredni obraz etapu budowania jest odrzucany, dzięki czemu obraz końcowy jest mały.

Przykład kompilacji wieloetapowej (Go)

Przepiszmy plik Dockerfile naszej aplikacji w Go, korzystając z podejścia wieloetapowego. Zbudujemy aplikację w pierwszym etapie, a następnie skopiujemy tylko skompilowany plik binarny do znacznie mniejszego obrazu bazowego `alpine`.

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

Uruchamianie kompilacji wieloetapowej

Podczas budowania tego pliku Dockerfile Docker wykonuje każdy etap. Jednak tylko zawartość ostatniej instrukcji `FROM`, wraz z plikami skopiowanymi z poprzednich etapów, tworzy obraz końcowy.

Dzięki temu obraz jest znacznie mniejszy w porównaniu z kompilacją jednoetapową, ponieważ kompilator Go i narzędzia budowania pozostają poza nim.

Zalety kompilacji wieloetapowych

Kompilacje wieloetapowe są niezwykle przydatne w przypadku:

  • Języków kompilowanych: Go, Java, C++, Rust.
  • Frameworków frontendowych: budowania aplikacji React/Angular i serwowania zasobów statycznych za pomocą Nginx.
  • Aplikacji Node.js: instalowania `node_modules` w etapie budowania, a następnie kopiowania tylko plików `package.json`, `package-lock.json` i zbudowanej aplikacji do odchudzonego obrazu uruchomieniowego.

Sprawdź swoją wiedzę

Jakie są główne korzyści ze stosowania wieloetapowych kompilacji Docker?

Podsumowanie: efektywność kompilacji wieloetapowej

Nauczono się, czym są wieloetapowe kompilacje Docker!

  • Obejmują one wiele instrukcji FROM w jednym pliku Dockerfile.
  • Słowo kluczowe AS nadaje nazwy etapom, a COPY --from= przenosi artefakty.
  • Najważniejszą korzyścią są znacznie mniejsze, bezpieczniejsze i wydajniejsze obrazy końcowe.

Ta technika ma kluczowe znaczenie dla optymalizacji aplikacji uruchamianych w kontenerach. Następnie przyjrzymy się wykorzystaniu pamięci podręcznej kompilacji!

Często zadawane pytania

Czy lekcja „Wielostopniowe kompilacje zwiększające wydajność” jest bezpłatna?

Tak — pełny tekst „Wielostopniowe kompilacje zwiększające wydajność” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Docker & DevOps Fundamentals, przejdź na CoddyKit PRO. Kurs Docker & DevOps Fundamentals zawiera 4 lekcji w sumie.

Co nauczysz się w „Wielostopniowe kompilacje zwiększające wydajność”?

Wykorzystuj wielostopniowe kompilacje do tworzenia mniejszych i bezpieczniejszych obrazów produkcyjnych przez oddzielenie zależności kompilacji od zależności środowiska uruchomieniowego. Ćwiczysz Docker & DevOps Fundamentals z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Docker & DevOps Fundamentals?

Nie wymagamy żadnego doświadczenia. Docker & DevOps Fundamentals w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 4.

Ile czasu zajmuje lekcja „Wielostopniowe kompilacje zwiększające wydajność”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Docker & DevOps Fundamentals?

Tak. Każda lekcja Docker & DevOps Fundamentals zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Wielostopniowe kompilacje zwiększające wydajność
  2. Wykorzystanie pamięci podręcznej kompilacji
  3. Najlepsze praktyki bezpieczeństwa Dockerfile
  4. Minimalizowanie rozmiaru obrazu za pomocą baz Slim i Distroless
← Powrót do Docker & DevOps Fundamentals