introduction

Le didacticiel officiel de docker était assez organisé et facile à comprendre, alors je l'ai parcouru. Cependant, je pensais que les tutoriels avaient tendance à hésiter en anglais, alors je les ai traduits en japonais pour qu'il soit utile à quelqu'un. Puisque nous sommes dans un environnement Windows, nous l'expliquons dans l'interface utilisateur Windows.

supposition

・ Docker installé ・ Git installé

Démarrez le tutoriel

Si vous souhaitez démarrer le didacticiel à partir de l'état installé, cliquez sur l'icône du menu fixe et cliquez sur Apprendre pour démarrer le didacticiel. Avant l'installation, le didacticiel doit démarrer automatiquement lorsque l'installation est terminée.

L'écran suivant apparaîtra, alors démarrez-le.

clone Cloner le code du tutoriel

git clone https://github.com/docker/getting-started.git

Build

docker build -t docker101tutorial .

Utilisez cette commande build lors de la création d'une image Docker à partir de Dokerfile. -t tutoriel docker 101 spécifie le nom de balise de l'image Docker. «t» est un acronyme pour tag. . Indique que le Dockerfile est dans le répertoire courant. En résumé, la commande ci-dessus signifie créer une image Docker à partir du Dokerfile dans le répertoire courant avec le nom de balise docker101tutorial. L'image Docker est le répertoire qui contient les fichiers nécessaires à l'exécution de l'application et est la source du conteneur.

Run

docker run -d -p 80:80 --name docker-tutorial docker101tutorial

La commande run est une commande utilisée pour créer et démarrer un conteneur à partir d'une image Docker, et peut être créée et démarrée en même temps. Il existe également une commande pour créer docker create et une commande pour démarrer docker start, et créer puis démarrer a le même comportement que l'exécution. -d spécifie de démarrer en mode détaché, et si cela est spécifié, il peut être démarré en arrière-plan. Si vous commencez sans le spécifier, les informations seront envoyées au terminal et elles seront occupées, alors spécifiez-les si vous voulez éviter cela. La commande ci-dessus lance un conteneur nommé docker-tutorial à partir d'une image Docker nommée docker101tutorial. Si docker ne démarre pas à ce stade, essayez de changer le port côté hôte sur 8080.

1. 1. Commençons

Si vous accédez à localhost: 80 et que l'écran ci-dessous s'affiche, vous avez accès au conteneur du didacticiel. De là, je vais le traduire en japonais selon ce tutoriel. J'inclus également mes commentaires ici et là.

(Supplément) L'endroit décrit ainsi est mon commentaire (supplément).

À propos de la commande exécutée

J'expliquerai la commande suivante qui a créé et démarré le conteneur.

docker run -d -p 80:80 docker/getting-started

---d: Créer / démarrer le conteneur en arrière-plan ---p 80: 80: mapper le port 80 du côté hôte au port 80 du côté conteneur --docker / Getting-started: Image à utiliser

Cette commande peut être abrégée comme indiqué ci-dessous. docker run -dp 80:80 docker/getting-started

The Docker Dashboard Ici, je vais vous expliquer une fois sur Docker Dashboard. En démarrant Dashboard, vous pouvez vérifier le journal du conteneur et démarrer le shell à l'intérieur du conteneur. En plus de cela, vous pouvez l'ouvrir dans le navigateur, le redémarrer, le supprimer et effectuer diverses opérations de manière intuitive avec l'interface utilisateur.

Lorsque vous accédez au tableau de bord, l'écran suivant s'ouvre et vous pouvez confirmer que le conteneur est en cours d'exécution. "Jolly_bouman" sera un nom aléatoire, donc ce devrait être un nom différent.

Qu'est-ce qu'un conteneur?

Qu'est-ce qu'un conteneur? En termes simples, il s'agit d'un processus sur la machine hôte et sur une machine isolée des autres processus. Un processus est un programme exécuté sur une machine. L'isolation de processus utilise les espaces de noms et les fonctionnalités des groupes de contrôle de Linux.

Qu'est-ce qu'une image de conteneur?

Qu'est-ce qu'une image de conteneur? L'image est la source (modèle) du conteneur qui s'exécute dans l'environnement d'exécution. L'identité de l'image de conteneur est le répertoire contenant les fichiers nécessaires à l'exécution de l'application. Il contient des variables d'environnement, des commandes à exécuter par défaut et d'autres métadonnées.

2. application

L'application que vous exécutez dans ce didacticiel est une application todo qui s'exécute sur Node.js. Vous n'avez pas besoin d'être familier avec Node.js. Ici, nous allons préparer une application todo qui fonctionne au minimum. Suivez les étapes ci-dessous pour démarrer l'application et vérifier le fonctionnement.

Obtenez l'application

Téléchargez le code source à partir de http: // localhost: 80 / assets / app.zip.

(Supplément) Entrez l'adresse ci-dessus dans votre navigateur pour télécharger le code source. Modifiez le port en conséquence.

Décompressez le zip et vous verrez package.json et deux sous-répertoires (src et spec).

Créer une image de conteneur

Pour construire l'application, nous utiliserons Dockerfile ici. Dockerfile est un script basé sur du texte, comme des instructions pour générer une image de conteneur. Suivez les étapes ci-dessous pour créer une image Docker.

Créez un Dockerfile dans la même hiérarchie de répertoires que package.json et écrivez ce qui suit. Le dockerfile ne nécessite pas d'extension.

FROM node:12-alpine WORKDIR /app COPY . . RUN yarn install --production CMD ["node", "src/index.js"]

 2. Ouvrez un terminal, accédez au répertoire de l'application et exécutez la commande suivante.

    ```
docker build -t getting-started .

Utilisez cette commande pour générer une nouvelle image de conteneur à partir d'un Dockerfile. Si vous vérifiez le terminal après l'exécution, vous pouvez voir que de nombreuses "couches" sont téléchargées. C'est parce que nous avons utilisé l'image node: 12-alpie comme image de base et si vous n'avez pas cette image sur votre machine, vous devrez la télécharger. Lorsque le téléchargement est terminé, copiez-le dans votre application (COPY ..) et utilisez yarn pour installer les dépendances de l'application ( RUN yarn install --production). L'installation des dépendances est effectuée avec la commande RUN yarn install --production, qui installe autre chose que ceux listés dans devDependencies dans package.json dans l'application. Le package décrit dans devDependencies est un package requis au moment du développement et n'est pas requis dans la version de production (--production), donc --production est spécifié. CMD est une commande qui est exécutée par défaut lorsqu'un conteneur est démarré à partir d'une image de conteneur. Cela signifie que lorsque vous exécutez docker run XXXX, la commande node src / index.js sera exécutée. Le dernier . de la commande docker build signifie que le Dockerfile est dans le répertoire courant.

(Supplément) Par défaut, le docker recherche le nom Dockerfile, mais vous pouvez spécifier un alias avec -f. Si vous voulez le nommer Dockerfile.base, utilisez la commande suivante docker build -t sample -f Dockerfile.base .

Démarrez le conteneur

Maintenant que l'image est prête, utilisez la commande docker run pour exécuter l'application.

Spécifiez l'image et démarrez le conteneur avec la commande docker run.

docker run -dp 3000:3000 getting-started

 «-d» signifie démarrer le conteneur en arrière-plan, et «-p» mappe le port 3000 du côté hôte au port 3000 du côté du conteneur. Vous ne pourrez pas accéder à votre application sans ce mappage de port.
 2. Vous pouvez accéder à l'application en accédant à [http: // localhost: 3000](http: // localhost: 3000).
 3. Vous devriez voir l'élément ajouté comme prévu. Vous pouvez le marquer comme terminé et vous pouvez également supprimer l'élément ajouté.

 Nous allons apporter quelques modifications ici pour en savoir plus sur la gestion des conteneurs.


## 3. 3. Mise à jour de l'application
 Suivez les étapes ci-dessous pour mettre à jour votre application.

 1. Modifiez la 56ème ligne de `src / static / js / app.js` comme suit.
 ![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/187747/70f53862-a69a-61b5-9637-c9396aebf7c2.png)

 2. Créez la version mise à jour de l'image. Exécutez la commande suivante.
`docker build -t getting-started .`

 3. Lancez un nouveau conteneur avec le code mis à jour.
`docke run -dp 3000:3000 getting-started`

 Lorsque j'exécute ce code, je devrais voir une erreur similaire à la suivante:
`docker: Error response from daemon: driver failed programming external connectivity on endpoint laughing_burnell 
(bb242b2ca4d67eba76e79474fb36bb5125708ebdabd7f45c8eaf16caaabde9dd): Bind for 0.0.0.0:3000 failed: port is already allocated.`
 
 La cause de cette erreur est que l'ancien conteneur est toujours en cours d'exécution sur le port 3000. Un seul processus peut être occupé par un port côté hôte.
 La solution consiste à supprimer l'ancien conteneur.

### Remplacez l'ancien conteneur
 Premier arrêt pour supprimer le conteneur. Il ne peut pas être supprimé sans s'arrêter.
 Il existe deux façons de supprimer un ancien conteneur, alors supprimez-le comme vous le souhaitez.

#### Supprimer le conteneur (à l'aide de la CLI)
 1. Obtenez l'ID du conteneur avec la commande `docker ps`

    ```
docker ps

Utilisez docker stop pour arrêter le conteneur

Veuillez remplacer l'endroit par l'ID de conteneur obtenu par docker ps.

docker stop

 3. Supprimez le conteneur arrêté avec la commande `docker rm`

    ```
docker rm <the-container-id>

Vous pouvez utiliser les commandes ci-dessous pour arrêter et supprimer un conteneur avec une commande sur une seule ligne. docker rm -f <the-container-id>

Supprimer le conteneur (à l'aide du Docker Dashboard)

Avec le tableau de bord Docker, vous pouvez supprimer un conteneur en seulement deux clics. Vous pouvez supprimer un conteneur plus facilement et intuitivement qu'en utilisant la CLI.

Ouvrez le tableau de bord et passez la souris sur le conteneur que vous souhaitez supprimer et un bouton d'action apparaîtra sur la droite.
Cliquez sur l'icône de la corbeille pour supprimer le conteneur
Confirmez que le conteneur est parti

Démarrez l'application mise à jour

Lancez l'application mise à jour

docker run -dp 3000:3000 getting-started

 2. Accédez à [http: // localhost: 3000](http: // localhost: 3000) et assurez-vous que le texte est mis à jour
 ![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/187747/4a4315be-b138-73e3-400a-25384e698db6.png)


### (Résumé du chapitre 3)
 J'ai mis à jour l'application, mais je pense que vous avez remarqué les deux points suivants.

 1. Tous les éléments enregistrés au début ont disparu. Ce n'est pas bon pour une application de liste de tâches, nous en parlerons donc dans un chapitre ultérieur.
 2. Pour les petits changements, la mise à jour de l'application a nécessité de nombreuses étapes. Nous verrons dans un chapitre ultérieur comment reconstruire et ne pas avoir à démarrer un nouveau conteneur à chaque fois.

 Avant de parler de la manière dont les éléments sont conservés, examinons rapidement comment partager des images.

## 4. Partage d'application
 Maintenant que l'image est complète, partageons-la. Pour partager une image Docker, vous devez utiliser le référentiel Docker. Utilisons `Docker Hub`, qui contient toutes les images que nous utilisons.

### Créer un référentiel
 Créons un référentiel sur Docker Hub pour pousser l'image.

 1. Connectez-vous à [Docker Hub](https://hub.docker.com/)
 2. Cliquez sur ** Créer un référentiel **
 3. Nommez le référentiel «Getting-started». Assurez-vous également que la visibilité est «Public».
 4. Cliquez sur le bouton Créer

 En regardant à droite de la page, il y a une section ** Commandes Docker ** qui montre des exemples de commandes à exécuter pour pousser l'image.
 ![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/187747/21a8f219-b8c2-f416-1080-98b925628800.png)

### Poussée d'image
 1. Ouvrez la ligne de commande et entrez la commande push que vous venez de vérifier. À ce stade, remplacez `docker` par votre propre ID Docker.

    ```
$ docker push docker/getting-started
The push refers to repository [docker.io/docker/getting-started]
An image does not exist locally with the tag: docker/getting-started

J'ai échoué. La commande push aurait dû chercher une image nommée docker / getting-started, mais ne l'a pas trouvée. Essayez d'exécuter la commande docker image ls pour vérifier REPOSITORY. Il n'y a certainement pas d'image d'un tel nom. Pour résoudre ce problème, attribuez à l'image un alias avec "tag". 2. Connectez-vous à Docker Hub. docker login -u YOUR-USER-NAME (Entrez votre mot de passe après l'exécution) 3. Remplacez YOUR-USER-NAME par votre identifiant Docker.

```

docker tag getting-started YOUR-USER-NAME/getting-started

 4. Exécutez à nouveau la commande push. Si vous copiez la commande depuis Docker Hub, n'entrez aucun `nom de variable`. Si vous ne spécifiez pas de balise dans Docker, la balise `latest` est utilisée.

    ```
docker push YOUR-USER-NAME/getting-started

Lancer l'image dans une nouvelle instance

À ce stade, vous avez créé l'image et l'avez poussée dans le registre. Je souhaite lancer l'image poussée dans un tout nouvel environnement. Utilisons ici Play with Docker.

Ouvrez Play with Docker
Connectez-vous avec votre compte Docker Hub
Une fois connecté, cliquez sur «+ AJOUTER UNE NOUVELLE INSTANCE» dans la barre latérale gauche. (S'il ne s'affiche pas, essayez de réduire un peu la taille du navigateur.) Après un certain temps, l'écran suivant s'affiche sur le navigateur.
Lançons l'application que vous avez poussée plus tôt sur le terminal 　docker run -dp 3000:3000 YOUR-USER-NAME/getting-started
Lorsque vous le démarrez, un bouton intitulé «3000» s'affiche, cliquez dessus. Vous pouvez voir que l'application poussée vers Docker Hub a été lancée. Si vous n'avez pas de bouton, cliquez sur ** OPEN PORT ** et entrez 3000.

(Résumé du chapitre 4)

Ce chapitre a expliqué comment pousser l'image créée dans le registre et la partager. J'ai essayé de lancer une nouvelle application en utilisant l'image poussée en utilisant Play with Docker. C'est la même chose que ce qu'on appelle le pipeline CI, où vous pouvez créer et pousser des images pour obtenir les dernières images de votre environnement de production.

5. Persistance DB

Comme vous ne l'avez peut-être pas remarqué, l'application TODO perd des données chaque fois que vous démarrez un conteneur. Comprenons pourquoi cela se produit et comment fonctionne le conteneur.

Système de fichiers de conteneur

Le conteneur est lancé en utilisant différentes couches de l'image.

(Supplément) L'image docker est un état dans lequel les instructions de chaque fichier docker se chevauchent en tant qu'image, et ici il semble que ces états superposés soient exprimés sous forme de "calques". docker conserve chaque instruction de dockerfile en tant qu'image et utilise ces images pour démarrer le conteneur.

Chaque conteneur dispose de son propre «espace de travail» dans lequel les fichiers sont créés, mis à jour et supprimés. Aucun changement ne peut être vu à partir d'autres conteneurs, même pour la même image.

(Supplément) Espace à gratter: Imaginez un espace de mémoire isolé des autres processus ici.

Bougeons réellement votre main et vérifions

Pour confirmer ce qui précède, commençons deux conteneurs et éditons les fichiers dans chacun. Vous pouvez voir que les fichiers modifiés dans un conteneur ne sont pas disponibles dans l'autre conteneur.

Démarrez le conteneur ʻubuntu`. Ce conteneur génère un nombre aléatoire de 1 à 10000 dans /data.txt

docker run -d ubuntu bash -c "shuf -i 1-10000 -n 1 -o /data.txt && tail -f /dev/null"

 Cette commande lance le shell bash et appelle deux commandes (&& connecte les deux commandes). La première commande écrit un nombre aléatoire dans /data.txt. La deuxième commande surveille simplement le fichier pour maintenir le conteneur en cours d'exécution.
 > (Supplément)
 Essayez de supprimer la deuxième commande et && et exécutez, le conteneur démarré s'arrêtera immédiatement et vous ne pourrez pas voir les fichiers dans le conteneur.
 2. Vérifiez la valeur de sortie. Ouvrez Dashboard, passez la souris sur le conteneur exécutant l'image ʻubuntu` et cliquez sur le bouton le plus à gauche (CLI).
 ![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/187747/f61691f3-0d27-dca0-d433-65a7cee97cff.png)
 Une fois à l'intérieur du conteneur, exécutez la commande suivante pour vérifier le contenu de /data.txt.

    ```
cat /data.txt

Si vous souhaitez utiliser la ligne de commande, vous pouvez faire de même avec la commande docker exec. Après avoir obtenu l'ID du conteneur avec docker ps, exécutez la commande suivante.

```

docker exec cat /data.txt

 Vous pouvez voir que les nombres aléatoires sont affichés.
 3. Ensuite, commençons un autre conteneur en utilisant la même image ʻubuntu`. Ensuite, vous pouvez voir que /data.txt n'existe pas.

    ```
docker run -it ubuntu ls /

/data.txt n'existe pas car ce fichier a été écrit dans l'espace de travail du premier conteneur. 4. Utilisez la commande docker rm -f pour supprimer les conteneurs inutiles.

Volumes de conteneurs

Comme nous l'avons vu, un conteneur est celui qui démarre en fonction du contenu de l'image lors de son démarrage. Même si vous créez un conteneur et mettez à jour ou supprimez des fichiers, ces modifications seront perdues une fois le conteneur supprimé. Tous les changements sont indépendants pour chaque conteneur. Vous pouvez utiliser des volumes pour l'empêcher de disparaître.

Volumes vous permet de connecter un chemin de système de fichiers spécifique d'un conteneur à une machine hôte. Si le répertoire côté conteneur est monté, la modification peut également être confirmée côté machine hôte. Si vous montez le même répertoire lorsque vous démarrez le conteneur, vous pouvez vérifier le même fichier côté conteneur. En d'autres termes, les données ne seront pas perdues.

Il existe deux types de volumes. Tout d'abord, vérifions à partir des ** volumes nommés **.

Ne pas effacer les données TODO

Par défaut, les données d'application TODO sont stockées dans la base de données SQLite dans /etc/todos/todo.db. Vous n'avez pas besoin de vous familiariser avec SQLite. Il s'agit simplement d'une base de données de relations, où toutes les données sont stockées dans un seul fichier. Cette méthode ne convient pas aux grandes applications, mais elle fonctionne bien pour les petites applications comme cette application TODO. Plus tard, nous verrons comment passer à un autre moteur de base de données.

Si la base de données est un fichier unique, vous devriez pouvoir redémarrer le conteneur là où il s'était arrêté en conservant ce fichier du côté hôte et en le rendant disponible pour le nouveau conteneur suivant. En créant un volume et en attachant le volume au répertoire qui stocke les données (cela s'appelle «montage»), les données peuvent être utilisées en continu. Lorsque le conteneur écrit les données dans le fichier todo.db, les données sont stockées dans le volume côté hôte.

Comme je l'ai dit plus tôt, nous utiliserons ici ** volume nommé **. Vous pouvez considérer le volume nommé comme un simple compartiment de données. Lors de son utilisation, il suffit de se souvenir uniquement du nom du volume, vous n'avez pas besoin de savoir où se trouve la zone de stockage physique et Docker gère l'association entre le nom du volume et la zone de stockage. Chaque fois que vous utilisez le volume, Docker localise les données réelles.

Créez un volume à l'aide de la commande docker volume create.

docker volume create todo-db

 2. Supprimez l'application TODO qui n'utilise pas ces volumes nommés avec Dashboard. (Ou supprimez-le avec `docker rm -f <container-id>`)
 3. Ensuite, je vais démarrer le conteneur de l'application TODO, mais cette fois, spécifiez le montage du volume avec l'indicateur `-v`. Cela profitera du volume nommé et le montera dans `/ etc / todos`. Cela permet à tous les fichiers générés dans le chemin `/ etc / todos` d'être sauvegardés côté hôte.

    ```
docker run -dp 3000:3000 -v todo-db:/etc/todos getting-started

Après avoir lancé le conteneur, essayez d'ajouter des éléments.
Supprimez le conteneur d'application TODO. Utilisez Dashboard ou obtenez l'ID du conteneur avec docker ps, puis supprimez-le avec docker rm -f <id>.
Entrez à nouveau et exécutez la même commande que celle indiquée ci-dessus
Ouvrez l'application et vous devriez voir que vous avez l'élément que vous venez d'ajouter
Après confirmation, supprimez le conteneur comme précédemment.

Vous savez maintenant comment conserver les données.

(Supplément) Deux types de volumes, ** volumes nommés ** et ** montage de liaison **, sont disponibles en standard. La principale différence entre eux est l'emplacement de gestion des données côté hôte. Comme vu ci-dessus, les volumes nommés étaient OK si l'utilisateur ne connaissait que le nom du volume. En d'autres termes, c'est au docker de décider où stocker les données réelles. Ensuite, ** bind mount ** vous permet de spécifier quel répertoire côté hôte doit être monté sur quel répertoire côté conteneur. En d'autres termes, l'emplacement de gestion des données du côté hôte peut être sélectionné arbitrairement.

(Information) Astuce de pro les volumes nommés et les montages de liaison (expliqués dans le chapitre suivant) sont les deux principaux volumes pris en charge par défaut lorsque le moteur Docker est installé, mais ils prennent également en charge NFS, SFTP, NetApp et bien d'autres. Il existe un plug-in de pilote de volume. Il s'agit d'une technique particulièrement importante lors du lancement de conteneurs sur plusieurs hôtes dans un environnement de cluster tel que Swarm ou Kubernetes.

Vérifiez les détails du volume

Vous vous demandez peut-être: "Où sont les données stockées lors de l'utilisation d'un volume nommé?" Si vous voulez le savoir, vous pouvez le résoudre en exécutant la commande suivante.

docker volume inspect todo-db
[
    {
        "CreatedAt": "2019-09-26T02:18:36Z",
        "Driver": "local",
        "Labels": {},
        "Mountpoint": "/var/lib/docker/volumes/todo-db/_data",
        "Name": "todo-db",
        "Options": {},
        "Scope": "local"
    }
]

«Mountpoint» indique où les données sont réellement stockées. Sur de nombreuses machines, vous avez besoin de privilèges d'administrateur pour accéder à ce répertoire à partir de l'hôte, mais les données sont certainement là.

(Information) Pour accéder aux données de volume directement sur Docker Desktop Lorsque vous regardez le point de montage de todo-db ci-dessus, vous pouvez penser qu'il n'existe nulle part dans un tel répertoire. Lors du lancement de Docker Desktop, les commandes Docker sont en fait exécutées dans une petite machine virtuelle sur votre machine. Donc, si vous souhaitez voir les données dans le répertoire Mountpoint, vous devez vous connecter à l'intérieur de la machine virtuelle. Il existe de nombreuses façons de procéder lorsque vous recherchez sur Google.

(Résumé du chapitre 5)

J'ai pu créer une application qui conserve les données même si je supprime le conteneur et le redémarre. Cependant, comme nous l'avons vu dans le chapitre précédent, il faut un certain temps pour apporter des modifications à l'image et la reconstruire. Vous pouvez mieux créer votre application avec des montages de liaison. Dans le prochain chapitre, nous examinerons les montages liés.

6. Utiliser des montures de liaison

Dans le chapitre précédent, nous avons examiné comment conserver les données à l'aide de ** volume nommé **. ** volumes nommés ** est très utile si vous souhaitez simplement stocker les données car vous n'avez pas à vous soucier de l'emplacement de stockage des données réelles.

Vous pouvez utiliser ** bind mounts ** pour vous assurer de contrôler l'emplacement de votre hôte que vous souhaitez monter. Cela sert à peu près à contenir des données, mais il est également utilisé si vous souhaitez ajouter de nouvelles données au conteneur. Vous pouvez monter le code source côté conteneur lors du démarrage de l'application et utiliser des montages de liaison pour modifier le code source et vérifier l'opération en temps réel.

Les applications basées sur les nœuds ont un outil appelé nodemon qui surveille les modifications de fichiers et redémarre l'application lorsqu'elle change, d'autres langues et frameworks. Possède un outil équivalent.

Tableau de comparaison des types de volume

Les montages de liaison et les volumes nommés sont les principaux volumes qui peuvent être utilisés par défaut dans le moteur Docker, mais en plus de cela, d'autres cas d'utilisation (SFTP, Ceph, [NetApp](https://netappdvp.readthedocs.io/en/ Différents pilotes de volume sont disponibles pour supporter stable /), [S3](https: //github.com/elementar/docker-s3-volume), etc ...).

Démarrer le conteneur en mode de développement

Pour lancer un conteneur prenant en charge le workflow de développement, procédez comme suit:

--Monter le code source dans un conteneur --Installez toutes les dépendances (y compris les dépendances "dev")

Lancez nodemon pour surveiller les modifications de fichiers

Assurez-vous que le conteneur de démarrage n'est pas démarré
Exécutez la commande suivante. La signification de la commande sera expliquée plus loin

docker run -dp 3000:3000 \
    -w /app -v "$(pwd):/app" \
    node:12-alpine \
    sh -c "yarn install && yarn run dev"

Si vous utilisez PowerShell, veuillez utiliser la commande suivante.

docker run -dp 3000:3000 `
    -w /app -v "$(pwd):/app" `
    node:12-alpine `
    sh -c "yarn install && yarn run dev"

---dp 3000: 3000: Commencez par l'arrière-plan et mappez le port 3000 du côté hôte au port 3000 du côté du conteneur. ---w / app: Définition du répertoire de travail. Lorsque la commande est exécutée, le répertoire spécifié ici devient le répertoire courant. ---v "$ (pwd): / app" : monte le répertoire courant côté hôte et le répertoire / app côté conteneur. --node: 12-plpine: Image à utiliser. Notez qu'il s'agit d'une image basée sur une application provenant du Dockerfile. --sh -c "yarn install && yarn run dev: Démarrez le shell en utilisant sh (il n'y a pas de bash en alpin), puis faites yarn install pour installer toutes les dépendances et Exécutez yarn run dev. Comme vous pouvez le voir en regardant package.json, l'exécution du script dev démarre nodemon.

1. Vérifiez les journaux en utilisant docker logs -f <container-id>. Si l'écran ressemble à celui ci-dessous, vous êtes prêt à commencer.

docker logs -f <container-id>
$ nodemon src/index.js
[nodemon] 1.19.2
[nodemon] to restart at any time, enter `rs`
[nodemon] watching dir(s): *.*
[nodemon] starting `node src/index.js`
Using sqlite database at /etc/todos/todo.db
Listening on port 3000

Si vous pouvez vérifier le journal, appuyez sur «Ctrl» + «C» pour quitter.

Modifions maintenant l'application. Changez la ligne 109 de src / static / js / app.js comme suit.
Actualisez (ou ouvrez) la page pour voir les modifications prendre effet immédiatement. Le redémarrage du serveur Node prend quelques secondes. Si vous obtenez une erreur, essayez d'actualiser.
N'hésitez pas à apporter des modifications. Lorsque vous êtes satisfait, arrêtez le conteneur et construisez une nouvelle image avec docker build -t getting-started ..

Les montures de liaison sont souvent utilisées pour créer un environnement de développement local. L'avantage est que la machine de développement ne nécessite pas d'outils de construction. Simplement «docker run» et l'environnement de développement sera extrait et prêt. Nous parlerons de Docker Compose dans le futur, ce qui peut simplifier la commande.

(Résumé du chapitre 6)

Nous avons vu comment conserver la base de données et répondre plus rapidement à vos besoins et demandes. Pour vous préparer à l'environnement de production, vous devez déplacer votre base de données de SQLite vers quelque chose qui peut être mis à l'échelle plus facilement. Pour simplifier les choses, nous allons utiliser une base de données relationnelle ici et la mettre à jour pour utiliser MySQL dans nos applications. Nous verrons comment les conteneurs permettent la communication entre eux à partir du chapitre suivant.

sept. Application multi-conteneurs

Jusqu'à présent, nous avons traité des applications à conteneur unique, mais nous aimerions ensuite ajouter MySQL à l'application TODO. Vous pouvez avoir des questions telles que «Où commencez-vous MySQL?» «Installer dans le même conteneur ou démarrer indépendamment?» En général, une chose doit être faite dans chaque conteneur. La raison en est la suivante.

――Il est tout à fait possible que vous souhaitiez mettre à l'échelle l'API et le front-end quelle que soit la base de données.

En rendant chaque conteneur indépendant, vous pouvez effectuer les mises à jour et la gestion des versions indépendamment. --Il convient lorsque vous n'avez pas besoin de créer une base de données dans votre application et que vous souhaitez utiliser un service géré pour une base de données de production.
Un gestionnaire de processus distinct est nécessaire pour démarrer plusieurs processus (un conteneur ne peut démarrer qu'un seul processus). Cela complique le démarrage et l'arrêt.

Il existe de nombreuses autres raisons. Alors ici, configurons l'application comme suit.

Réseau de conteneurs

Par défaut, les conteneurs s'exécutent indépendamment des autres processus et ne peuvent pas être connectés à d'autres conteneurs / processus, même sur la même machine. Comment puis-je connecter un conteneur à un autre conteneur? La réponse est ** le réseautage **. Vous n'avez pas besoin d'avoir les mêmes connaissances qu'un ingénieur réseau, rappelez-vous simplement ce qui suit.

Si deux conteneurs sont sur le même réseau, ils peuvent se connecter l'un à l'autre

Lancez MySql

Il existe deux façons de placer le conteneur sur le réseau. 1) Placez le réseau au démarrage 2) Connectez-vous au conteneur démarré. Ici, nous créons d'abord un réseau et l'attachons au démarrage du conteneur MySQL.

Créez un réseau

docker network create todo-app

 2. Démarrez MySQL et connectez le réseau. Certaines variables d'environnement sont définies pour initialiser la base de données. (Si vous souhaitez en savoir plus, veuillez consulter [Liste MuSQL Docker Hub](https://hub.docker.com/_/mysql/).)

    ```
docker run -d \
    --network todo-app --network-alias mysql \
    -v todo-mysql-data:/var/lib/mysql \
    -e MYSQL_ROOT_PASSWORD=secret \
    -e MYSQL_DATABASE=todos \
    mysql:5.7

Si vous utilisez PowerShell, veuillez utiliser la commande suivante.

```

docker run -d --network todo-app --network-alias mysql -v todo-mysql-data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=secret -e MYSQL_DATABASE=todos ` mysql:5.7

 Vous pouvez voir qu'il existe un indicateur `--network-alias` en plus des variables d'environnement pour l'initialisation de la base de données. Nous en reparlerons plus tard.

    > (Pro-tip)
 Dans la commande ci-dessus, le volume nommé `todo-mysql-data` est utilisé pour le monter dans / var / lib / mysql, qui est la destination de stockage des données de MYSQL. Cependant, je n'ai pas créé le volume en exécutant la commande `docker volume create`. Docker créera automatiquement un nouveau nom de volume nommé si spécifié.

 3. Connectons-nous pour nous assurer que la base de données fonctionne

    ```
docker exec -it <mysql-container-id> mysql -p

Il vous sera demandé un mot de passe, alors entrez «secret». Vérifiez la base de données todos lorsque vous entrez dans le shell MySQL.

```

mysql>　SHOW DATABASES;

 Vous devriez obtenir une sortie similaire à ce qui suit:

    ```
+--------------------+
| Database           |
+--------------------+
| information_schema |
| mysql              |
| performance_schema |
| sys                |
| todos              |
+--------------------+
5 rows in set (0.00 sec)

Vous savez que la base de données todo est prête.

Connectez-vous à MySQL

Maintenant que nous avons confirmé que MySQL fonctionne, utilisons-le. Juste comment ...? Si vous avez un autre conteneur fonctionnant sur le même réseau, comment trouvez-vous ce conteneur (même si je me souviens que chaque conteneur a une adresse IP)?

Pour comprendre cela, utilisez le conteneur nicolaka / netshoot. Ce conteneur dispose d'un ensemble d'outils utiles installés pour le dépannage et le débogage du réseau.

Démarrez un nouveau conteneur avec l'image nicolaka / netshoot. N'oubliez pas de vous connecter au même réseau.

docker run -it --network todo-app nicolaka/netshoot

 2. Exécutez la commande `dig` car elle entrera dans le conteneur lorsque vous tapez la commande ci-dessus (cette commande est un outil DNS pratique). Vérifiez l'adresse IP du nom d'hôte `mysql`.

    ```
dig mysql

Vous obtiendrez la sortie suivante:

```

; <<>> DiG 9.14.1 <<>> mysql ;; global options: +cmd ;; Got answer: ;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 32162 ;; flags: qr rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 0, ADDITIONAL: 0 ;; QUESTION SECTION: ;mysql. IN A ;; ANSWER SECTION: mysql. 600 IN A 172.23.0.2 ;; Query time: 0 msec ;; SERVER: 127.0.0.11#53(127.0.0.11) ;; WHEN: Tue Oct 01 23:47:24 UTC 2019 ;; MSG SIZE rcvd: 44


 Si vous regardez "ANSWER SECTION", vous pouvez voir l'enregistrement ʻA` du nom d'hôte` mysql` résolu en l'adresse IP 172.23.0.2 (l'adresse IP dépend de l'environnement). Normalement, `mysql` n'est pas un nom d'hôte valide, mais Docker peut résoudre l'adresse IP d'un conteneur avec un alias réseau (souvenez-vous de l'indicateur` --network-alias`, n'est-ce pas?).
 Cela signifie que vous pouvez vous connecter à la base de données simplement en vous connectant au nom d'hôte `mysql` depuis l'application TODO. Ce n'est jamais aussi simple!

### Connectez l'application TODO à MySQL et lancez-la
 L'application TODO prend en charge la définition de certaines variables d'environnement pour les connexions MySQL. Les quatre suivants.

 --`MYSQL_HOST`: Le nom de l'hôte exécutant le serveur MySQL
 --`MYSQL_USER`: Nom d'utilisateur utilisé pour la connexion
 --`MYSQL_PASSWORD`: Mot de passe utilisé pour la connexion
 --`MYSQL_DB`: nom de la base de données à utiliser

 > Attention!
 L'utilisation de variables d'environnement pour configurer des connexions convient dans un environnement de développement, mais ce n'est certainement pas recommandé lors de l'exécution d'applications dans un environnement de production. L'ancien responsable de la sécurité de Docker, Diogo Monica, explique pourquoi [excellent article de blog](https://diogomonica.com/2017/03/27/why-you-shouldnt-use-env-variables-for-secret-data/ ).

 Maintenant, commençons le conteneur d'environnement de développement.

 1. Connectez le conteneur MySQL au réseau d'applications TODO en spécifiant les variables d'environnement ci-dessus.

    ```
docker run -dp 3000:3000 \
  -w /app -v "$(pwd):/app" \
  --network todo-app \
  -e MYSQL_HOST=mysql \
  -e MYSQL_USER=root \
  -e MYSQL_PASSWORD=secret \
  -e MYSQL_DB=todos \
  node:12-alpine \
  sh -c "yarn install && yarn run dev"

Si vous utilisez PowerShell, utilisez la commande suivante.

```

docker run -dp 3000:3000 -w /app -v "$(pwd):/app" --network todo-app -e MYSQL_HOST=mysql -e MYSQL_USER=root -e MYSQL_PASSWORD=secret -e MYSQL_DB=todos node:12-alpine sh -c "yarn install && yarn run dev"

 2. Si vous vérifiez les journaux du conteneur avec la commande `docker logs <container-id>`, vous pouvez voir qu'il existe une déclaration indiquant que vous utilisez la base de données mysql.

    ```
# Previous log messages omitted
$ nodemon src/index.js
[nodemon] 1.19.2
[nodemon] to restart at any time, enter `rs`
[nodemon] watching dir(s): *.*
[nodemon] starting `node src/index.js`
Connected to mysql db at host mysql
Listening on port 3000
```　
 3. Ouvrez l'application TODO dans votre navigateur et essayez d'ajouter des éléments.
 4. Essayez de vous connecter à la base de données mysql et assurez-vous que les éléments que vous avez ajoutés sont définitivement ajoutés à la base de données. Le mot de passe est ** secret **.

    ```
docker exec -ti <mysql-container-id> mysql -p todos

Après avoir entré le shell mysql, exécutez la commande suivante.

```

mysql> select * from todo_items; +--------------------------------------+--------------------+-----------+ | id | name | completed | +--------------------------------------+--------------------+-----------+ | c906ff08-60e6-44e6-8f49-ed56a0853e85 | Do amazing things! | 0 | | 2912a79e-8486-4bc3-a4c5-460793a575ab | Be awesome! | 0 | +--------------------------------------+--------------------+-----------+

 Le nom change en fonction de l'élément ajouté, mais j'ai pu confirmer qu'il était certainement enregistré.

 Consultez le tableau de bord Docker. Vous pouvez voir que les deux conteneurs sont en cours d'exécution, mais ils ne sont pas regroupés dans une seule application. Chaque conteneur est lancé indépendamment, mais l'application TODO est connectée au conteneur mysql.

### (Résumé du chapitre 7)
 J'ai enregistré les données de l'application TODO dans un conteneur mysql externe séparé. Ensuite, apprenez-en un peu plus sur la mise en réseau des conteneurs, [Service Discovery](https://ja.wikipedia.org/wiki/%E3%82%B5%E3%83%BC%E3%83%93%E3%82%B9 Utilisez DNS pour voir comment% E3% 83% 87% E3% 82% A3% E3% 82% B9% E3% 82% AB% E3% 83% 90% E3% 83% AA) est implémenté Je l'ai confirmé.

 Cependant, j'étais un peu dépassé car je devais créer un réseau, démarrer un conteneur, spécifier des variables d'environnement, ouvrir des ports et faire beaucoup d'autres choses simplement pour démarrer une application. Cela peut avoir été. Je ne me souviens pas de tant de choses et c'est difficile de le dire à quelqu'un.
 Le chapitre suivant décrit Docker Compose. Avec Docker Compose, vous pouvez partager votre application avec d'autres personnes de manière beaucoup plus simple et vous pourrez lancer les applications couvertes dans ce chapitre avec des commandes simples.

## 8. Utiliser Docker Compose
 [Docker Compose](https://docs.docker.com/compose/) est un outil développé pour vous aider à définir et partager des applications multi-conteneurs. Avec Docker Compose, vous pouvez définir un service dans un fichier YAML et démarrer ou détruire le service avec une seule commande.
 L'avantage d'utiliser Docker Compose est que vous pouvez définir votre application dans un seul fichier (placer le fichier dans la direction racine de votre projet) et permettre à quelqu'un d'autre de rejoindre facilement votre projet. Si vous souhaitez rejoindre le projet, il vous suffit de cloner le référentiel et de lancer l'application avec la commande Docker Compose. De nombreux projets l'utilisent sur Github et GitLab.

### Installez Docker Compose
 Si Docker Desktop / Toolbox est installé sur votre Windows ou Mac, Docker Compose est déjà installé. Docker Compose est également déjà installé pour Play-with-Docker. Si vous utilisez Linux, suivez les étapes ici (https://docs.docker.com/compose/install/) pour installer.

 Après l'installation, vous pouvez vérifier les informations de version avec la commande suivante.

docker-compose version


### Créer un fichier Docker Compose

 1. Créez un fichier `docker-compose.yml` (fichier de composition) dans le répertoire racine de votre projet
 2. Tout d'abord, écrivez la version du schéma dans le fichier de composition. Dans la plupart des cas, il est préférable d'utiliser la dernière version. La référence du fichier Compose (https://docs.docker.com/compose/compose-file/) contient la version actuelle du schéma et la table de compatibilité.

    ```
version: 3.7

Ensuite, définissez la liste des services (ou conteneurs) que vous souhaitez démarrer en tant qu'application.

version: "3.7" services:

 Ensuite, je vais expliquer le service de composition de fichiers.

### Définir le service de l'application
 Rappelez-vous la commande ci-dessous qui a été utilisée pour définir le conteneur de l'application.

docker run -dp 3000:3000
-w /app -v "$(pwd):/app"
--network todo-app
-e MYSQL_HOST=mysql
-e MYSQL_USER=root
-e MYSQL_PASSWORD=secret
-e MYSQL_DB=todos
node:12-alpine
sh -c "yarn install && yarn run dev"

 Si vous utilisez PowerShell, c'était la commande suivante.


 1. Commençons par enregistrer le service et définir l'image du conteneur. Vous pouvez définir le nom du service à votre guise, et ce nom deviendra automatiquement un alias pour votre réseau. Cet alias est utile pour définir les services MySQL.

    ```
version: "3.7"
services:
  app:
    image: node:12-alpine

Normalement, la commande est placée près de la définition de ʻimage`, mais il n'y a aucune restriction sur l'ordre.

version: "3.7" services: app: image: node:12-alpine command: sh -c "yarn install && yarn run dev"

 3. Ensuite, jetons un œil à la commande `-p 3000 3000` définie dans` ports`. La description ici est [syntaxe courte](https://docs.docker.com/compose/compose-file/#short-syntax-1), qui est plus détaillée [syntaxe longue](https: //). Il existe également une variable docs.docker.com/compose/compose-file/#long-syntax-1).

    ```
version: "3.7"
services:
  app:
    image: node:12-alpine
    command: sh -c "yarn install && yarn run dev"
    ports:
      - 3000:3000

Vient ensuite le répertoire de travail (-w / app) défini par working_dir et le mappage de volume (-v "$ (pwd): / app") défini par volumes. Également sur le volume, Short et Long / # long-syntax-3) Il existe une syntaxe.

version: "3.7" services: app: image: node:12-alpine command: sh -c "yarn install && yarn run dev" ports: - 3000:3000 working_dir: /app volumes: - ./:/app


 5. Le dernier est ʻenvironment`, qui définit les variables d'environnement.

    ```
version: "3.7"
services:
  app:
    image: node:12-alpine
    command: sh -c "yarn install && yarn run dev"
    ports:
      - 3000:3000
    working_dir: /app
    volumes:
      - ./:/app
    environment:
      MYSQL_HOST: mysql
      MYSQL_USER: root
      MYSQL_PASSWORD: secret
      MYSQL_DB: todos

Définition du service MySQL

Définissons le service MySQL. Lorsque j'ai créé le conteneur, j'ai utilisé la commande suivante.

docker run -d \
  --network todo-app --network-alias mysql \
  -v todo-mysql-data:/var/lib/mysql \
  -e MYSQL_ROOT_PASSWORD=secret \
  -e MYSQL_DATABASE=todos \
  mysql:5.7

Dans le cas de PowerShell, c'est comme suit.

docker run -d `
  --network todo-app --network-alias mysql `
  -v todo-mysql-data:/var/lib/mysql `
  -e MYSQL_ROOT_PASSWORD=secret `
  -e MYSQL_DATABASE=todos `
  mysql:5.7

Tout d'abord, définissons un nouveau service avec le nom mysql. A ce moment, mysql devient automatiquement un alias réseau. Spécifions l'image comme lors de la définition de l'application.

version: "3.7" services: app: # The app service definition mysql: image: mysql:5.7

 2. Vient ensuite la définition du mappage de volume. Le volume nommé est créé automatiquement lorsque vous démarrez le conteneur avec la commande `docker run`. Cependant, dans le cas de `docker compose`, il n'est pas créé automatiquement. Vous devez définir `volumes:` et spécifier le point de montage. Spécifiez simplement le nom du volume et les options par défaut seront utilisées. Il existe également de nombreuses options (https://docs.docker.com/compose/compose-file/#volume-configuration-reference).

    ```
version: "3.7"
services:
  app:
    # The app service definition
  mysql:
    image: mysql:5.7
    volumes:
      - todo-mysql-data:/var/lib/mysql
volumes:
  todo-mysql-data:

Enfin, spécifiez les variables d'environnement.

version: "3.7" services: app: # The app service definition mysql: image: mysql:5.7 volumes: - todo-mysql-data:/var/lib/mysql environment: MYSQL_ROOT_PASSWORD: secret MYSQL_DATABASE: todos volumes: todo-mysql-data:

 Pour résumer ce qui précède, `docker-compose.yml` est le suivant.

    ```
version: "3.7"
services:
  app:
    image: node:12-alpine
    command: sh -c "yarn install && yarn run dev"
    ports:
      - 3000:3000
    working_dir: /app
    volumes:
      - ./:/app
    environment:
      MYSQL_HOST: mysql
      MYSQL_USER: root
      MYSQL_PASSWORD: secret
      MYSQL_DB: todos
  mysql:
    image: mysql:5.7
    volumes:
      - todo-mysql-data:/var/lib/mysql
    environment: 
      MYSQL_ROOT_PASSWORD: secret
      MYSQL_DATABASE: todos
volumes:
  todo-mysql-data:

Commençons l'application

Maintenant que vous avez créé docker-compose.yml, commençons l'application.

Assurez-vous qu'aucune autre application ou copie de la base de données n'est en cours d'exécution. (Vérifiez l'id avec docker ps et supprimez-le avec rm if <ids>)
Démarrez l'application à l'aide de la commande docker compose up. À ce stade, ajoutez l'indicateur -d pour le démarrer en arrière-plan.

docker-compose up -d

 Vous obtiendrez la sortie suivante.

    ```
Creating network "app_default" with the default driver
Creating volume "app_todo-mysql-data" with default driver
Creating app_app_1   ... done
Creating app_mysql_1 ... done

Vous pouvez voir que le volume est créé ainsi que le réseau. Docker Compose crée automatiquement le réseau par défaut. Je n'ai donc pas défini la création de réseau dans docker-compose.yml. 3. Vérifiez les journaux avec la commande docker-compose logs -f. Vous pouvez voir que le journal est sorti sur une ligne pour chaque service. Ce journal est utile lorsque vous souhaitez surveiller les problèmes liés au temps. L'indicateur -f consiste à" suivre "le journal afin qu'il soit imprimé immédiatement lorsque le journal est généré.

```

mysql_1 | 2019-10-03T03:07:16.083639Z 0 [Note] mysqld: ready for connections. mysql_1 | Version: '5.7.27' socket: '/var/run/mysqld/mysqld.sock' port: 3306 MySQL Community Server (GPL) app_1 | Connected to mysql db at host mysql app_1 | Listening on port 3000

 Le nom du service est répertorié au début pour distinguer les messages de chaque service. Si vous souhaitez enregistrer uniquement un service spécifique, ajoutez le nom du service à la fin, par exemple, avec la commande `docker-comopse log -f app`.
 > (Informations utiles) Attendez DB jusqu'au démarrage de l'application
 Lorsque l'application est en cours d'exécution, l'application attend que MySQL démarre et soit prête avant de démarrer la connexion. Docker n'a pas de prise en charge intégrée pour attendre qu'un autre conteneur démarre complètement et soit prêt avant de démarrer un autre conteneur. Pour les projets basés sur des nœuds, vous pouvez tirer parti de la dépendance wait-port. Des projets similaires existent dans d'autres langages et frameworks.
 4. À ce stade, vous pouvez voir que l'application est en cours d'exécution. Vous pouvez voir qu'il peut être exécuté avec une seule commande!

### Vérifiez l'application sur le tableau de bord Docker
 Si vous ouvrez le tableau de bord Docker, vous pouvez voir ce qui est regroupé sous le nom ** app **. Il s'agit du nom de projet attribué par Docker Compose, qui combine plusieurs conteneurs en un seul. Le nom du projet est par défaut le nom du répertoire où se trouve `docker-compose.yml`.
 ![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/187747/1a051b66-4da8-6c24-a001-0e5437544cee.png)

 Si vous développez l'application, vous pouvez voir les deux conteneurs définis dans le fichier de composition. Chaque nom est écrit de manière facile à comprendre et est au format `<nom du projet> _ <nom du service> _ <numéro de réplique>`, donc quel est le conteneur de l'application et quelle est la base de données de mysql Vous pouvez le dire en un coup d'œil.
 ![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/187747/2cebbc84-3cdf-105b-2b23-062c630f95a4.png)

### Arrêter et supprimer le conteneur
 Si vous souhaitez arrêter et supprimer le conteneur, utilisez la commande `docker-compose down` ou cliquez sur l'icône de la corbeille dans le Docker Dashboard. Le conteneur sera arrêté et le réseau sera supprimé.

 > Supprimer le volume
 Par défaut, le volume nommé n'est ** pas supprimé ** lorsqu'il est arrêté avec la commande `docker-compose down`. Si vous souhaitez le supprimer, vous devez ajouter l'indicateur `--volumes`.
 Le volume nommé n'est pas supprimé même s'il est supprimé par Docker Dashboard.

 Une fois arrêté et supprimé, vous pouvez démarrer un autre projet avec `docker-compose up`.

### (Résumé du chapitre 8)
 Dans cette section, vous avez découvert Docker Compose et vous avez trouvé qu'il était considérablement plus facile de définir et de partager des applications multiservices. J'ai également créé un fichier de composition en écrivant des commandes selon le format de composition approprié.

 C'est la fin du tutoriel. Cependant, les fichiers Dockerfiles que j'ai utilisés jusqu'à présent ont des problèmes majeurs, je décrirai donc les meilleures pratiques pour la création d'images dans les chapitres suivants pour en savoir plus.



 Pour le moment, c'est tout.
 J'ajouterai les prochains chapitres 9 et 10 au besoin.

 Chapitre 9: Meilleures pratiques de création d'image
 Chapitre 10: Que faire ensuite

[Introduction à Docker] Tutoriel officiel (traduction en japonais)