This chapter covers new Docker commands and details on how to share data between host system and containerized applications. Learn when and how to use persistent volumes and access host filesystems.

Intermediate Docker Commands

Help at a glance

Existing containers

Automatic container cleanup

Mounting the host filesystem

Passing a file to a running container

Gone, but not forgotten

Different methods, same result

Persistent volumes

Creating a container volume

Different containers, same volume

Commands and filesystems

Learn to expose networking services in Docker, create Docker networks, and use Dockerfiles to maintain network settings.

Networking refresher

What's my IP?

Valid ports

Making network services available in Docker

Mapping a port

Multiple containers, same host port?

Exposing ports with Dockerfiles

So many options

Mapping a container port

Using ephemeral mapping

Docker networks

Creating a docker network

Adding containers to a network

IP Ranges

Removing container networks

Networking

Learn to use Docker's advanced image management and build tools to create compact effective container images. Create multi-platform images capable of running on different processor architectures.

Optimizing Docker images

Contain your concerns

Docker image exploration

Determining the best image to use

Understanding layers

Layer cake

How many layers?

Multi-stage builds

Single-stage build

Multi-stage build

Understanding multi-stage builds

Multi-platform builds

Multi-platform steps

Multi-platform build

Building advanced container images

Combine the the volume, networking, and container handling capabilities of Docker into multi-container applications using Docker Compose. Update and manage application deployments via the docker-compose.yml file.

Introductie tot Docker Compose

Een applicatie beheren met Docker Compose

Problemen oplossen bij het starten van de applicatie

compose.yaml-bestanden maken

Een compose.yaml-bestand schrijven

Secties herkennen

Hoeveel resources?

Afhankelijkheden en troubleshooting in Docker Compose

Opstartvolgorde van resources

Afhankelijkheidsberekening

Volgorde van afsluiten

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

Problemen met afhankelijkheden oplossen

Een dataservice maken binnen Docker

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


Een backend voor een dataservice bouwen

Een dataclient toevoegen

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


Een volledige applicatie definiëren met Docker Compose

Gefeliciteerd!

Docker Compose

Deze cursus bouwt voort op de basis van Docker en containerisatie uit de cursus Introduction to Docker. We verdiepen de concepten en tools uit die cursus en voegen onderwerpen toe zoals beheer en optimalisatie van containerimages, netwerken, bestandssysteemcommunicatie en multi-platform- en multi-containerapplicaties. Na afronding kun je:

- Multi-stage builds maken om de grootte, veiligheid en herbruikbaarheid van gecontaineriseerde applicaties te optimaliseren.
- Docker-netwerktools en -concepten gebruiken om communicatie tussen containers toe te voegen en netwerkdiensten aan het lokale netwerk en de buitenwereld te bieden.
- Bestanden en data delen tussen containers en de hostmachine met Docker-bestandssysteem mounts en volumes.
- Deployments van multi-containerapplicaties maken met Docker Compose, waardoor de setup van complexe tools die vaak in data science en engineering worden gebruikt, sterk wordt vereenvoudigd.

Je haalt het meeste uit deze cursus als je al met eenvoudige containers hebt gewerkt en gebouwd, en je je toolkit voor ontwikkeling, testen en distributie wilt uitbreiden. We kijken ernaar uit je te begeleiden tijdens je leerreis met Docker.

Deze cursus bouwt voort op wat je hebt geleerd in de cursus Inleiding tot Docker en gaat dieper in op containerisatieconcepten en -tools. We gaan dieper in op geavanceerde onderwerpen zoals het beheer van containerimages, netwerken, bestandsysteemcommunicatie en het ontwikkelen van applicaties voor meerdere platforms en containers.
<h2>Containerized apps beter maken</h2>
Leer hoe je builds in meerdere stappen kunt maken om de grootte, beveiliging en herbruikbaarheid van gecontaineriseerde apps te verbeteren. Leer door middel van praktische oefeningen hoe je containerimages kunt optimaliseren, zodat je ze efficiënt kunt gebruiken en beheren in allerlei omgevingen.
<h2>Containerimplementaties verbeteren met Docker Compose</h2>
Ontdek hoe je Docker-netwerktools en -concepten kunt gebruiken om communicatie tussen containers makkelijker te maken en netwerkservices te bieden aan zowel lokale als externe netwerken. Check eens de bestandssysteemkoppelingen en volumes voor het makkelijk delen van gegevens tussen containers en de hostmachine. Leer ook goed omgaan met Docker Compose om meerdere containers in apps te regelen, zodat je makkelijker complexe tools kunt opzetten die vaak worden gebruikt in datawetenschap en engineering.
<h2>Ontwikkeling en implementatie stimuleren</h2>
Deze cursus geeft je de vaardigheden die je nodig hebt om je ontwikkelings-, test- en distributieprocessen te verbeteren. Hoewel het niet echt nodig is, haal je het meeste uit deze cursus als je al eens met simpele containers hebt gewerkt en er een paar hebt gemaakt. Aan het einde van de cursus heb je de kennis en tools om gecontaineriseerde applicaties te optimaliseren, de communicatie tussen containers te stroomlijnen en multi-containerapplicaties makkelijk te implementeren, waardoor je verder kunt op je Docker-leertraject.

Introduction to Docker

Beheers multi-stage builds, Docker-netwerktools en Docker Compose voor optimale containerapplicaties!

Docker voor gevorderden

Word een expert in multi-stage builds, Docker-netwerktools en Docker Compose voor de beste containerized apps!

Volgorde van afsluiten

Docker voor gevorderden

Praktische interactieve oefening