Ce chapitre présente de nouvelles commandes Docker et explique en détail comment partager des données entre le système hôte et les applications conteneurisées. Découvrez quand et comment utiliser des volumes persistants et accéder aux systèmes de fichiers de l’hôte.

Commandes Docker intermédiaires

Aide en un coup d’œil

Conteneurs existants

Nettoyage automatique du conteneur

Monter le système de fichiers de l’hôte

Transmettre un fichier à un conteneur en cours d’exécution

Parti, mais pas oublié

Méthodes différentes, même résultat

Volumes persistants

Créer un volume de conteneur

Conteneurs différents, même volume

Commandes et systèmes de fichiers

Apprenez à exposer des services réseau dans Docker, à créer des réseaux Docker et à utiliser des Dockerfiles pour conserver la configuration réseau.

Rappel sur le réseau

Quelle est mon IP ?

Ports valides

Rendre des services réseau disponibles dans Docker

Mapper un port

Plusieurs conteneurs, même port hôte ?

Exposer des ports avec des Dockerfiles

Tellement d’options

Mapper un port de conteneur

Utiliser un mappage éphémère

Réseaux Docker

Créer un réseau Docker

Ajouter des conteneurs à un réseau

Plages IP

Supprimer des réseaux de conteneurs

Réseau

Apprenez à utiliser les outils avancés de gestion et de build d’images de Docker pour créer des images de conteneur compactes et efficaces. Créez des images multi‑plateformes capables de s’exécuter sur différentes architectures de processeur.

Optimiser les images Docker

Maîtriser vos préoccupations

Exploration des images Docker

Déterminer la meilleure image à utiliser

Comprendre les couches

Gâteau de couches

Combien de couches ?

Constructions multi-étapes

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 en une seule étape

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.


Build multi-étapes

Étapes de build du moteur Docker

Comprendre les builds multi-étapes

Constructions multiplateformes

Ordre d'un build multi-plateformes

Étapes multi-plateformes

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

Création d’images de conteneur avancées

Combinez les capacités de Docker en matière de volumes, de réseau et de gestion des conteneurs pour créer des applications multi‑conteneurs avec Docker Compose. Mettez à jour et administrez les déploiements via le fichier docker-compose.yml.

Introduction à Docker Compose

Gérer une application avec Docker Compose

Dépanner le démarrage de l’application

Créer des fichiers compose.yaml

Écrire un fichier compose.yaml

Identifier les sections

Combien de services ?

Dépendances et dépannage avec Docker Compose

Calcul des dépendances

Ordre d’arrêt

Dépannage des dépendances

Créer un service de données dans Docker

Créer un backend de service de données

Ajout d’un client de données

Utiliser Docker Compose pour définir une application complète

Félicitations !

Docker Compose

Ce cours approfondit les bases de Docker et de la conteneurisation présentées dans le cours Introduction à Docker. Nous allons plus loin sur les concepts et outils abordés, en y ajoutant la gestion et l’optimisation des images de conteneurs, le réseau, la communication via le système de fichiers, ainsi que les applications multi‑plateformes et multi‑conteneurs. À la fin, vous serez en mesure de :

- Créer des builds multi‑étapes pour optimiser la taille, la sécurité et la réutilisabilité des applications conteneurisées.
- Utiliser les outils et concepts réseau de Docker pour ajouter des communications entre conteneurs et fournir des services réseau au réseau local et vers l’extérieur.
- Partager des fichiers et des données entre les conteneurs et la machine hôte à l’aide des montages de systèmes de fichiers et des volumes Docker.
- Créer des déploiements d’applications multi‑conteneurs avec Docker Compose, simplifiant drastiquement la mise en place d’outils complexes courants en data science et en ingénierie.

Ce cours sera particulièrement utile si vous avez déjà manipulé et construit quelques conteneurs simples et souhaitez étoffer votre boîte à outils de développement, de test et de distribution. Nous sommes impatients de vous accompagner dans votre progression sur Docker.

Ce cours approfondit les connaissances acquises dans le cours Introduction à Docker, en explorant plus en détail les concepts et les outils de conteneurisation. Nous aborderons des sujets avancés tels que la gestion des images de conteneurs, la mise en réseau, la communication entre systèmes de fichiers et le développement d'applications multi-plateformes et multi-conteneurs.
<h2>Optimisation des applications conteneurisées</h2>
Apprenez à créer des builds en plusieurs étapes afin d'améliorer la taille, la sécurité et la réutilisabilité des applications conteneurisées. Grâce à des exercices pratiques, maîtrisez les techniques permettant d'optimiser les images de conteneurs, garantissant ainsi un déploiement et une gestion efficaces dans divers environnements.
<h2>Améliorer les déploiements de conteneurs avec Docker Compose</h2>
Découvrez comment exploiter les outils et concepts de mise en réseau Docker pour faciliter la communication entre conteneurs et fournir des services de mise en réseau aux réseaux locaux et externes. Découvrez les montages et les volumes du système de fichiers pour un partage transparent des données entre les conteneurs et la machine hôte. De plus, acquérez des compétences dans l'utilisation de Docker Compose pour orchestrer le déploiement d'applications multi-conteneurs, simplifiant ainsi la configuration d'outils complexes couramment utilisés dans les environnements de science des données et d'ingénierie.
<h2>Développement et déploiement proactifs</h2>
Ce cours vous fournit les compétences essentielles pour améliorer vos processus de développement, de test et de distribution. Bien que cela ne soit pas indispensable, vous tirerez le meilleur parti de ce cours si vous avez déjà travaillé avec des conteneurs et en avez créé quelques-uns simples. À la fin de ce cours, vous disposerez des connaissances et des outils nécessaires pour optimiser les applications conteneurisées, rationaliser la communication entre les conteneurs et déployer facilement des applications multi-conteneurs, ce qui vous permettra de progresser dans votre apprentissage de Docker.

Introduction to Docker

Maîtrisez les builds multi-étapes, les outils réseau Docker et Docker Compose pour des applications optimales !

Docker : niveau intermédiaire

Maîtrisez les multi-stage builds, les outils de mise en réseau Docker et Docker Compose pour optimiser vos applications conteneurisées.

Gâteau de couches

Docker : niveau intermédiaire

Exercice interactif pratique