Ten rozdział omawia nowe polecenia Dockera oraz sposoby współdzielenia danych między systemem hosta a skonteneryzowanymi aplikacjami. Dowiedz się, kiedy i jak używać trwałych woluminów oraz uzyskiwać dostęp do systemów plików hosta.

Pośrednie polecenia Dockera

Szybka pomoc

Istniejące kontenery

Automatyczne usuwanie kontenerów

Montowanie systemu plików hosta

Przekazywanie pliku do działającego kontenera

Znikł, ale nie zniknął

Różne metody, ten sam efekt

Woluminy trwałe

Tworzenie woluminu kontenera

Różne kontenery, ten sam wolumen

Polecenia i systemy plików

Naucz się udostępniać usługi sieciowe w Dockerze, tworzyć sieci Dockera i używać plików Dockerfile do zarządzania ustawieniami sieciowymi.

Odświeżenie wiedzy o sieciach

Jaki mam adres IP?

Prawidłowe porty

Udostępnianie usług sieciowych w Dockerze

Mapowanie portów

Wiele kontenerów, ten sam port hosta?

Udostępnianie portów za pomocą plików Dockerfile

Tyle możliwości

Mapowanie portu kontenera

Używanie efemerycznego mapowania portów

Sieci Docker

Tworzenie sieci Docker

Dodawanie kontenerów do sieci

Zakresy adresów IP

Usuwanie sieci kontenerów

Sieć

Naucz się korzystać z zaawansowanych narzędzi Dockera do zarządzania obrazami i ich kompilacji, aby tworzyć kompaktowe i wydajne obrazy kontenerów. Twórz obrazy wieloplatformowe, które działają na różnych architekturach procesorów.

Optymalizacja obrazów Docker

Przemyśl swoje obawy

Eksploracja obrazów Docker

Wybór najlepszego obrazu bazowego

Warstwy obrazów – jak to działa

Tort warstwowy

Ile warstw?

Kompilacje wieloetapowe

package main
import "fmt"

func main() {
  fmt.Println("Application running...")
}


FROM golang:1.21-alpine3.19
WORKDIR /src
COPY /src/main.go /src/main.go

# Build the go application from source code
RUN go build -o /bin/app_runner /src/main.go

CMD ["/bin/app_runner"]


Run the following commands:
  - docker build . -t single-stage-app
  - docker run single-stage-app
  - docker images
Check the size of the single-stage-app image


Kompilacja jednoczęściowa

FROM golang:1.21-alpine3.19 AS gobuild

WORKDIR /src
COPY /src/main.go /src/main.go

# Build the go application from source code
RUN go build -o /bin/app_runner /src/main.go

# Create application in standalone container
# Update with the image name from instructions

FROM ____

# Update with name of previous build stage
COPY --from=____ /bin/app_runner /bin/app_runner

CMD ["/bin/app_runner"]


FROM golang:1.21-alpine3.19 AS gobuild

WORKDIR /src
COPY src/main.go /src/main.go

# Build the go application from source code
RUN go build -o /bin/app_runner /src/main.go

# Create application in standalone container
# Update with the image name from instructions

FROM scratch

# Update with name of previous build stage
COPY --from=gobuild /bin/app_runner /bin/app_runner

CMD ["/bin/app_runner"]


Update the Dockerfile as shown in the example.

Once complete, run the following commands in the terminal:

- docker build . -t multi-stage-app
- docker run multi-stage-app
- docker images

Check the size of the single-stage-app and multi-stage-app
containers.


Wieloetapowe budowanie obrazu

Kroki kompilacji silnika Dockera

Zrozumienie kompilacji wieloetapowych

Kompilacje wieloplatformowe

Kolejność kroków w budowaniu obrazu wieloplatformowego

Etapy budowania obrazów wieloplatformowych

#!/bin/bash

# Note this is an example of string concatenation in jq
#
# There is not a Platform attribute returned by docker image inspect
# so we create our own. This is simply a string returned as Platform,
# consisting of the .Os attribute and the .Architecture attribute joined
# with a slash to produce the Platform field.
#
# This is outside the realm of the course, but is hopefully a further
# example of the power available within the jq tool.

docker image inspect multi-platform-app | jq '.[0] | {Platform: (.Os + "/" + .Architecture)}'


# Update the FROM line to support a multi-platform build
FROM ____=$BUILDPLATFORM golang:1.21-alpine3.19 AS gobuild

WORKDIR /src
COPY src/main.go /src/main.go

# Define the option to pull environment variables from the host
____ TARGETOS TARGETARCH

# Build the go application from source code
RUN env GOOS=$TARGETOS GOARCH=$TARGETARCH go build -o /bin/app_runner /src/main.go

# Create application in standalone container
# Update with the image name from instructions

FROM ____

# Update with name of previous build stage
COPY --from=____ /bin/app_runner /bin/app_runner

CMD ["/bin/app_runner"]


# Update the FROM line to support a multi-platform build
FROM --platform=$BUILDPLATFORM golang:1.21-alpine3.19 AS gobuild

WORKDIR /src
COPY src/main.go /src/main.go

# Define the option to pull environment variables from the host
ARG TARGETOS TARGETARCH

# Build the go application from source code
RUN env GOOS=$TARGETOS GOARCH=$TARGETARCH go build -o /bin/app_runner /src/main.go

# Create application in standalone container
# Update with the image name from instructions

FROM scratch

# Update with name of previous build stage
COPY --from=gobuild /bin/app_runner /bin/app_runner

CMD ["/bin/app_runner"]


Update the Dockerfile as shown in the example.

Once complete, run the following command in the terminal:

- docker buildx build --platform linux/arm64 . -t multi-platform-app 

Verify the platform image built as expected by running the command:

./check_platform.sh

in the terminal window and verify that it returns "linux/arm64"


Budowanie obrazu dla wielu platform

Tworzenie zaawansowanych obrazów kontenerów

Połącz możliwości Dockera w zakresie woluminów, sieci i obsługi kontenerów, tworząc wielokontenerowe aplikacje za pomocą Docker Compose. Aktualizuj wdrożenia i zarządzaj nimi przy użyciu pliku docker-compose.yml.

Wprowadzenie do Docker Compose

Zarządzanie aplikacją za pomocą Docker Compose

Rozwiązywanie problemów z uruchamianiem aplikacji

Tworzenie plików compose.yaml

Tworzenie pliku compose.yaml

Rozpoznawanie sekcji

Ile zasobów?

Zależności i rozwiązywanie problemów w Docker Compose

Obliczanie kolejności zależności

Kolejność wyłączania

Rozwiązywanie problemów z zależnościami

Tworzenie usługi danych w Dockerze

Tworzenie backendu usługi danych

Dodawanie klienta danych

Definiowanie pełnej aplikacji za pomocą Docker Compose

Gratulacje!

Docker Compose

Ten kurs rozbudowuje wiedzę zdobytą w kursie Wprowadzenie do Dockera, poświęconym podstawom konteneryzacji. Rozwijamy omówione tam koncepcje i narzędzia, wprowadzając zarządzanie obrazami kontenerów i ich optymalizację, obsługę sieci, komunikację z systemem plików, a także tworzenie aplikacji wieloplatformowych i wielokontenerowych. Po ukończeniu kursu będziesz potrafić:

- Tworzyć wieloetapowe kompilacje w celu optymalizacji rozmiaru, bezpieczeństwa i możliwości ponownego użycia skonteneryzowanych aplikacji.
- Korzystać z narzędzi i mechanizmów sieciowych Dockera, aby umożliwiać komunikację między kontenerami oraz udostępniać usługi sieciowe w sieci lokalnej i zewnętrznej.
- Współdzielić pliki i dane między kontenerami a maszyną hosta za pomocą montowania systemu plików i woluminów Dockera.
- Tworzyć wielokontenerowe wdrożenia aplikacji przy użyciu Docker Compose, znacznie upraszczając konfigurację złożonych narzędzi powszechnych w środowiskach data science i inżynierii danych.

Najwięcej wyniesiesz z tego kursu, jeśli masz już doświadczenie w tworzeniu prostych kontenerów i chcesz rozszerzyć swój warsztat programistyczny, testowy i dystrybucyjny. Zapraszamy do nauki Dockera!

Ten kurs rozwija wiedzę zdobytą na kursie Wprowadzenie do Dockera, zagłębiając się bardziej w koncepcje i narzędzia konteneryzacji. Poznamy zaawansowane zagadnienia, takie jak zarządzanie obrazami kontenerów, sieci, komunikacja systemu plików oraz tworzenie aplikacji wieloplatformowych i wielokontenerowych.
<h2>Optymalizacja aplikacji konteneryzowanych</h2>
Naucz się tworzyć wieloetapowe kompilacje, aby zwiększyć rozmiar, bezpieczeństwo i możliwość ponownego wykorzystania aplikacji konteneryzowanych. Dzięki praktycznym ćwiczeniom opanujesz techniki optymalizacji obrazów kontenerów, zapewniając efektywne wdrażanie i zarządzanie w zróżnicowanych środowiskach.
<h2>Usprawnianie wdrożeń kontenerów za pomocą Docker Compose</h2>
Dowiedz się, jak wykorzystać narzędzia i koncepcje sieciowe Dockera, aby ułatwić komunikację między kontenerami oraz zapewnić usługi sieciowe zarówno dla sieci lokalnych, jak i zewnętrznych. Poznaj punkty montowania systemu plików i woluminy, aby bezproblemowo udostępniać dane między kontenerami a maszyną hosta. Dodatkowo zdobędziesz biegłość w Docker Compose do orkiestracji wdrożeń aplikacji wielokontenerowych, co uprości konfigurację złożonych narzędzi powszechnie stosowanych w środowiskach data science i inżynierii.
<h2>Wspieranie tworzenia i wdrażania</h2>
Ten kurs wyposaża Cię w niezbędne umiejętności, które usprawnią Twoje procesy tworzenia, testowania i dystrybucji. Choć nie jest to konieczne, najwięcej zyskasz na tym kursie, jeśli pracowałeś(-aś) już z kontenerami i tworzyłeś(-aś) proste kontenery. Pod koniec kursu będziesz mieć wiedzę i narzędzia, aby optymalizować aplikacje konteneryzowane, usprawniać komunikację między kontenerami i z łatwością wdrażać aplikacje wielokontenerowe, co wesprze Cię na Twojej ścieżce nauki Dockera.

Introduction to Docker

Opanuj wieloetapowe budowanie, narzędzia sieciowe Docker i Docker Compose dla optymalnych aplikacji!

Docker średnio zaawansowany

Opanuj wieloetapowe buildy, narzędzia sieciowe Dockera i Docker Compose, by tworzyć optymalne aplikacje kontenerowe!

Konteneryzacja i wirtualizacja z Docker i Kubernetes

Plik Dockerfile powinien utworzyć etap budowania z użyciem `$BUILDPLATFORM`

Wartości `ARG` powinny być pobrane z hosta

Zdefiniuj wartość `FROM` dla docelowego kontenera

Skopiuj skompilowany kod do obrazu kontenera

Etapy budowania obrazów wieloplatformowych

Docker średnio zaawansowany

Interaktywne ćwiczenie praktyczne