5 astuces : compose.yml

Tu vas découvrir 5 astuces utiles lorsque tu crées un fichier compose.yml. 😎

Astuce 1 : Centraliser les variables sensibles (mots de passe, etc.)

Pourquoi centraliser les variables sensibles ?

C'est très simple !

Pour plus de flexibilité et de sécurité, il est préférable d’utiliser des variables d'environnement pour stocker les informations sensibles. Ainsi, elles ne seront pas présentes dans le fichier compose.yml de Docker.

Comment utiliser les variables d'environnement dans Docker ?

Mauvais exemple

Il ne faut surtout pas procéder de cette façon :

environment:
  POSTGRES_PASSWORD: supersecret

Bon exemple

Il est préférable d'utiliser des variables d'environnement. Voici un exemple :

environment:
  POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}

Ensuite, dans un fichier .env, ajoutez le nom de la variable ainsi que son contenu : le mot de passe.

POSTGRES_PASSWORD=supersecret

Voici l'arborescence adapté à l'exemple :

test/
|-- compose.yml
|-- .env

Astuce 2 : Réutiliser des blocs grâce aux ancres

Les ancres YML

Pour information, les ancres ne sont pas une fonctionnalité propre à Docker, mais une fonctionnalité des fichiers YML.

Pourquoi utiliser des ancres ?

Les ancres permettent de réutiliser des blocs que l’on répète plusieurs fois dans le fichier compose.yml.

Comment créer des ancres ?

Pour bien comprendre, nous allons utiliser un exemple.

Nous souhaitons répéter le bloc suivant trois fois :

image: nginx:latest
    networks:
      - nginx_network

Préparation de l'ancre

Pour préparer le bloc, il faut utiliser la structure suivante :

x-serveurs: &serveurs
    image: nginx:latest
    networks:
      - nginx_network

Alors, x-serveurs est une clé choisie. Le préfixe x- est une convention de nommage qu’il faut respecter.

Et &serveurs est l’ancre à utiliser. Le symbole & permet de définir l’ancre, et serveurs en est le nom.

Utiliser l'ancre

Pour utiliser l'ancre, il faut insérer dans le fichier compose.yml l'expression suivante :

<<: *serveurs

Et pour mieux comprendre, voici l’exemple complet :

x-serveurs: &serveurs
    image: nginx:latest
    networks:
      - nginx_network
 
services:
  app1:
    <<: *serveurs
    ports:
      - "81:80"

  app2:
    <<: *serveurs
    ports:
      - "82:80"

  app3:
    <<: *serveurs
    ports:
      - "83:80"

networks:
  nginx_network:
    driver: bridge

Ce code équivaut à :

services:
  app1:
    image: nginx:latest
    networks:
      - nginx_network
    ports:
      - "81:80"

  app2:
    image: nginx:latest
    networks:
      - nginx_network
    ports:
      - "82:80"

  app3:
    image: nginx:latest
    networks:
      - nginx_network
    ports:
      - "83:80"

networks:
  nginx_network:
    driver: bridge

Grâce aux ancres, l’espace est optimisé et, en cas de modification, il suffit de changer uniquement le contenu de l’ancre. 😉

Si vous faites un docker compose up, trois conteneurs seront lancés, basés sur l’image nginx:latest et connectés au réseau nginx_network.

Astuce 3 : Vérifier la configuration du fichier compose.yml

Tu peux simplement, vérifier la configuration de ton fichier compose.yml grâce à la commande suivante : docker compose config.

Nous allons créer un compose.yml pour l'exemple :

services:
  web:
    image: nginx:latest
    ports:
      - "80:80"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf
    networks:
      - webnet
  app:
    image: php:latest
    volumes:
      - program:/var/www/html
    networks:
      - webnet

networks:
  webnet:
    driver: bridge
    
volumes:
  program:

Maintenant, on lance la commande pour vérifier la configuration :

docker compose config

Et voici le résultat :

services:
  app:
    image: php:latest
    networks:
      webnet: null
    volumes:
      - type: volume
        source: program
        target: /var/www/html
        volume: {}
  web:
    image: nginx:latest
    networks:
      webnet: null
    ports:
      - mode: ingress
        target: 80
        published: "80"
        protocol: tcp
    volumes:
      - type: bind
        source: /Users/henrique/Documents/apps/lab/Test/nginx.conf
        target: /etc/nginx/nginx.conf
        bind:
          create_host_path: true
networks:
  webnet:
    name: test_webnet
    driver: bridge
volumes:
  program:
    name: test_program

Cela nous affiche des détails intéressants :

• Lignes 17 à 18 : On voit clairement le port utilisé par notre conteneur ainsi que celui exposé. Il s’agit du mappage entre le port du conteneur et celui de la machine locale.

• Lignes 6 à 10 et 20 à 25 : On identifie un volume mappé et un autre managé.

Astuce 4 : Utiliser plusieurs configurations

Pourquoi utiliser plusieurs configurations ?

Cela permet d’ajouter des règles sans modifier la configuration principale. C’est très utile lorsqu’on utilise Docker en mode développement d’application.

C’est également pratique lorsqu’on souhaite une configuration spécifique pour le passage en production.

Créer une configuration compose.override.yml et compose.prod.yml

Le fichier compose.override.yml a une particularité : il est automatiquement pris en compte lorsque l’on exécute la commande docker compose config.

Nous allons utiliser un exemple pour bien comprendre.

Il nous faut de fichiers :

test/
|-- compose.yml
|-- compose.override.yml

compose.yml

Dans le fichier compose.yml tapez les règles suivantes :

services:
  web:
    image: nginx:latest

compose.override.yml

Dans le fichier compose.override.yml insérez les informations suivantes :

services:
  web:
    ports:
        - "8000:80"

Tapez la commande qui permet d'analyser la configuration de notre compose.yml.

docker compose config

Et voici le résultat :

name: test
services:
  web:
    image: nginx:latest
    networks:
      default: null
    ports:
      - mode: ingress
        target: 80
        published: "8000"
        protocol: tcp
networks:
  default:
    name: test_default

Les deux fichiers ont été pris en compte. 👍 Cette mécanique pourra être utile dans certains cas.

compose.prod.yml

Une configuration spécifique pourra être utilisée en production. On la nommera compose.prod.yml.

Ce fichier ne sera pas pris en compte automatiquement. Nous allons donc procéder autrement pour gérer les configurations, en utilisant l’option -f.

Mais avant cela, je rappelle l’arborescence.

test/
|-- compose.yml
|-- compose.override.yml
|-- compose.prod.yml

Dans le fichier compose.prod.yml j'insère ces règles :

services:
  web:
    ports:
        - "80:80"

Maintenant, je vais utiliser la commande suivante :

docker compose -f compose.yml  -f compose.prod.yml config

J’utilise donc l’option -f. Cela me permet d’indiquer quels fichiers doivent être pris en compte. Et vous avez certainement remarqué que compose.override.yml n’est pas utilisé dans ce cas.

Voici le résultat :

name: test
services:
  web:
    image: nginx:latest
    networks:
      default: null
    ports:
      - mode: ingress
        target: 80
        published: "80"
        protocol: tcp
networks:
  default:
    name: test_default

Comme vous pouvez le constater, le mappage de ports défini dans le fichier compose.prod.yml a bien été pris en compte.

Astuce 5 : Utiliser les profils pour gérer des services conditionnels

Qu'est-ce qu'un profils ?

Un profil est une étiquette que l’on associe à un ou plusieurs services dans le fichier compose.yml. Lorsqu’on lance Docker Compose, on peut choisir d’activer un profil particulier pour inclure ou exclure certains services. 😮

Comment définir un profil ?

Dans votre fichier compose.yml, vous pouvez ajouter la clé profiles à un ou plusieurs services.

Voici la syntaxe de base :

services:
  webdev:
    image: nginx:latest
    ports:
      - "8000:80"
    profiles:
      - dev

  webprod:
    image: nginx:latest
    ports:
      - "80:80"
    profiles:
      - prod

N'oubliez pas de supprimer les autres fichier :

test/
|-- compose.yml

Activer un profil !

Pour activer un profil, il faut utiliser l'option --profile :

Profil dev

docker compose --profile dev config 

Voici le résultat pour dev :

name: test
services:
  webdev:
    profiles:
      - dev
    image: nginx:latest
    networks:
      default: null
    ports:
      - mode: ingress
        target: 80
        published: "8000"
        protocol: tcp
networks:
  default:
    name: test_default

Profil prod

docker compose --profile prod config 

Voici le résultat pour prod :

name: test
services:
  webprod:
    profiles:
      - prod
    image: nginx:latest
    networks:
      default: null
    ports:
      - mode: ingress
        target: 80
        published: "80"
        protocol: tcp
networks:
  default:
    name: test_default

Informations supplémentaires

Pour les experts

Ces astuces sont destinées à ceux qui maîtrisent déjà Docker. Si vous débutez, je vous invite d’abord à vous former aux bases de Docker.

Possibilité d'utiliser docker compose up

Pour l’astuce 4 et l’astuce 5, il est possible d’utiliser directement docker compose up au lieu de vérifier la configuration. Le principe reste le même.