Optimisez votre déploiement en créant des conteneurs avec Docker

Sarah, la CTO, vous appelle un matin :

Je viens de recevoir les projections de volumétrie d’utilisateurs attendues pour l’application. Il va falloir qu’on réfléchisse sérieusement à déporter le stockage des fichiers sur un service externe si on veut pouvoir répondre aux attentes de Liam…

Une application n’est que rarement autonome et dépend souvent de services externes. Base de données, service de stockage ou d’authentification, autant d’éléments qui agrégés constituent un écosystème applicatif cohérent, avec son cycle de vie propre.

La conteneurisation n’est pas exempte de cette vérité et au contraire peut apporter un certain nombre d’outils facilitant la création et la maintenance de ce type d’architecture applicative.

Les applications multi-tiers

Il est rare qu’un environnement applicatif se limite à un seul et unique service. Le modèle classique d’architecture “3 tiers” - qui est un cas particulier des architectures multi-tiers - découpe ainsi un environnement en 3 couches :

• La présentation ;

• Le traitement ;

• Les données.

Ces 3 couches peuvent par exemple se matérialiser en 3 services séparés :

• Une “Single Page App” : elle a pour rôle de réaliser l’interface entre l’utilisateur et le modèle de données ;

• Une API REST : elle a pour rôle d’exécuter les règles de gestion “métier” sur les données de l’application (traitements, droits d’accès, etc)

• Une base de données : elle a pour rôle de persister les données et de maintenir la cohérence de celles-ci.

Afin de respecter le principe fondamental de responsabilité unique, il est préférable de découper ces 3 services en 3 conteneurs séparés. Cette démarche permet d’améliorer :

• La maintenabilité de nos images : en réduisant le nombre de dépendances de nos images, cette approche simplifie le processus de création et mise à jour des recettes de construction.

• La capacité de passage à l’échelle (scalability) : en séparant les responsabilités de chaque conteneur, il est plus simple de mettre en place des mécanismes de répartition de charge en démarrant plusieurs instances d’une même image de conteneur sur les services en souffrance.

S'il était nécessaire de réaliser l’ensemble de nos déploiements complexes avec les commandes Docker, la tâche pourrait s’avérer fastidieuse. Fort heureusement, il existe Docker Compose pour nous simplifier  la tâche !

Intégrez des services externes

Docker Compose est un outil permettant de définir et de gérer des applications multi-conteneurs. Avec Docker Compose, vous pouvez configurer les services de votre application, les réseaux et les volumes en un seul fichier, ce qui facilite le déploiement et la gestion de l’écosystème applicatif.

Voici les points clés à retenir :

• Définition simplifiée : Un fichierdocker-compose.ymlcentralise la configuration de tous les services nécessaires.

• Gestion de la dépendance : Vous pouvez facilement gérer les dépendances entre différents services.

• Isolation des environnements : Chaque environnement est isolé, permettant une configuration propre pour le développement, les tests et la production.

Passons directement à des éléments concrets et découvrons ensemble le fichierdocker-compose.yml, véritable cartographie de votre environnement applicatif conteneurisé.

Rédigez votre premier fichier docker-compose.yml

Le fichierdocker-compose.yml permet de décrire les services, les réseaux et les volumes de votre application dans un format lisible par l'humain. Il définit comment les conteneurs Docker devraient interagir et être configurés.

Au format YAML, il se compose principalement de sections telles que services,volumesetnetworks:

services:
# Section de définition des “services” qui constituent l’environnement
# applicatif
volumes:
# Section de définition des “volumes” (supports de stockage) utilisés
# par l’environnement applicatif
networks:
# Section de définition des “networks” (réseaux et interfaces virtuels)
# utilisés par l’environnement applicatif.

Explorons le détail de ces trois sections.

Section “services”

# La section “services” permet de déclarer l’ensemble des conteneurs
# qui constitueront notre environnement applicatif.
services:
# On déclare un service intitulé “web”
web:
# Le conteneur du service “web” utilise une image
# construite à partir du fichier Dockerfile présent dans
# le répertoire courant (./)
build: ./
# On expose les variables d’environnement suivantes
# à notre conteneur
environment:
      - NODE_ENV=production
    # On déclare des volumes qui seront utilisés par notre conteneur
# Ici, on “monte” le répertoire ./web de l’hôte sur le chemin /usr/src/app
# dans le conteneur
volumes:
- ./web:/usr/src/app
networks:
my-network
# On expose le port 3000 du conteneur sur le port 3000 de la machine hôte
ports:
- "3000:3000" 
# On déclare un service intitulé “database”
database:
# Ce service utilise l’image mysql:5.7
image: mysql:5.7
# Déclaration des variables d’environnement
# exposées dans le conteneur
environment:
      MYSQL_ROOT_PASSWORD: example
    # Déclaration des volumes utilisés par le conteneur. 
volumes:
# Dans le cas présent, on utilise un volume nommé “db-data”, monté
# sur le chemin /var/lib/mysql dans le conteneur
- db-data:/var/lib/mysql
networks:
my-network
# On expose le port 3306 du conteneur sur le port 3306 de la machine hôte
ports:
- "3306:3306"

Cette section décrit les différents services qui composent votre application. Elle contient entre autres les sous-sections suivantes :

• image etbuild : Utilisezimage pour spécifier une image Docker existante oubuildpour construire une image à partir d’un Dockerfile.

• environment: Définissez les variables d’environnement pour le conteneur.

• volumes: Montez des répertoires ou des fichiers depuis le système de fichiers hôte dans le conteneur.

• ports: Mappez les ports entre l’hôte et le conteneur.

Section “volumes”

# On déclare des volumes nommés qui seront utilisables
# par nos services
volumes:
db-data:

Cette section permet de définir des volumes partagés entre plusieurs conteneurs ou persistants sur le système hôte.

Dans cet exemple, le volume nommédb-data est utilisé par le service database, défini dans la sectionserviceprécédente.

Section “networks”

# On déclare les réseaux nommés qui seront utilisables
# par nos services
networks:
my-network:
driver: bridge

Dans cet exemple, le réseau nommémy-networkest utilisé par les servicesapp etdatabase, définis dans la sectionserviceprécédente.

L’attributdriverpermet de définir le pilote associé au réseau. Le driverbridge, utilisé en général par défaut par les conteneurs, permet de créer un réseau privé pour ceux-ci. 

Passons à la pratique avec la vidéo suivante :

Dans cette vidéo, nous avons vu :

• Le détail des principales sections constituant un fichierdocker-compose.yml, notamment :

  • L’utilisation d’images préexistantes

  • L’utilisation d’images construites localement

  • La déclaration de dépendances entre les conteneurs

  • La déclaration de variables d’environnement pour notre conteneur

  • La déclaration de networks

  • L’utilisation de volumes nommés ou utilisant des répertoires locaux

  • L’exposition de ports

Notre fichierdocker-compose.ymlmaintenant rédigé, voyons comment démarrer et gérer notre tout nouvel environnement applicatif !

Gérez votre environnement “compose”

La manipulation d’un environnement Docker Compose s’effectue via les sous commandesdocker composeintégrées au client Docker. Voyons dans cette vidéo comment réaliser ces opérations.

Dans cette vidéo, nous avons découvert les commandes suivantes :

• docker compose build : Construit les images des services définis dans le fichierdocker-compose.yml

• docker compose up : Démarre les conteneurs, crée les réseaux et les volumes définis.

• docker compose down : Arrête et supprime les conteneurs, les réseaux et les volumes créés par up.

• docker compose ps : Liste les conteneurs en cours d’exécution.

• docker compose logs : Affiche les journaux d'exécution des conteneurs.

• docker compose top / stats : Visualise l’usage des ressources et les processus en cours d’exécution.

En maîtrisant ces commandes, vous êtes désormais en mesure de gérer efficacement le cycle de vie de votre environnement de conteneurs, de la construction initiale à la surveillance des performances.

À vous de jouer

Contexte

Ce matin, c’est un courriel de Neil, le développeur du projet Libra, qui vous accueille :

Sarah m’a dit qu’elle t’avait parlé du problème de stockage des fichiers… Voici la nouvelle version de l’application capable de se connecter à un service de type S3, pour externaliser le stockage. Ça se configure via une variable d’environnement !

Comme indiqué par Sarah, Libra va nécessiter l’utilisation d’un système de stockage externe pour ses fichiers. Pour ce faire, il a été décidé d’utiliser un service de type “S3”, le nom générique donné aux services implémentant une API de stockage répliquant celle d’Amazon S3.

Le choix technique s’est porté sur Minio, un logiciel libre remplissant exactement ce type de fonctionnalité.

À vous de rédiger le fichierdocker-compose.ymlqui intégrera la nouvelle version de l’application Libra avec ce nouveau service !

Consignes

• Rédiger le fichierdocker-compose.ymlpermettant de créer :

  • Un servicelibra utilisant l’imagelibra:latest:

    • exposant le port 8080 sur votre machine

    • utilisant la variable d’environnementLIBRA_STORE_DSN=s3://minio/libra

  • Un serviceminioutilisant l’imageminio/minio:

    • Exposant les ports 9000 et 9001 sur votre machine

• Vérifier que l’environnement Docker Compose démarre correctement lors de l’exécution de la commandedocker compose upet que l’application est bien disponible à l’adresse http://localhost:8080

En résumé

• Docker Compose est un outil essentiel pour définir et gérer des applications multi-conteneurs de manière cohérente et centralisée via un fichierdocker-compose.yml

• Le fichierdocker-compose.yml est composé de plusieurs sections, les principales étant  services , définissant les conteneurs,volumes etnetworks.

• Les sous-commandesdocker compose …permettent de gérer l’ensemble du cycle de vie de votre environnement conteneurisé, du démarrage à l’arrêt, en passant par la surveillance de celui-ci.

Vous êtes désormais capable de créer un environnement applicatif conteneurisé complet, voyons ensemble comment le déployer sur plusieurs machines afin de passer à l’échelle !