Tato kapitola se věnuje novým příkazům Dockeru a podrobnostem o sdílení dat mezi hostitelským systémem a kontejnerizovanými aplikacemi. Naučíš se, kdy a jak používat persistentní volumes a přistupovat k souborovým systémům hostitele.

Středně pokročilé příkazy Dockeru

Rychlý přehled nápovědy

Existující kontejnery

Automatické odstranění kontejneru

Připojení souborového systému hostitele

Předání souboru běžícímu kontejneru

Pryč, ale nezapomenuto

Různé metody, stejný výsledek

Persistentní svazky

Vytvoření volume pro kontejner

Různé kontejnery, stejný svazek

Příkazy a souborové systémy

Naučíš se zpřístupňovat síťové služby v Dockeru, vytvářet Docker sítě a používat Dockerfile pro správu síťových nastavení.

Opakování základů sítí

Jaká je moje IP adresa?

Platné porty

Zpřístupnění síťových služeb v Dockeru

Mapování portů

Více kontejnerů, stejný port na hostu?

Vystavení portů pomocí Dockerfile

Tolik možností

Mapování portu kontejneru

Použití efemérního mapování portů

Docker sítě

Vytvoření Docker sítě

Přidávání kontejnerů do sítě

Rozsahy IP adres

Odebírání kontejnerových sítí

Síťování

Naučíš se používat pokročilé nástroje pro správu a sestavování obrazů v Dockeru, aby byly kompaktní a efektivní. Vytvoříš multiplatformní obrazy schopné běžet na různých procesorových architekturách.

Optimalizace Docker image

Důvody pro obavy

Průzkum Docker image

Výběr nejvhodnějšího image

Pochopení vrstev

Vrstvený dort

Kolik vrstev?

Vícefázové buildy

Jednoetapové sestavení

Multi-stage build

Jak fungují multi-stage buildy

Sestavení pro více platforem

Kroky multi-platform buildu

Sestavení multi-platform image

Pokročilá tvorba obrazů kontejnerů

Zkombinuj možnosti Dockeru v oblasti volumes, síťování a správy kontejnerů do aplikací s více kontejnery pomocí Docker Compose. Aktualizuj a spravuj nasazení aplikací prostřednictvím souboru `docker-compose.yml`.

Úvod do Docker Compose

Správa aplikace pomocí Docker Compose

Řešení problémů při spouštění aplikace

Vytváření souborů compose.yaml

Psaní souboru compose.yaml

Rozpoznávání sekcí

Kolik zdrojů?

Závislosti a řešení problémů v Docker Compose

Pořadí spouštění zdrojů

Výpočet závislostí

Pořadí vypínání

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

Řešení problémů se závislostmi

Vytvoření datové služby v Dockeru

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


Sestavení backendu datové služby

Přidání datového klienta

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


Definování kompletní aplikace pomocí Docker Compose

Gratulujeme!

Docker Compose

Tento kurz navazuje na základy Dockeru a kontejnerizace z kurzu Úvod do Dockeru. Rozšiřujeme koncepty a nástroje z toho kurzu a přidáváme témata jako správa a optimalizace obrazů kontejnerů, síťování, komunikace se souborovým systémem, multiplatformní aplikace a aplikace s více kontejnery. Po dokončení kurzu budeš umět:

- Vytvářet vícefázové buildy pro optimalizaci velikosti, bezpečnosti a znovupoužitelnosti kontejnerizovaných aplikací.
- Používat síťové nástroje a koncepty Dockeru pro komunikaci mezi kontejnery a poskytování síťových služeb lokální síti i vnějšímu světu.
- Sdílet soubory a data mezi kontejnery a hostitelským počítačem pomocí připojení souborového systému a volumes v Dockeru.
- Vytvářet nasazení aplikací s více kontejnery pomocí Docker Compose, což výrazně zjednodušuje nastavení složitých nástrojů běžných v prostředí datové vědy a inženýrství.

Z tohoto kurzu vytěžíš nejvíce, pokud už máš zkušenosti s vytvářením jednoduchých kontejnerů a chceš rozšířit svůj toolbox pro vývoj, testování a distribuci. Těšíme se, že tě provedeme tvou cestou za poznáváním Dockeru.

Tento kurz navazuje na znalosti získané v kurzu Úvod do Dockeru a jde více do hloubky konceptů a nástrojů kontejnerizace. Prozkoumáme pokročilá témata, jako je správa obrazů kontejnerů, síťování, komunikace souborového systému a vývoj multiplatformních a vícekontejnerových aplikací.
<h2>Optimalizace kontejnerizovaných aplikací</h2>
Naučte se vytvářet vícestupňové buildy pro zlepšení velikosti, zabezpečení a znovupoužitelnosti kontejnerizovaných aplikací. Prostřednictvím praktických cvičení si osvojíte techniky pro optimalizaci kontejnerových obrazů a zajistíte efektivní nasazení a správu v různorodých prostředích.
<h2>Vylepšení nasazení kontejnerů pomocí Docker Compose</h2>
Objevte, jak využít síťové nástroje a koncepty Dockeru k usnadnění komunikace mezi kontejnery a poskytování síťových služeb pro místní i externí sítě. Prozkoumejte připojení souborového systému a svazky pro bezproblémové sdílení dat mezi kontejnery a hostitelským počítačem. Navíc získáte dovednosti v Docker Compose pro orchestraci nasazení vícekontejnerových aplikací, což zjednoduší nastavení komplexních nástrojů běžných v prostředích datové vědy a inženýrství.
<h2>Umožnění vývoje a nasazení</h2>
Tento kurz vás vybaví základními dovednostmi, které vám pomohou zlepšit vaše procesy vývoje, testování a distribuce. Ačkoli to není nezbytné, z tohoto kurzu získáš nejvíce, pokud už jsi pracoval/a s kontejnery a vytvořil/a několik jednoduchých kontejnerů. Na konci kurzu budete mít znalosti a nástroje k optimalizaci kontejnerizovaných aplikací, zefektivnění komunikace mezi kontejnery a snadnému nasazování vícekontejnerových aplikací, což vás posune na vaší cestě za učením Dockeru.

Introduction to Docker

Ovládněte vícefázové sestavení, nástroje pro síťování Dockeru a Docker Compose pro lepší aplikace!

Intermediate Docker

Zvládněte vícestupňové buildy, síťové nástroje Dockeru a Docker Compose pro optimální kontejnerové aplikace!

Rozpoznávání sekcí

Intermediate Docker

Interaktivní praktické cvičení