Tirer parti des variables d'environnement docker-compose

Si vous devez définir diverses valeurs de configuration, les variables d'environnement sont votre meilleur ami. Comme de nombreux outils, Docker et, plus précisément, Docker Compose peuvent à la fois définir et lire des variables d'environnement pour vous aider à garder vos configurations propres et modulaires. Ce tutoriel vous apprend à utiliser docker-compose variables d'environnement pour définir différents conteneurs, environnements, etc.

Prérequis

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

• Un hôte Linux avec des privilèges d'administrateur. Ce didacticiel utilise Ubuntu 18.04.5 LTS.
• Docker installé sur l'hôte Linux. Ce tutoriel utilise Docker v19.03.11.

Déclarer des variables d'environnement dans le fichier Docker Compose

Les conteneurs peuvent exiger beaucoup de configuration. Et toutes les configurations de vos conteneurs ne seront pas uniques. Certains paramètres peuvent être partagés entre certains de vos conteneurs, comme un identifiant de base de données MySQL. Stockez les informations d'identification manuellement dans chaque conteneur, et lorsque les informations d'identification changent, vous finissez par devoir mettre à jour les informations d'identification plusieurs fois.

Les variables d'environnement peuvent réduire ce tracas. Stockez ces paramètres partagés en tant que variables d'environnement ! Référencez les variables d'environnement au lieu de vous répéter dans les conteneurs. Lorsque les informations d'identification changent, vous devez mettre à jour un seul paramètre :la variable d'environnement.

Commençons par déclarer une variable d'environnement et la stocker dans le fichier Docker Compose lui-même. Les étapes ci-dessous stockeront les paramètres d'une base de données MySQL hypothétique dans des variables d'environnement.

1. Ouvrez un terminal sur votre ordinateur local.

2. Créez un dossier nommé ~/docker-compose-demo, puis changez (cd ) le répertoire de travail dans le dossier que vous venez de créer. La ~/docker-compose-démo dossier contiendra tous les fichiers que vous allez créer dans ce didacticiel.

mkdir ~/docker-compose-demo
cd ~/docker-compose-demo

3. Ouvrez votre éditeur de texte préféré, copiez/collez le code dans l'extrait ci-dessous dans l'éditeur de texte. Enregistrez le fichier sous docker-compose.yml dans ~/docker-compose-demo annuaire. Le docker-compose.yml stocke les configurations des services de votre application.

Dans l'extrait de code ci-dessous :

• mysql:5.7 est l'image de base que Docker Compose extrait et crée un nouveau conteneur.
• MYSQL_ROOT_PASSWORD , MYSQL_ALLOW_EMPTY_PASSWORD , et MYSQL_RANDOM_ROOT_PASSWORD sont trois variables d'environnement différentes dans le fichier Docker Compose. Chaque variable d'environnement est déclarée avec ses valeurs. La valeur que la variable d'environnement obtient vient après le : symbole.
• mysql le service créera le conteneur nommé mysql .

# Version of Docker compose file
version: "2.2"

services:
# Defining the service
  mysql:
# Defining the base image to be used 
    image: mysql:5.7
    hostname: mysql
    container_name: mysql
# Defining the environmental variable
    environment:
      # ENVIRONMET_VARIABLE_NAME: "environment variable value" 
      MYSQL_ROOT_PASSWORD: "root_password"
      MYSQL_ALLOW_EMPTY_PASSWORD: "password"
      MYSQL_RANDOM_ROOT_PASSWORD: "password"

Certains conteneurs s'appuient sur des variables d'environnement pour fonctionner correctement. Celui de l'exemple, MySQL, est l'un de ces conteneurs. Si vous ne déclarez pas les variables d'environnement attendues par le conteneur, une erreur sera générée. Vous pouvez voir l'erreur ci-dessous.

4. Ensuite, exécutez le docker-compose up commande. Le docker-compose up la commande lit le fichier YAML (docker-compose.yml ) créé à l'étape précédente et crée le conteneur. Le docker-compose up La commande démarre tous les services configurés dans le fichier Docker Compose.

5. Maintenant, vérifiez si les trois variables d'environnement sont présentes dans le conteneur en exécutant le docker exec commande et le env commande.

L'exécution de la commande docker exec vous permettra de vous connecter au conteneur. Exécution de env imprimera la liste des variables d'environnement actuelles avec leurs valeurs respectives.

# ee8a... is the container
docker exec -it ee8af8bfcd41 /bin/bash

Remplacement des variables d'environnement

Dans la section précédente, vous avez appris à déclarer les variables d'environnement directement dans le fichier Docker Compose en les codant en dur. Une telle approche n'est pas optimale si vous avez besoin de sécuriser vos informations d'identification. Comme alternative, stockez les valeurs des variables d'environnement dans un fichier nommé .env que seul l'administrateur peut lire.

Entraînons-nous à utiliser la substitution pour les variables d'environnement. Dans votre terminal :

1. Créez un fichier nommé .env dans le même ~/docker-compose-demo répertoire et copiez le code ci-dessous dans le .env dossier. Le fichier contiendra toutes les variables d'environnement avec leurs valeurs respectives.

 # Defining the values of environmental variables
 MYSQL_ROOT_PASSWORD="root_password"
 MYSQL_ALLOW_EMPTY_PASSWORD="password"
 MYSQL_RANDOM_ROOT_PASSWORD="password"

2. Ensuite, modifiez les autorisations de .env fichier que vous avez créé à l'étape précédente à l'aide de la commande setfacl. La commande ci-dessous garantit que l'utilisateur root dispose des autorisations de lecture/écriture sur .env fichier.

• m Le paramètre vous permet de définir les autorisations sur les fichiers/dossiers.
• u est l'utilisateur (root ) qui aura des permissions accordées au fichier spécifié ~/*docker-compose-demo/.env

setfacl -m "u:root:rw" ~/docker-compose-demo/.env

3. Ensuite, modifiez le fichier docker-compose.yml avec votre éditeur préféré et commentez la section environnement dans le docker-compose.yml de la section précédente. Ajoutez le code ci-dessous pour définir les valeurs par défaut des variables d'environnement dans le fichier Compose.

Docker définit les valeurs via la ligne de commande ou en lisant des fichiers, tels que .env fichier dans l'exemple. Dans les deux cas, Docker remplace les valeurs en conséquence.

# Defining the environmental variable using Hardcoded values in variables
    environment:
	    ###  Static way ###
      # MYSQL_ROOT_PASSWORD: "root_password" 
			# MYSQL_ALLOW_EMPTY_PASSWORD: "password"
      # MYSQL_RANDOM_ROOT_PASSWORD: "password"

			### Substitution ### 
      MYSQL_ROOT_PASSWORD: ${MYSQL_ROOT_PASSWORD} 
			MYSQL_ALLOW_EMPTY_PASSWORD: ${MYSQL_ALLOW_EMPTY_PASSWORD} 
			MYSQL_RANDOM_ROOT_PASSWORD:  ${MYSQL_RANDOM_ROOT_PASSWORD} 

Le code définit les variables en appliquant la méthode d'interpolation de chaîne. Les variables avec interpolation de chaîne sont déclarées comme ${variable}. Docker définit les valeurs des variables d'environnement au moment de l'exécution.

4. Encore une fois, exécutez le docker-compose up commande. Lorsque vous exécutez le docker-compose up commande, le docker-compose.yml file cherche les valeurs des variables d'environnement dans le .env dossier. Le docker-compose la commande recherche automatiquement un .env fichier dans le répertoire du projet ou dans le dossier parent de votre fichier de composition.

Dès que docker-compose trouve la valeur des variables d'environnement définies dans docker-compose.yml dans le .env fichier, Compose remplace les valeurs en conséquence et démarre le service. Démarrer le service crée le conteneur défini dans le docker-compose.yml fichier.

Utilisation de plusieurs fichiers de variables d'environnement pour plusieurs environnements

Jusqu'à présent, vous avez appris deux approches pour déclarer les variables d'environnement. La première consiste à déclarer des variables d'environnement dans le docker-compose.yml dossier. La deuxième approche consiste à déclarer les variables d'environnement dans un seul .env fichier et application de la substitution.

Les deux approches conviennent lorsque vous travaillez avec un seul environnement. Si vous avez plusieurs environnements, comme la production et/ou les tests, vous avez besoin d'une approche différente. Voyons comment créer plusieurs .env des fichiers avec des noms différents pour correspondre à vos environnements !

L'exemple ci-dessous émule les environnements habituels que l'on peut rencontrer dans les opérations informatiques :Dev, QA et Prod. De retour sur votre terminal :

1. Accédez à votre ~/docker-compose-demo répertoire et créez un .env.dev dossier. Copiez/collez le contenu de l'extrait de code ci-dessous dans le fichier et enregistrez-le. Ce fichier contiendra les paramètres utilisés pour la base de données de votre environnement de développement MySQL.

# Enviornmental Variables file .env.dev
MYSQL_ROOT_PASSWORD="password_DEV"
MYSQL_ALLOW_EMPTY_PASSWORD="password1"
MYSQL_RANDOM_ROOT_PASSWORD="password1"

2. Dans le même répertoire, créez un .env.qa fichier et enregistrez le contenu de l'extrait de code ci-dessous dans le fichier. Ce sont les paramètres de votre base de données d'environnement d'assurance qualité MySQL.

# Enviornmental Variables  file .env.qa
MYSQL_ROOT_PASSWORD="password_QA"
MYSQL_ALLOW_EMPTY_PASSWORD="password2"
MYSQL_RANDOM_ROOT_PASSWORD="password2"

3. Créez maintenant un .env.prod pour stocker les paramètres de la base de données hypothétique de l'environnement de production MySQL. Le contenu est ci-dessous :

# Enviornmental Variables file .env.prod
MYSQL_ROOT_PASSWORD="password_PROD"
MYSQL_ALLOW_EMPTY_PASSWORD="password3"
MYSQL_RANDOM_ROOT_PASSWORD="password3"

4. Ensuite, exécutez le docker-compose commande avec le --env-file option, en spécifiant le .env.dev dossier. Le docker-compose la commande recherche le .env.dev fichier dans le courant ~/docker-compose-demo annuaire.

docker-compose --env-file .env.dev up

Passer le fichier comme argument vous permet de stocker le fichier n'importe où et avec un nom approprié.

Comme vous pouvez le voir ci-dessous, vous pouvez facilement choisir les différents fichiers d'environnement et les déployer en remplaçant le .env.dev fichier vers .env.qa ou le .env.prod dossier.

# Running the docker-compose command with the QA file
docker-compose --env-file .env.qa up
# Running the docker-compose command with the Prod file
docker-compose --env-file .env.prod up

5. Maintenant, vérifiez si le fichier de configuration (.env.dev ) a été lu avec succès en exécutant docker exec commande. L'exécution de la commande docker exec vous permettra de vous connecter au conteneur. Exécution de env imprimera la liste des variables d'environnement actuelles.

Notez que les trois variables d'environnement (MYSQL_ROOT_PASSWORD , MYSQL_ALLOW_EMPTY_PASSWORD , et MYSQL_RANDOM_ROOT_PASSWORD ) sont présents dans le conteneur. Notez que leurs valeurs proviennent de env.dev dossier.

Intégrer le env_file dans le fichier Docker Compose

Dans la section précédente, vous avez vu comment déclarer les variables d'environnement dans .env des dossiers. Lorsque vous stockez les valeurs des variables d'environnement dans le .env fichier séparément, vous vous retrouvez avec beaucoup de lignes et de références dans le docker-compose.yml .

Pour réduire les références et le nombre de lignes pour les variables d'environnement dans le docker-compose.yml fichier, pensez à incorporer le env_file dans votre docker-compose.yml fichier.

Apprenons à incorporer le env_file dans le fichier de composition Docker. Encore une fois, dans le terminal :

1. Créez un fichier nommé var.env pour conserver les paramètres de votre base de données MySQL. Copiez/collez ce qui suit dans le var.env fichier et enregistrez-le dans le même ~/docker-compose-demo annuaire.

MYSQL_ROOT_PASSWORD="password_NEW"
MYSQL_ALLOW_EMPTY_PASSWORD="password_NEW"
MYSQL_RANDOM_ROOT_PASSWORD="password_NEW"

2. Ensuite, ouvrez le fichier docker-compose.yml créé précédemment à l'aide de votre éditeur préféré. Remplacez la section environnement de docker-compose.yml que vous avez créé précédemment avec env_file , et ajoutez le chemin du fichier avec - ./var.env .

Docker recherche maintenant le ./var.env fichier dans le même ~/docker-compose-demo annuaire.

version: "2.2"

services:
  mysql_svc:
    image: mysql:5.7
    hostname: mysql
    container_name: mysql
# Replacing the environment: with env_file: 
  # environment:
  #   MYSQL_ROOT_PASSWORD: ${MYSQL_ROOT_PASSWORD}
  #   MYSQL_ALLOW_EMPTY_PASSWORD: ${MYSQL_ALLOW_EMPTY_PASSWORD}
  #   MYSQL_RANDOM_ROOT_PASSWORD: ${MYSQL_RANDOM_ROOT_PASSWORD}
    env_file:
     - ./var.env

Notez que les trois paramètres et références ont maintenant disparu. Vous vous retrouvez avec une seule référence. Cela peut sembler peu dans l'exemple. Mais dans le monde réel, le nombre de références peut rapidement devenir incontrôlable.

3. Ensuite, exécutez le docker-compose commande. La commande recherche les valeurs de la variable d'environnement présente dans le var.env fichier et crée le conteneur que vous avez défini dans le fichier docker-compose.yml dossier.

Docker crée les services, ce qui signifie que Docker a trouvé les valeurs des variables d'environnement dans var.env dossier. Pour confirmer, exécutez le docker exec et le env commandes une dernière fois. Vous verrez toutes les variables d'environnement (MYSQL_ROOT_PASSWORD , MYSQL_ALLOW_EMPTY_PASSWORD , et MYSQL_RANDOM_ROOT_PASSWORD ) et leurs valeurs dans le conteneur.

Conclusion

Dans ce didacticiel, vous avez appris différentes manières de déclarer des variables d'environnement avec Docker compose. L'article vous a montré la grande flexibilité que Docker permet de déclarer les variables d'environnement en les codant directement ou en les utilisant avec des fichiers séparés.

Alors, quelle approche allez-vous utiliser ensuite lors de l'exécution de vos conteneurs Docker à partir de Docker Compose ?