Tout ce que vous devez savoir sur l'utilisation de Docker Compose

Si vous vous demandez comment créer des conteneurs Docker reproductibles avec Docker Compose, vous êtes au bon endroit. Dans ce didacticiel étape par étape sur Docker Compose, vous allez apprendre à créer des conteneurs simples, à mapper des ports avec Docker Compose jusqu'à des scénarios complexes à plusieurs conteneurs.

Es-tu prêt? Creusons !

Prérequis

Si vous souhaitez suivre étape par étape, dans ce didacticiel, assurez-vous d'avoir les éléments suivants :

Une nouvelle installation d'Ubuntu Server LTS avec SSH activé . Ce guide utilisera Ubuntu Server LTS 20.04.1 comme machine hôte Docker.
Un ordinateur avec code VS installé (facultatif). Ce guide utilisera Visual Studio Code 1.52.1 pour SSH sur l'hôte Docker et exécutera des commandes.
L'extension SSH officielle de VS Code installée et connecté à l'hôte Docker. (facultatif)

Qu'est-ce que Docker Compose ?

Les commandes simples peuvent devenir longues, très longues dans Docker. Prenez ce qui suit comme exemple. Cet exemple crée un conteneur pour une application logicielle appelée Bookstack.

docker create \
   --name=bookstack \
   -e PUID # UID of user to take ownership of application/files \
   -e PGID # GID of user to take ownership of application/files \
   -e DB_USER # The database user \
   -e DB_PASS # The database password \
   -e DB_HOST # The database host \
   -e DB_DATABASE # The database to be used \
   -e APP_URL # The url your application will be accessed on (required for correct operation of reverse proxy) \
   -v /host/path/to/config:/config # Location of any uploaded data \
   -p 80:80/tcp # Web UI port \
   --restart unless-stopped \
   linuxserver/bookstack:version-v0.31.4

À mesure que la complexité d'un environnement Docker augmente, le nombre d'indicateurs et de conditions requis pour une configuration de conteneur de travail augmente également. La ligne de commande Docker commence à devenir lourde et difficile à dépanner ; surtout une fois que les configurations multi-conteneurs commencent à entrer dans le mix.

Docker Compose est un moyen de créer des conteneurs Docker reproductibles à l'aide d'un fichier de configuration au lieu de commandes Docker extrêmement longues. En utilisant un fichier de configuration structuré, les erreurs sont plus faciles à détecter et les interactions avec les conteneurs sont plus faciles à définir.

Docker Compose devient rapidement inestimable lorsqu'il s'agit de gérer des dépendances de conteneurs ou des environnements multi-conteneurs.

Docker Compose est un moyen fantastique d'entrer dans l'infrastructure en tant que code sans la complexité des systèmes distribués comme Kubernetes.

Docker Compose utilise une structure de fichier de configuration appelée YAML . YAML est similaire à JSON ou HTML en ce sens que YAML est un langage structuré et lisible par machine. YAML vise spécifiquement à être aussi lisible que possible par l'homme tout en conservant ce pouvoir structuré.

YAML a un inconvénient où les onglets et autres espaces blancs sont importants et doivent être formatés correctement. VS Code fait une grande partie de ce travail acharné pour vous et c'est aussi pourquoi vous verrez de nombreux exemples réalisés dans VS Code.

Installer Docker Compose

Commençons maintenant à nous salir les mains. En supposant que vous êtes connecté à votre hôte Docker, il est temps d'installer Docker Compose.

Docker Compose est un package distinct de l'environnement d'exécution Docker. Mais l'installation de Docker Compose installera également le runtime Docker afin que vous fassiez d'une pierre deux coups !

Pour installer Docker Compose et l'environnement d'exécution Docker, exécutez les deux commandes suivantes.

# update the software list (known as a repository) and then install docker compose
# with any needed dependencies. the -y flag is used to skip confirmation
sudo apt update -y
sudo apt install docker-compose -y

Une fois installé, vous devez maintenant créer une structure de dossiers pour stocker les conteneurs.

Création d'une structure de dossiers pour Docker Compose

Avant de pouvoir créer un conteneur avec Docker Compose, vous devez d'abord créer un dossier pour stocker les conteneurs. Vous ne devez pas seulement créer une structure de dossiers pour stocker les conteneurs, mais vous constaterez que diverses commandes Docker sont sensibles à l'emplacement de divers fichiers de configuration ; Docker Compose n'est pas différent.

Le composant le plus important de Docker Compose est son fichier de configuration appelé docker-compose.yaml . Ce fichier de configuration, comme expliqué ci-dessus, dicte comment le runtime Docker doit créer un conteneur.

Lorsque vous exécutez Docker Compose, la commande recherche son fichier de configuration dans le même dossier que celui où la commande est exécutée. En raison de cette exigence, il est toujours préférable de créer un dossier séparé lors de l'exécution de Docker Compose.

Il ne peut y avoir qu'un seul fichier de configuration Docker Compose par dossier.

Pour démontrer la création d'un conteneur Docker avec Docker Compose, créez d'abord une structure de dossiers pour stocker le futur conteneur et son fichier de configuration à l'aide d'un petit serveur de fichiers appelé Caddy.

Caddy est un serveur de fichiers, similaire à apache httpd ou nginx , mais écrit en langage Go. Caddy est spécialement conçu pour être facile à utiliser (et générera ou servira automatiquement un fichier index.html) sans configuration. Cette combinaison fait du caddie un bon choix pour les débutants.

En supposant que vous êtes connecté à votre hôte Docker, créez la structure de dossiers comme suit :

Dans votre répertoire personnel, créez un dossier appelé containers . Ce dossier sera un bon espace réservé pour ce conteneur et d'autres.
À l'intérieur des conteneurs dossier, créez un sous-dossier appelé caddy . Ce dossier contiendra le fichier de configuration Docker Compose et le conteneur Caddy lui-même.
Enfin, à l'intérieur du dossier conteneur, caddy, créez un fichier texte vide appelé docker-compose.yaml qui deviendra le fichier de configuration de Docker Compose.

Une fois la structure de dossiers et le fichier de configuration Docker Compose créés, vous pouvez maintenant commencer à remplir ce fichier de configuration avec une configuration Docker Compose.

Création d'un fichier de configuration Docker Compose

Dans sa forme la plus basique, un docker-compose.yaml fichier pour le conteneur de caddie ressemble à ce qui suit. Dans votre éditeur de texte Linux préféré ou avec VS Code, copiez et collez le code ci-dessous dans le fichier de configuration Docker Compose créé précédemment.

version: "3.7"
services:
  caddy:
    container_name: "caddy"
    image: "caddy:latest"
    ports:
      - "80:80"

Passons en revue chacune des options affichées :

version spécifie la version du fichier docker-compose. Chaque nouvelle définition de Docker Compose inclut des modifications radicales de la spécification. Par conséquent, la version est importante pour que Docker Compose puisse indiquer les fonctionnalités qu'il doit utiliser. La version 3.7 est la dernière version prise en charge par Ubuntu 20.04.1 LTS.

La spécification complète de Docker Compose 3.x est disponible ici. La documentation liée mentionne chaque option que vous pouvez utiliser dans Docker Compose

services contiennent les spécifications des conteneurs réels. Vous pouvez définir plusieurs conteneurs dans cette section.
caddy est le nom du premier conteneur (c'est purement pour référence).
container_name définit le nom réel donné au conteneur par Docker et doit être unique.
image est le nom de l'image. Dans ce cas, caddie depuis le Docker Hub est défini. Le nom ou le numéro après la balise, séparés par deux-points, correspond à la version.

Mappage des ports

Cette dernière option en particulier nécessite une mention spéciale :

ports:
  - "80:80"

Dans Docker Compose, les ports La directive vous permet de définir un ou plusieurs mappages de l'hôte vers le conteneur. Par exemple, ci-dessus, vous avez mappé le port 80 sur l'hôte au port 80 sur le conteneur. Cependant, vous n'avez pas besoin de faire correspondre le numéro de port. L'exemple ci-dessous mappe le port 8800 sur l'hôte au port 80 dans le conteneur.

ports:
  - "8800:80"

Vous pouvez également définir plusieurs ports comme ci-dessous.

ports:
  - "80:80"
  - "443:443"

Cela mapperait les deux ports 80 et 443 à l'hôte (une configuration courante pour les serveurs Web, pour servir à la fois HTTP et HTTPS).

Le créateur d'image Docker définit les ports disponibles au moment de la création. Assurez-vous de vérifier la documentation de l'image avec laquelle vous travaillez sur Docker Hub ou le site Web du responsable pour les ports mappables. Il est inutile de mapper un port si le port n'est pas utilisé !

Gardant cela à l'esprit, examinons l'exécution réelle du conteneur.

Exécuter le conteneur

Vous devriez maintenant avoir le docker-compose.yaml fichier à l'intérieur de votre ~\containers\caddy dossier. Il est maintenant temps de créer et de démarrer le conteneur Caddy.

Sur votre terminal, exécutez la commande suivante qui fera apparaître les conteneurs Docker définis dans le docker-compose.yaml fichier.

# This command must be run in the same folder as the file. The -d flag runs
# the command *detached*, which will bring up the container in the background
sudo docker-compose up -d

Vous remarquerez peut-être que vous n'avez pas eu à spécifier l'emplacement du fichier docker-compose.yaml lors de l'exécution de sudo docker-compose up -d . Docker Compose s'attend à ce que vous exécutiez toutes les commandes du dossier contenant le fichier docker-compose.yaml, car de nombreuses commandes sont relatives à ce dossier.

Vérifiez maintenant que le conteneur est opérationnel en accédant à http:// . Ce guide utilise http://homelab-docker pour référence.

Vous pouvez voir ce traitement se produire dans VS Code alors que SSH est connecté à l'hôte Docker dans l'animation ci-dessous :

Succès! Vous avez maintenant utilisé Docker Compose avec succès pour démarrer un conteneur à partir d'un fichier de configuration. Cette première étape importante franchie, voyons comment vous gérez l'état de votre conteneur.

Commandes pour gérer les conteneurs détachés

Dans la section précédente, vous avez démarré le conteneur caddy en utilisant le -d drapeau. Cela a exécuté un conteneur dans un détaché Etat. Lorsqu'un conteneur est dans un état détaché, le conteneur continuera à s'exécuter en arrière-plan. Mais, cela pose un problème :comment gérer ce conteneur si vous n'avez plus le contrôle direct ?

Pour résoudre ce problème, Docker Compose dispose d'une série de commandes qui vont gérer les conteneurs démarrés avec un docker-compose.yaml fichier :

docker-compose restart est utilisé pour redémarrer un conteneur en cours d'exécution. Cela est différent de réexécuter réellement docker-compose up -d . La commande de redémarrage redémarrera simplement un conteneur existant, relancera le docker-compose up -d et recréez le conteneur à partir de zéro (si le fichier de configuration a été modifié).
docker-compose stop arrêtera un conteneur en cours d'exécution sans détruire le conteneur. De même, docker-compose start redémarrera le conteneur.
docker-compose down arrêtera les conteneurs en cours d'exécution et les détruira également . C'est là que les montages liés des volumes entrent en jeu (en savoir plus ci-dessous).
docker-compose pull extraira la version actuelle de l'image (ou des images) Docker du référentiel. Si vous utilisez le latest tag, vous pouvez suivre avec docker-compose down && sudo docker-compose up -d pour remplacer le conteneur par la dernière version. Utilisation de docker-compose pull est un moyen pratique de mettre à jour rapidement les conteneurs avec un minimum de temps d'arrêt.
docker-compose logs affichera les journaux du conteneur en cours d'exécution (ou arrêté). Vous pouvez également adresser des conteneurs individuels (s'il y a plusieurs conteneurs définis dans le fichier de composition) avec docker-compose logs <container name> .

Une liste complète des commandes docker-compose peut être consultée en exécutant docker-compose sans arguments supplémentaires ou référencés ici dans la documentation.

Maintenant que vous avez un conteneur en cours d'exécution, examinons comment utiliser le contenu enregistré localement sur votre machine.

Création de montages de liaison dans Docker Compose

Lier les montures sont la manière dont Docker mappe les données utilisateur importantes sur le stockage local sur votre serveur. Pour commencer, générez du contenu pour le conteneur à héberger :

Sur l'hôte Docker, à l'intérieur du ~/containers/caddy dossier créer un nouveau dossier appelé fichiers .

2. Créez un nouveau fichier appelé index.html à l'intérieur du ~/containers/caddy dossier qui ressemble à ci-dessous. Ce sera la page principale que le serveur Web Caddy servira.

<body><h2>hello world!</h2></body>

3. Modifiez votre fichier de configuration Docker Compose pour qu'il ressemble à celui ci-dessous. Le fichier d'exemple ci-dessous ajoute les volumes section et pointant un montage de liaison vers les fichiers dossier que vous venez de créer pour le mettre à disposition du conteneur.

version: "3.7" services: caddy: container_name: "caddy" image: "caddy:latest" ports: - "80:80" volumes: #the ./ refers a folder relative to the docker-compose file - "./files:/usr/share/caddy"

4. Exécutez docker-compose up -d de nouveau. Docker Compose va maintenant reconnaître que le fichier a été modifié et recréer votre conteneur.

5. Accédez à la page du conteneur avec un navigateur et vous devriez maintenant voir qu'il sert le "Hello World!" page.

Vous pouvez voir ce qui suit dans l'animation ci-dessous :

Vous hébergez désormais du contenu stocké localement sur votre machine ! Cependant, que se passe-t-il si votre contenu se trouve sur une source externe comme un partage réseau ?

Utilisation de Docker Compose avec les volumes Docker

Une fois que vous avez créé un conteneur simple avec Docker Compose, vous aurez probablement besoin de ce conteneur pour accéder aux fichiers ailleurs, peut-être sur un partage réseau. Si tel est le cas, vous pouvez configurer le conteneur pour utiliser les volumes Docker directement dans votre fichier de configuration Docker Compose.

À des fins de démonstration, ce guide créera un serveur de partage de fichiers en réseau (NFS) sur l'hôte Docker. La diffusion de contenu local en tant que montage NFS n'a aucun objectif pratique en dehors de la démonstration. Si vous deviez monter un volume NFS, il proviendrait généralement d'une source externe comme un NAS ou un serveur distant.

Si vous n'avez pas encore configuré de partage NFS, créez-en un maintenant sur l'hôte Docker pour ce didacticiel. Pour ce faire :

Installer le serveur NFS package en exécutant apt install nfs-kernel-server -y .

2. Ajoutez le conteneur en tant qu'exportation NFS (similaire à un partage CIFS Windows) en exécutant ce qui suit.

# Add a line to the /etc/exports config file to create a NFS share for # /home/homelab/containers. This share is only exposed to localhost (to # prevent other computers from having access) echo '/home/homelab/containers localhost(rw,sync,no_root_squash,no_subtree_check)' | sudo tee -a /etc/exports # Restart the NFS server with the new config sudo systemctl restart nfs-kernel-server

3. Vérifiez maintenant que l'hôte expose le partage NFS en exécutant showmount -e localhost . Cette commande affichera tous les partages NFS actuellement exposés et qui y a accès.

Dans la capture d'écran ci-dessous, vous pouvez voir /home/homelab/containers est exposé, mais uniquement à l'ordinateur localhost (qui est le même serveur exécutant l'hôte Docker).

Si vous voyez le dossier /home//containers dans la sortie, le partage NFS est configuré.

Définir un volume nommé Docker

Une fois que vous avez créé le partage NFS, vous devez maintenant indiquer à Docker comment accéder à ce partage. En utilisant Docker Compose, vous pouvez le faire en définissant un volume nommé dans le fichier de configuration de Docker Compose.

Un volume nommé est un moyen pour Docker d'abstraire les partages de fichiers basés sur le réseau. Le partage de fichiers réseau se présente de nos jours sous toutes sortes de formes et de tailles :partages CIFS (Windows), partages NFS (Linux), compartiments AWS S3, etc. En créant un volume nommé, Docker fait le plus dur pour trouver comment communiquer avec le partage réseau et laisse le conteneur traiter le partage comme s'il s'agissait d'un stockage local.

Pour créer un volume nommé :

Ouvrez le fichier de configuration de Docker Compose (docker-compose.yaml ). Si vous suivez, le fichier devrait se trouver dans le dossier ~/containers/caddy dossier.

2. Dans le fichier de configuration de Docker Compose, ajoutez un volumes après le services section. Votre fichier de configuration devrait ressembler à ci-dessous. Les volumes La section crée un volume nommé appelé MyWebsite . Dans ce volume nommé, les paramètres nécessaires (tels que l'adresse IP, les paramètres NFS et le chemin) sont spécifiés. Les volumes paramètre dans les services est également modifiée, pour pointer vers le nom du volume plutôt que vers un dossier local.

version: "3.7"
 services:
   caddy:
     container_name: "caddy"
     image: "caddy:latest"
     ports:
       - "80:80"
     volumes:
       - "MyWebsite:/usr/share/caddy"
 volumes:
   MyWebsite:
     driver_opts:
       type: "nfs"
       o: "addr=localhost,nolock,soft,rw"
       device: ":/home/homelab/containers/caddy/files"

3. Une fois que vous avez défini le volume nommé pointant vers le partage NFS dans le fichier de configuration Docker Compose, exécutez docker-compose up -d pour créer et démarrer le conteneur. Si tout se passe bien, le conteneur et le site Web devraient revenir.

4. Accédez à nouveau à la page du conteneur. Le index.html le contenu doit apparaître comme si le fichier était monté localement. Cependant, ce fichier est monté via le serveur NFS configuré sur le réseau.

Comme vous pouvez désormais monter des volumes Docker externes dans Docker Compose, vous pouvez désormais intégrer toutes sortes de stockage réseau dans vos conteneurs. Cependant, Docker Compose peut faire plus que simplement définir des conteneurs ou des volumes uniques. Plongeons-nous dans des scénarios multi-conteneurs plus complexes.

Ce tutoriel n'utilisera plus le conteneur caddy, vous pouvez donc supprimer le conteneur à l'aide de docker-compose down .

Définir plusieurs conteneurs dans Docker Compose

La plupart des conteneurs Docker ne fonctionnent pas dans le vide. Les conteneurs Docker ont généralement des dépendances de service comme des bases de données ou des services Web distincts qui parlent via une API.

À l'aide de Docker Compose, vous pouvez regrouper des conteneurs définis dans un seul fichier. En définissant plusieurs conteneurs dans un seul fichier, les conteneurs peuvent communiquer entre des services dépendants et simplifier l'organisation de dispositions de conteneurs complexes.

Pour illustrer un tel scénario, configurons une application wiki populaire appelée BookStack .

BookStack est un logiciel wiki populaire connu pour sa facilité d'utilisation et sa disposition hiérarchique (par opposition à une disposition plate, comme mediawiki).

BookStack, comme de nombreuses applications Web, nécessite une base de données distincte pour fonctionner correctement, ainsi que les informations nécessaires pour communiquer avec la base de données. La mise en place d'une telle situation est l'endroit où Docker Compose excelle.

Créer le fichier de configuration Docker Compose

BookStack n'a pas d'image Docker gérée en interne, cependant, linuxserver.io maintient une image Docker Hub de bonne réputation au nom de BookStack. Alors que la documentation sur le site Docker Hub contient un fichier de configuration Docker Compose recommandé, ce didacticiel créera un nouveau fichier de configuration tout en expliquant les concepts.

Sur l'hôte Docker :

Tout d'abord, créez un dossier pour BookStack. Si vous avez suivi les tutoriels de la section précédente, vous devriez avoir un ~/containers dossier. Créez un dossier appelé bookstack là-dedans.

2. Créez ensuite un fichier de configuration Docker Compose vierge appelé docker-compose.yaml à l'intérieur de la pile de livres dossier.

3. Ouvrez maintenant le fichier de configuration de Docker Compose et définissez deux conteneurs :le bookstack conteneur et le bookstack_db (mariadb) conteneur.

version: "3.7"
 services:
   bookstack:
     container_name: "bookstack"
     image: "ghcr.io/linuxserver/bookstack"
     ports:
       - "8080:80"
     volumes:
       - "./files:/usr/share/caddy"
     depends_on:
       - "bookstack_db"
   bookstack_db:
     container_name: "bookstack_db"
     image: "mariadb"
     volumes:
       - "./db:/var/lib/mysql"

Jusqu'à présent, ce docker-compose.yaml Le fichier utilise principalement des concepts déjà introduits :vous avez deux services (bookstack , et bookstack_db ), à la fois avec des images et des montages liés. Le conteneur Bookstack a un mappage de port du port hôte 8080 au port interne 80.

Compte tenu de la surcharge extrêmement faible des conteneurs Docker, il est courant de définir un conteneur de base de données distinct pour chaque application Web. Cela permet une plus grande séparation des tâches. Ceci est nettement différent des configurations de base de données traditionnelles, où une seule installation de base de données peut servir des centaines d'applications Web.

Une nouvelle option que vous pouvez voir dans le fichier ci-dessus est le depends_on commande. Cette commande indique à Docker l'ordre dans lequel les conteneurs doivent démarrer. Définition de depends_on commande indique à Docker que le bookstack_db conteneur doit commencer en premier.

Configuration de la communication du conteneur avec les variables d'environnement

Ce fichier de configuration construit dans la dernière section n'est pas encore complet. Alors que vous avez défini deux services (conteneurs), ils ne se parlent pas ! La bookstack le conteneur n'a aucune idée de comment communiquer avec le bookstack_db récipient. Résolvons cela en utilisant des variables d'environnement.

Les variables d'environnement sont le moyen le plus courant de fournir des variables aux conteneurs Docker. Ce sont des variables données au moment de l'exécution (ou définies dans le docker-compose.yaml fichier de configuration) pour fournir des informations sur ce que le conteneur doit faire.

Les variables d'environnement sont définies par la personne qui crée l'image Docker. Ils seront différents selon l'image Docker que vous utilisez, et vous devez vous référer à la documentation du créateur concernant les variables d'environnement à utiliser.

Il existe deux méthodes pour définir les variables d'environnement ; directement dans le docker-compose.yaml fichier lui-même ou dans un fichier séparé.

Un fichier séparé est généralement la méthode recommandée, surtout si les variables contiennent des données sensibles telles que des mots de passe. Un docker-compose.yaml Le fichier est conçu pour être partagé ou même téléchargé sur un dépôt GitHub public. Le fait d'avoir un fichier séparé pour les données sensibles réduit le risque d'une faille de sécurité accidentelle.

Sur l'hôte Docker, créez maintenant deux variables d'environnement ; un pour la pile de livres conteneur et un pour bookstack_db conteneur.

Créer un nouveau fichier dans ~/containers/bookstack dossier appelé bookstack.env avec le contenu suivant :

APP_URL is the IP address or hostname of your server. This article is using homelab-docker
 APP_URL=http://homelab-docker:8080
 DB_HOST is the container name you gave your container
 DB_HOST=bookstack_db
 DB_USER is defined in the bookstack_DB environment file
 DB_USER=bookstack_user
 DB_PASS is also defined in the bookstack_DB environment file
 DB_PASS=MySecurePassword
 DB_DATABASE is the name of the database within mariadb
 DB_DATABASE=bookstack

2. Créez un nouveau fichier dans ~/containers/bookstack dossier appelé bookstack_db.env et inclure le contenu suivant :

The root password for our database, keep it secret, keep it safe
 MYSQL_ROOT_PASSWORD=MySecureRootPassword
 The database bookstack will be using
 MYSQL_DATABASE=bookstack
 the user bookstack will be using
 MYSQL_USER=bookstack_user
 the password bookstack will be using
 MYSQL_PASSWORD=MySecurePassword

3. Comme bonne pratique, assurez-vous maintenant que env les fichiers ne sont pas lisibles par les autres utilisateurs.

chmod 600 bookstack.env bookstack_db.env

Vous devez modifier l'accès en lecture car les fichiers bookstack.env et bookstack_db.env contiennent des données sensibles.

4. Mettez à jour le fichier ~/containers/bookstack/docker-compose.yaml Fichier Docker Compose pour référencer ces deux fichiers d'environnement illustrés ci-dessous.

version: "3.7"
 services:
   bookstack:
     container_name: "bookstack"
     image: "ghcr.io/linuxserver/bookstack"
     ports:
       - "8080:80"
     volumes:
       - "./files:/usr/share/caddy"
     depends_on:
       - "bookstack_db"
     env_file:
       - "./bookstack.env"
   bookstack_db:
     container_name: "bookstack_db"
     image: "mariadb"
     volumes:
       - "./db:/var/lib/mysql"
     env_file:
       - "./bookstack_db.env"

5. Maintenant, démarrez la pile de livres et bookstack_db conteneurs à l'aide de Docker Compose.

sudo docker-compose up -d

Vous pouvez voir chacune des étapes susmentionnées dans cette section exécutées dans VS Code ci-dessous.

Surveillance des journaux de composition Docker

Le moteur Docker fonctionne avec Docker Compose pour effectuer de nombreuses tâches différentes en arrière-plan. Il est utile de pouvoir surveiller ce qui se passe, en particulier lorsque vous travaillez avec plusieurs conteneurs à la fois.

Pour surveiller le conteneur de la pile de livres, par exemple, utilisez les logs commande. Dans ce tutoriel, une fois que vous voyez les journaux afficher [services.d] done , vous pouvez accéder à l'URL de la pile de livres.

sudo docker-compose logs bookstack

À ce stade, vous devriez avoir un wiki entièrement fonctionnel fonctionnant dans son propre conteneur, avec sa propre base de données, entièrement dans Docker !

Tant que vous avez les dossiers bookstack et bookstack_db, vous pouvez recréer votre environnement bookstack à partir de zéro.

Docker Compose et mise en réseau

Jusqu'à présent, vous n'avez pas beaucoup appris sur l'aspect communication et mise en réseau de la façon dont les conteneurs fonctionnent ensemble. Changeons cela.

Lorsque vous créez plusieurs conteneurs dans un seul docker-compose.yaml comme vous l'avez fait dans les sections précédentes, ils sont tous affectés au même réseau (généralement appelé name-of-parent-folder_default ).

Vous pouvez voir le réseau créé pour les conteneurs lorsque vous exécutez docker-compose up -d comme indiqué ci-dessous.

Lorsque tous les conteneurs sont affectés au sein du même réseau, Docker crée des entrées DNS pour eux en interne. C'est pourquoi dans l'exemple précédent, vous avez fait référence à votre base de données en tant que bookstack_db dans les variables d'environnement. Ce bookstack_db name est en fait une entrée DNS qui pointe vers l'adresse IP du conteneur de la base de données.

Vous n'avez pas non plus besoin de compter sur Docker Compose pour générer automatiquement des réseaux pour vous. Vous pouvez définir manuellement des réseaux internes ou externes. La définition manuelle des réseaux est idéale lorsque vous avez un conteneur qui doit parler à un autre conteneur dans un docker-compose.yaml séparé. dossier. Vous pouvez exposer les ports ou créer un réseau auquel ils peuvent tous les deux se joindre !

Notez que lorsque vous commencez à définir explicitement des réseaux, vous devez également définir explicitement le réseau par défaut. Docker Compose arrêtera automatiquement de créer ce réseau une fois que vous aurez commencé à définir les réseaux

Modifiez maintenant la pile de livres docker-compose.yaml pour inclure un réseau créé en externe.

Créez le réseau externe avec docker network create my_external_network .

2. Définissez le réseau externe dans docker-compose.yaml :

version: "3.7"
 services:
   bookstack:
     container_name: "bookstack"
     image: "ghcr.io/linuxserver/bookstack"
     ports:
       - "8080:80"
     volumes:
       - "./files:/usr/share/caddy"
     depends_on:
       - "bookstack_db"
     env_file:
       - "./bookstack.env"
     networks:
       - "my_external_network"
       - "bookstack_default"
   bookstack_db:
     container_name: "bookstack_db"
     image: "mariadb"
     volumes:
       - "./db:/var/lib/mysql"
     env_file:
       - "./bookstack_db.env"
     networks:
       - "bookstack_default"
 networks:
   bookstack_default:
   my_external_network:
     external: true

3. Exécutez docker-compose up -d pour recréer les conteneurs. Vos deux conteneurs sont maintenant joints à deux réseaux comme indiqué ci-dessous.

Le conteneur de la pile de livres est maintenant aussi rattaché à un réseau défini de l'extérieur. Cela vous permet de créer un autre conteneur qui transforme le trafic HTTP de la pile de livres en HTTPS avant qu'il ne quitte Docker (appelé reverse-proxy ).

Définir un utilisateur spécifique pour exécuter un conteneur

Par défaut, tous les conteneurs Docker s'exécutent en tant qu'utilisateur root en bac à sable. Cela équivaut à exécuter une machine virtuelle connectée en tant qu'utilisateur administrateur par défaut. Alors que cela généralement n'est pas un problème, il y a des problèmes de sécurité si le bac à sable est compromis.

L'autre problème avec l'exécution en tant que root est les autorisations de fichiers. Vous remarquerez peut-être que si vous essayez de supprimer le db dossier dans la bookstack dossier, vous ne pouvez pas ; le contenu appartient à root.

Alors que la plupart des images n'apprécient pas de s'exécuter en tant qu'utilisateur non root, linuxserver.io les images en particulier offrent une variable d'environnement pour définir l'utilisateur qui s'exécute à l'intérieur du conteneur. Vous pouvez le faire en ajoutant UID=1000 et GID=1000 à l'intérieur de bookstack.env configuration.

1000:1000 is the default user ID and group for the first user in ubuntu (which you may not be). You can read more about User IDs and Group IDs at Related:A Windows Guy in a Linux World:Users and File Permissions )

You can also force a UID and GID using the user parameter in docker-compose, but this is not recommended as most containers do not behave well when forced to a different user

Setting the Restart Policy

If you’d like containers built with Docker Compose to restart on failure, use the restart policy by adding a restart: <option> parameter under the container settings in docker-compose.yaml .

restart: "no"
restart: always
restart: on-failure
restart: unless-stopped

Adding this parameter will cause containers to automatically restart on failure to help maintain uptime in the event of unexpected power issues.

Manually setting DNS entries for Containers

Just like with Windows and Linux, Docker also has a “hosts file”. By using the extra_hosts parameter in a config file, you can force a host to resolve to a specific IP. This can be useful when you have DNS constraints, such as split DNS or a test server you want to interact with temporarily.

extra_hosts:
  - "somehost:x.x.x.x"
  - "otherhost:x.x.x.x"

Running Commands

Once the container is started, you can run commands inside of the container using the docker-compose run . For example, maybe you’d like to start up a Bash terminal inside of your bookstack récipient. To do that, you’d run the command below.

docker-compose run web bash

Conclusion

At this stage, you should have enough information to follow along with the majority of docker-compose tutorials out on the web. Having this knowledge can vastly expand your ability to move into the world of Docker, and the building of web apps in Infrastructure as Code.