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.

Introduzione a Docker Compose

Gestire un'applicazione con Docker Compose

Risoluzione dei problemi all'avvio dell'applicazione

Creare file compose.yaml

Scrivere un file compose.yaml

Identificare le sezioni

Quante risorse?

Dipendenze e risoluzione dei problemi in Docker Compose

Ordine di avvio delle risorse

Calcolo delle dipendenze

Ordine di spegnimento

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

Risoluzione dei problemi di dipendenze

Creare un servizio dati con 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


Creare un backend di data service

Aggiungere un client dati

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


Usare Docker Compose per definire un'applicazione completa

Congratulazioni!

Docker Compose

Questo corso amplia le basi su Docker e la containerizzazione trattate nel corso Introduzione a Docker. Estenderemo i concetti e gli strumenti visti in quel corso, aggiungendo la gestione e l’ottimizzazione delle immagini dei container, il networking, la comunicazione tramite file system, e le applicazioni multi‑piattaforma e multi‑container. Al termine, sarai in grado di:

- Creare build multi‑stage per ottimizzare dimensioni, sicurezza e riusabilità delle applicazioni containerizzate.
- Usare gli strumenti e i concetti di networking di Docker per abilitare le comunicazioni tra container e offrire servizi di rete alla rete locale e al mondo esterno.
- Condividere file e dati tra container e macchina host usando i mount del file system di Docker e i volumi.
- Creare deployment di applicazioni multi‑container con Docker Compose, semplificando drasticamente la configurazione di strumenti complessi comuni negli ambienti di data science e ingegneria.

Otterrai il massimo da questo corso se hai già lavorato con alcuni container semplici e ne hai creati, ma vuoi ampliare gli strumenti per sviluppo, test e distribuzione. Non vediamo l’ora di guidarti nel tuo percorso di apprendimento di Docker.

Questo corso approfondisce le conoscenze acquisite nel corso Introduzione a Docker, esplorando più a fondo i concetti e gli strumenti della containerizzazione. Esploreremo argomenti avanzati come la gestione delle immagini dei container, il networking, la comunicazione tra file system e lo sviluppo di app multipiattaforma e multicontner.
<h2>Ottimizzazione delle applicazioni containerizzate</h2>
Impara a creare build in più fasi per migliorare le dimensioni, la sicurezza e la riutilizzabilità delle app containerizzate. Attraverso esercizi pratici, impara le tecniche per ottimizzare le immagini dei container, assicurando un'implementazione e una gestione efficienti in diversi ambienti.
<h2>Migliorare le distribuzioni dei container con Docker Compose</h2>
Scopri come usare gli strumenti e i concetti di rete di Docker per rendere più facile la comunicazione tra i container e fornire servizi di rete sia alle reti locali che a quelle esterne. Scopri come montare file system e volumi per condividere i dati senza problemi tra i container e la macchina host. In più, impara a usare Docker Compose per gestire le distribuzioni di app multi-container, semplificando la configurazione di strumenti complicati che si usano spesso nei campi della scienza dei dati e dell'ingegneria.
<h2>Potenziare lo sviluppo e l'implementazione</h2>
Questo corso ti dà le competenze essenziali per migliorare i tuoi processi di sviluppo, test e distribuzione. Anche se non è fondamentale, potrai ottenere il massimo da questo corso se hai già lavorato con alcuni semplici contenitori e li hai creati. Alla fine del corso, avrai le conoscenze e gli strumenti per ottimizzare le app containerizzate, semplificare la comunicazione tra i container e distribuire facilmente app multi-container, aiutandoti nel tuo percorso di apprendimento di Docker.

Introduction to Docker

Padroneggia build multi-stage, strumenti di rete Docker e Docker Compose per app containerizzate ottimali!

Docker intermedio

Impara a gestire build multistadio, strumenti di rete Docker e Docker Compose per avere app containerizzate al top!

Ordine di spegnimento

Docker intermedio

Esercizio pratico interattivo