0Pricing
DevOps Bootcamp · Lekcja

Tworzenie niestandardowych obrazów Docker

Zbuduj swój pierwszy niestandardowy obraz Docker dla prostej aplikacji oraz prawidłowo go otaguj i wersjonuj.

Tworzenie niestandardowych obrazów Docker to bezpłatna lekcja DevOps Bootcamp na CoddyKit. To lekcja 2 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 DevOps Bootcamp, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs DevOps Bootcamp zawiera 4 lekcji w sumie.

Zbuduj swój pierwszy obraz Dockera

Dlaczego warto budować własne obrazy? Pozwalają one spakować konkretną aplikację, jej zależności i konfigurację w jedną przenośną jednostkę. Jest to kluczowe dla spójności i łatwego wdrażania.

Sposób budowania takiego obrazu definiuje się w pliku o nazwie Dockerfile.

Tworzenie niestandardowych obrazów Docker — ilustracja 1

Nasza prosta aplikacja internetowa

Skonteneryzujemy bardzo prostą aplikację internetową we Flasku dla języka Python. Po odwiedzeniu jej adresu internetowego zwraca ona tekst "Hello from Docker!".

Wyobraźmy sobie, że w katalogu znajdują się następujące pliki:

  • app.py: kod aplikacji w języku Python
  • requirements.txt: lista zależności języka Python
  • Dockerfile: instrukcje budowania obrazu

Kod aplikacji Flask

To nasza podstawowa aplikacja Python Flask. Nasłuchuje na porcie 5000 i odpowiada komunikatem „Hello from Docker!”.

Mogą ją Państwo uruchomić lokalnie (po zainstalowaniu Flask), aby zobaczyć ją w działaniu!

from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello():
    return 'Hello from Docker!'

if __name__ == '__main__':
    app.run(debug=True, host='0.0.0.0')

Określanie zależności

Nasza aplikacja potrzebuje biblioteki Flask. Wymieniamy ją w pliku requirements.txt. Ten plik informuje Docker (oraz menedżera pakietów Pythona, pip), co należy zainstalować.

Dzięki temu nasz obraz zawiera wszystkie biblioteki niezbędne do uruchomienia aplikacji.

Flask==2.3.2

Budowa naszego pliku Dockerfile

Dockerfile to plik tekstowy zawierający instrukcje potrzebne do zbudowania obrazu. Każda instrukcja tworzy warstwę. Oto instrukcje, których użyjemy:

  • FROM: określa obraz bazowy (np. Python).
  • WORKDIR: ustawia katalog roboczy wewnątrz kontenera.
  • COPY: kopiuje pliki z lokalnego komputera do obrazu.
  • RUN: wykonuje polecenia (np. instaluje zależności).
  • EXPOSE: informuje Docker o portach, na których nasłuchuje kontener.
  • CMD: definiuje domyślne polecenie uruchamiane po starcie kontenera.

Tworzenie pliku Dockerfile

Oto kompletny plik Dockerfile dla naszej aplikacji Flask. Umieść ten plik w tym samym katalogu co app.py i requirements.txt.

# Use an official Python runtime as a parent image
FROM python:3.9-slim-buster

# Set the working directory in the container
WORKDIR /app

# Copy the current directory contents into the container at /app
COPY requirements.txt .
COPY app.py .

# Install any needed packages specified in requirements.txt
RUN pip install --no-cache-dir -r requirements.txt

# Make port 5000 available to the world outside this container
EXPOSE 5000

# Run app.py when the container launches
CMD ["python", "app.py"]

Polecenie `docker build`

Teraz zbudujmy nasz obraz! Otwórz terminal w katalogu, w którym znajdują się plik Dockerfile oraz pliki aplikacji.

Flaga -t przypisuje obrazowi nazwę (my-flask-app) i wersję (1.0). Znak . informuje Docker, aby użyć bieżącego katalogu jako kontekstu kompilacji.

docker build -t my-flask-app:1.0 .

Weryfikowanie nowego obrazu

Po zakończeniu kompilacji można sprawdzić, czy nowy obraz istnieje, wyświetlając listę wszystkich lokalnych obrazów Docker.

W wynikach znajdź my-flask-app z tagiem 1.0.

docker images

Uruchamianie kontenera aplikacji

Czas zobaczyć aplikację w działaniu! Użyj polecenia docker run, aby utworzyć i uruchomić kontener na podstawie obrazu.

Parametr -p 5000:5000 mapuje port 5000 komputera hosta na port 5000 wewnątrz kontenera. Parametr -d uruchamia kontener w trybie odłączonym (w tle).

docker run -d -p 5000:5000 my-flask-app:1.0

Otwórz w przeglądarce adres http://localhost:5000, aby zobaczyć komunikat „Hello from Docker!”.

Dobre praktyki tagowania obrazów

Tagi mają kluczowe znaczenie podczas zarządzania różnymi wersjami obrazów. Powszechną praktyką jest stosowanie wersjonowania semantycznego (np. 1.0.0, 2.1.5) oraz tagu latest.

Można dodać wiele tagów do obrazu za pomocą polecenia docker tag:

docker tag my-flask-app:1.0 my-flask-app:latest

Dzięki temu można odwoływać się do tego samego obrazu za pomocą różnych nazw, co zwiększa elastyczność wdrażania.

Szybki test

Rozważ następujący plik Dockerfile i polecenie kompilacji:

# Dockerfile content
FROM alpine:latest
WORKDIR /app
COPY . .
CMD ["echo", "Hello"]

docker build -t my-app:v1 .

Które z poniższych stwierdzeń dotyczących polecenia docker build -t my-app:v1 . jest PRAWDZIWE?

Podsumowanie: niestandardowe obrazy

Świetnie! Dowiedziałeś się, jak:

  • przygotować prostą aplikację do konteneryzacji;
  • napisać podstawowy plik Dockerfile z użyciem kluczowych instrukcji (FROM, WORKDIR, COPY, RUN, EXPOSE, CMD);
  • zbudować niestandardowy obraz Docker za pomocą docker build -t;
  • zweryfikować obraz poleceniem docker images;
  • uruchomić kontener na podstawie niestandardowego obrazu za pomocą docker run -p;
  • zrozumieć znaczenie tagowania i wersjonowania obrazów.

W następnej części dokładniej przyjrzymy się strukturze obrazów Docker, warstwom oraz technikom optymalizacji ich rozmiaru i czasu kompilacji!

Często zadawane pytania

Czy lekcja „Tworzenie niestandardowych obrazów Docker” jest bezpłatna?

Tak — pełny tekst „Tworzenie niestandardowych obrazów Docker” 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 DevOps Bootcamp, przejdź na CoddyKit PRO. Kurs DevOps Bootcamp zawiera 4 lekcji w sumie.

Co nauczysz się w „Tworzenie niestandardowych obrazów Docker”?

Zbuduj swój pierwszy niestandardowy obraz Docker dla prostej aplikacji oraz prawidłowo go otaguj i wersjonuj. Ćwiczysz DevOps Bootcamp 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ąć DevOps Bootcamp?

Nie wymagamy żadnego doświadczenia. DevOps Bootcamp 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 2 z 4.

Ile czasu zajmuje lekcja „Tworzenie niestandardowych obrazów Docker”?

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 DevOps Bootcamp?

Tak. Każda lekcja DevOps Bootcamp 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. Poznawanie plików Dockerfile
  2. Tworzenie niestandardowych obrazów Docker
  3. Warstwy i optymalizacja obrazów
  4. Kompilacje wieloetapowe i mniejsze obrazy
← Powrót do DevOps Bootcamp