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

Kompilacja jednoczęściowa

Wieloetapowe budowanie obrazu

Zrozumienie kompilacji wieloetapowych

Kompilacje wieloplatformowe

Etapy budowania obrazów wieloplatformowych

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

Kolejność uruchamiania zasobów

Obliczanie kolejności zależności

Kolejność wyłączania

FROM python:3.12-alpine3.19
WORKDIR /code
RUN apk add --no-cache gcc musl-dev linux-headers
COPY requirements.txt requirements.txt
RUN pip install -r requirements.txt
COPY . .
CMD ["python3", "app.py"]


import time
import redis

cache = redis.Redis(host='redis', port=6379, socket_timeout=1)

def get_hit_count():
  retries = 5
  while True:
    try:
      return cache.incr('hits')
    except redis.exceptions.ConnectionError as exc:
      if retries == 0:
        raise exc
      retries -= 1
      time.sleep(0.5)

def hello():
  count = get_hit_count()
  return f'Successfully communicated {count} times.\n'

for i in range(0, 5):
  print(f"{hello()}")


services:
  app:
    build: .
  redis:
    image: "redis:alpine3.20"
    depends_on:
      - app


services:
  app:
    build: .
    depends_on:
      - redis
  redis:
    image: "redis:alpine3.20"


# Solution Steps:
  # 1. Run `docker compose up -d` to start the services
  # 2. Use `docker compose logs` to view the startup logs and identify errors
  # 3. Examine the compose.yaml file to find the dependency issue
  # 4. Update the compose.yaml to move depends_on from redis to app service
  # 5. Run `docker compose down` to stop all services
  # 6. Rerun `docker compose up -d` and verify you see "Successfully communicated" messages

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

Tworzenie usługi danych w Dockerze

import duckdb
from flask import Flask

app = Flask(__name__)

@app.route("/tripcount")
def returndata():
  cursor = duckdb.connect()
  try:
    count = cursor.execute("select count(*) from read_parquet('/data/*.parquet')").fetchall()[0][0]
    return f"Total trips: {count}"
  except duckdb.duckdb.IOException:
    return f"Data files are not present", 503

@app.route("/first")
def returnfirst():
  cursor = duckdb.connect()
  try:
    first = cursor.execute("select min(tpep_pickup_datetime) from read_parquet('/data/*.parquet')").fetchall()[0][0]
    return f"First pickup: {first:%Y/%m/%d}" 
  except duckdb.duckdb.IOException:
    return f"Data files are not present", 503

@app.route("/last")
def returnlast():
  cursor = duckdb.connect()
  try:
    last = cursor.execute("select max(tpep_pickup_datetime) from read_parquet('/data/*.parquet')").fetchall()[0][0]
    return f"Last pickup: {last:%Y/%m/%d}" 
  except duckdb.duckdb.IOException:
    return f"Data files are not present", 503


FROM python:3.12-alpine3.19

#
# NOTE: Application reads contents of /data in container
# If not found, application returns errors.
# 

WORKDIR /app
ENV FLASK_RUN_HOST=0.0.0.0

COPY code/app.py .
COPY code/requirements.txt .

RUN pip install -r requirements.txt --root-user-action=ignore

EXPOSE 5000

CMD ["flask", "run"]


STATUS_CODE=$(curl --silent --head http://localhost:5000/tripcount | awk '/^HTTP/{print $2}')

if [ "$STATUS_CODE" == "503" ]; then
  echo "ERROR ACCESSING DATA SERVICE - PLEASE VERIFY DATA IS PRESENT"
  echo "Did you use a -v flag with your docker run command?"
elif [ "$STATUS_CODE" == "200" ]; then
  echo "SUCCESSFULLY ACCESSED DATA SERVICE!"
else
  echo "ERROR ACCESSING DATA SERVICE - PLEASE VERIFY SERVICE IS RUNNING"
  echo "Did you start your container with a -p flag?"
fi
  


There are several steps required to complete this exercise:

- Build the dataservice container using the following command in the terminal:

docker build . -t dataservice

- Run an instance of the Docker container as follows:

docker run -d -p5000:5000 -v ~/workspace/datasets:/data dataservice

- Verify that the service is working by running the ./app_test.sh on the terminal


Tworzenie backendu usługi danych

Dodawanie klienta danych

services:
  ____:
    image: dataservice
    volumes:
      - /home/repl/datasets:/data
    networks: 
      data_net:
        ipv4_address: 10.11.12.2

  dataclient:
    image: ____
    depends_on: 
      - ____
    networks:
      data_net:
        ipv4_address: 10.11.12.3

# Ignore everything below this line
networks:
  data_net:
    driver: macvlan
    ipam:
      config:
        - subnet: "10.11.12.0/24"
    


services:
  dataservice:
    image: dataservice
    volumes:
      - /home/repl/workspace/datasets:/data
    networks: 
      data_net:
        ipv4_address: 10.11.12.2

  dataclient:
    image: dataclient
    depends_on: 
      - dataservice
    networks:
      data_net:
        ipv4_address: 10.11.12.3

# Ignore everything below this line
networks:
  data_net:
    driver: macvlan
    ipam:
      config:
        - subnet: "10.11.12.0/24"
    


- Update the compose.yaml file as shown.
- Run the following command:

  docker compose up -d
  
- Run the command:

  docker compose logs dataclient


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!

Rozpoznawanie sekcji

Docker średnio zaawansowany

Interaktywne ćwiczenie praktyczne