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.

Docker-images optimaliseren

Beperk je bezwaren

Docker-images verkennen

De beste image kiezen

Lagen begrijpen

Laagjestaart

Hoeveel lagen?

Multi-stage builds

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


Single-stage build

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.


Multi-stage build

Build-stappen van de Docker-engine

Multi-stage builds begrijpen

Multi-platform builds

Volgorde van een multi-platform build

Multi-platform stappen

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


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.

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

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!

Hoeveel lagen?

Docker voor gevorderden

Praktische interactieve oefening