Aprovechando las variables de entorno docker-compose

Si necesita definir varios valores de configuración, las variables de entorno son su mejor amigo. Como muchas herramientas, Docker y, más específicamente, Docker Compose pueden definir y leer variables de entorno para ayudar a mantener sus configuraciones limpias y modulares. Este tutorial le enseña cómo usar docker-compose variables de entorno para definir diferentes contenedores, entornos y más.

Requisitos previos

Si desea seguir paso a paso, asegúrese de tener lo siguiente:

• Un host Linux con privilegios de administrador. Este tutorial usa Ubuntu 18.04.5 LTS.
• Docker instalado en el host de Linux. Este tutorial usa Docker v19.03.11.

Declaración de variables de entorno en el archivo Docker Compose

Los contenedores pueden exigir mucha configuración. Y no todas las configuraciones en sus contenedores serán únicas. Algunas configuraciones pueden compartirse entre algunos de sus contenedores, como una credencial de base de datos MySQL. Almacene las credenciales manualmente en cada contenedor y, cuando las credenciales cambien, tendrá que actualizarlas varias veces.

Las variables de entorno pueden reducir esa molestia. ¡Almacene esas configuraciones compartidas como variables de entorno! Haga referencia a las variables de entorno en lugar de repetirse en los contenedores. Cuando las credenciales cambian, debe actualizar solo una configuración:la variable de entorno.

Comencemos declarando una variable de entorno y almacenándola en el propio archivo Docker Compose. Los pasos siguientes almacenarán la configuración de una base de datos MySQL hipotética en variables de entorno.

1. Abra una terminal en su máquina local.

2. Cree una carpeta llamada ~/docker-compose-demo, luego cambie (cd ) el directorio de trabajo a la carpeta que acaba de crear. El ~/docker-compose-demostración La carpeta contendrá todos los archivos que creará en este tutorial.

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

3. Abra su editor de texto favorito, copie/pegue el código en el fragmento a continuación en el editor de texto. Guarde el archivo como docker-compose.yml dentro de ~/docker-compose-demo directorio. docker-compose.yml almacena las configuraciones para los servicios de su aplicación.

En el fragmento de código a continuación:

• mysql:5.7 es la imagen base que Docker Compose extrae y crea un nuevo contenedor.
• MYSQL_ROOT_PASSWORD , MYSQL_ALLOW_EMPTY_PASSWORD y MYSQL_RANDOM_ROOT_PASSWORD son tres variables de entorno diferentes dentro del archivo Docker Compose. Cada variable de entorno se declara con sus valores. El valor que obtiene la variable de entorno viene después de : símbolo.
• mysql service creará el contenedor llamado 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"

Algunos contenedores se basan en variables de entorno para funcionar correctamente. El del ejemplo, MySQL, es uno de estos contenedores. Si no declara las variables de entorno que espera el contenedor, arrojará un error. Puedes ver el error a continuación.

4. A continuación, ejecute docker-compose up dominio. El docker-compose up El comando lee el archivo YAML (docker-compose.yml ) creado en el paso anterior y crea el contenedor. El docker-compose up El comando inicia todos los servicios configurados en el archivo Docker Compose.

5. Ahora, verifique si las tres variables de entorno están presentes en el contenedor ejecutando docker exec comando y el env dominio.

Ejecutar el comando docker exec le permitirá iniciar sesión en el contenedor. Ejecutando env imprimirá la lista de las variables de entorno actuales con sus respectivos valores.

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

Sustitución de las variables de entorno

En la sección anterior, aprendió cómo declarar las variables de entorno directamente dentro del archivo Docker Compose al codificarlas. Este enfoque no es óptimo si necesita proteger sus credenciales. Como alternativa, almacene los valores de las variables de entorno en un archivo llamado .env que solo el administrador puede leer.

Practiquemos el uso de la sustitución de variables de entorno. En tu terminal:

1. Cree un archivo llamado .env en el mismo ~/docker-compose-demo directorio y copie el código a continuación en .env expediente. El archivo tendrá todas las variables de entorno con sus respectivos valores.

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

2. A continuación, edite los permisos de .env archivo que creó en el paso anterior usando el comando setfacl. El siguiente comando asegura que el usuario raíz tenga permisos de lectura/escritura para .env archivo.

• m El parámetro le permite establecer los permisos para los archivos/carpetas.
• u es el usuario (root ) que tendrá permisos otorgados al archivo especificado ~/*docker-compose-demo/.env

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

3. A continuación, edite y abra el archivo docker-compose.yml con su editor favorito y comente la sección de entorno en docker-compose.yml de la sección anterior. Agregue el código a continuación para establecer valores predeterminados para las variables de entorno en el archivo Compose.

Docker establece los valores a través de la línea de comando o leyendo archivos, como .env archivo en el ejemplo. En cualquier caso, Docker reemplaza los valores en consecuencia.

# 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} 

El código define las variables aplicando el método de interpolación de cadenas. Las variables con interpolación de cadenas se declaran como ${variable}. Docker establece los valores de las variables de entorno en tiempo de ejecución.

4. Nuevamente, ejecute docker-compose up dominio. Cuando ejecuta docker-compose up comando, el docker-compose.yml El archivo busca los valores de las variables de entorno en .env expediente. docker-compose El comando busca automáticamente un .env archivo en el directorio del proyecto o en la carpeta principal de su archivo de redacción.

Tan pronto como docker-compose encuentra el valor de las variables de entorno establecidas en docker-compose.yml en el .env archivo, Compose sustituye los valores correspondientes e inicia el servicio. Al iniciar el servicio, se crea el contenedor definido en docker-compose.yml archivo.

Uso de múltiples archivos de variables de entorno para múltiples entornos

Hasta ahora, ha aprendido dos enfoques para declarar las variables de entorno. El primero es declarar variables de entorno dentro de docker-compose.yml expediente. El segundo enfoque es declarar las variables de entorno dentro de un solo .env archivo y aplicar la sustitución.

Ambos enfoques son adecuados cuando se trabaja con un solo entorno. Si tiene varios entornos, como Producción y/o Pruebas, necesita un enfoque diferente. Veamos cómo crear múltiples .env ¡archivos con diferentes nombres para que coincidan con sus entornos!

El siguiente ejemplo emulará los entornos habituales que se pueden encontrar en las operaciones de TI:desarrollo, control de calidad y producción. De vuelta en su terminal:

1. Navegue a su ~/docker-compose-demo directorio y cree un .env.dev expediente. Copie/pegue el contenido del fragmento de código a continuación en el archivo y guárdelo. Este archivo contendrá el uso de configuración para su base de datos del entorno de desarrollo MySQL.

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

2. En el mismo directorio, cree un .env.qa y guarde el contenido del fragmento de código a continuación en el archivo. Estas son las configuraciones para su base de datos del entorno de control de calidad de MySQL.

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

3. Ahora cree un .env.prod para almacenar la configuración de la base de datos hipotética del entorno de producción de MySQL. Los contenidos son los siguientes:

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

4. A continuación, ejecute docker-compose comando con el --env-file opción, especificando .env.dev expediente. docker-compose El comando busca .env.dev archivo en el ~/docker-compose-demo actual directorio.

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

Pasar el archivo como argumento le permite almacenar el archivo en cualquier lugar y con un nombre apropiado.

Como puede ver a continuación, puede elegir fácilmente los diferentes archivos de entorno e implementarlos reemplazando .env.dev archivo a .env.qa o el .env.prod expediente.

# 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. Ahora, verifique si el archivo de configuración (.env.dev ) se ha leído correctamente al ejecutar docker exec dominio. Ejecutar el comando docker exec le permitirá iniciar sesión en el contenedor. Ejecutando env imprimirá la lista de las variables de entorno actuales.

Observe que las tres variables de entorno (MYSQL_ROOT_PASSWORD , MYSQL_ALLOW_EMPTY_PASSWORD y MYSQL_RANDOM_ROOT_PASSWORD ) están presentes en el contenedor. Observe que sus valores provienen de env.dev expediente.

Incorporando el env_file en el archivo de redacción de Docker

En la sección anterior, vio cómo declarar las variables de entorno en .env archivos Cuando almacena valores de variables de entorno en .env archivo por separado, terminará con muchas líneas y referencias en docker-compose.yml .

Para reducir las referencias y el número de líneas de las variables de entorno en docker-compose.yml considere incorporar el archivo env_file en su docker-compose.yml archivo.

Aprendamos cómo incorporar el env_file en el archivo de redacción de Docker. Una vez más, en la terminal:

1. Cree un archivo llamado var.env para mantener la configuración de su base de datos MySQL. Copie y pegue lo siguiente en var.env y guárdelo en el mismo ~/docker-compose-demo directorio.

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

2. A continuación, abra el archivo docker-compose.yml creado anteriormente. utilizando su editor favorito. Reemplace la sección de entorno de docker-compose.yml que creaste previamente con env_file y agregue la ruta del archivo con - ./var.env .

Docker ahora busca ./var.env archivo en el mismo ~/docker-compose-demo directorio.

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

Observe que las tres configuraciones y referencias ya no están. Te quedas con una sola referencia. Puede que no parezca mucho en el ejemplo. Pero en el mundo real, la cantidad de referencias puede salirse de control muy rápido.

3. A continuación, ejecute docker-compose dominio. El comando busca los valores de la variable de entorno presente en el var.env y crea el contenedor que definió en docker-compose.yml expediente.

Docker crea los servicios, lo que significa que Docker encontró los valores para las variables de entorno en var.env expediente. Para confirmar, ejecute docker exec y el env ordena por última vez. Verá todas las variables de entorno (MYSQL_ROOT_PASSWORD , MYSQL_ALLOW_EMPTY_PASSWORD y MYSQL_RANDOM_ROOT_PASSWORD ) y sus valores en el contenedor.

Conclusión

En este tutorial, aprendió diferentes formas de declarar variables de entorno con Docker compose. El artículo le mostró la gran flexibilidad que permite Docker al declarar las variables de entorno, ya sea codificándolas directamente o usándolas con archivos separados.

Entonces, ¿qué enfoque utilizará a continuación mientras ejecuta sus contenedores Docker desde Docker Compose?