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.

Ottimizzare le immagini Docker

Contieni le tue preoccupazioni

Esplorazione delle immagini Docker

Determinare la migliore immagine da usare

Capire i layer

Torta a strati

Quanti layer?

Build multi-stage

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


Build a singolo stadio

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.


Passaggi di build del motore Docker

Capire i build multi-stage

Build multi‑piattaforma

Ordine di una build multi-piattaforma

Passi multi-piattaforma

#!/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"


Build multi-piattaforma

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.

Introduction to Docker Compose

Managing an application with Docker Compose

Troubleshooting application startup

Creating compose.yaml files

Writing a compose.yaml file

Identifying sections

How many resources?

Dependencies and troubleshooting in Docker Compose

Dependency calculation

Shutdown order

Troubleshooting dependencies

Creating a data service within Docker

Building a data service backend

Adding a data client

Using Docker Compose to define a full application

Congratulations!

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!

Quanti layer?

Docker intermedio

Esercizio pratico interattivo