La solution DOCKER:

Il semble que docker-compose 1.5 + ait activé la substitution des variables: https://github.com/docker/compose/releases

Le Dernier Docker Compose vous permet d'accéder aux variables d'environnement à partir de votre fichier de composition. Vous pouvez donc source vos variables d'environnement, puis exécuter composer comme suit:

set -a
source .my-env
docker-compose up -d

Ensuite, vous pouvez référencer les variables dans Docker-compose.yml en utilisant ${VARIABLE}, comme ceci:

db:
  image: "postgres:${POSTGRES_VERSION}"

Et voici plus d'informations de les docs, pris ici: https://docs.docker.com/compose/compose-file/#variable-substitution

Lorsque vous exécutez docker-compose avec cette configuration, composez des looks pour la variable D'environnement POSTGRES_VERSION dans le shell et substitue sa valeur en. Pour cet exemple, Composer résout l'image pour postgres: 9.3 avant d'exécuter la configuration.

Si une variable d'environnement n'est pas définie, composez des substituts avec chaîne vide. Dans l'exemple ci-dessus, si POSTGRES_VERSION n'est pas défini, la valeur de l'option image est postgres:.

Les syntaxes $VARIABLE et ${VARIABLE} sont prises en charge. Proroger caractéristiques de style shell, telles que ${VARIABLE-default} et ${VARIABLE / foo / bar}, ne sont pas pris en charge.

Si vous devez placer un signe dollar littéral dans une valeur de configuration, utilisez un signe double dollar ($$).

Et je crois que cette fonctionnalité a été ajoutée dans cette demande de tirage: https://github.com/docker/compose/pull/1765

La solution BASH:

Je remarque que les gens ont des problèmes avec le support des variables d'environnement de Docker. Au lieu de traiter les variables d'environnement dans Docker, revenons aux bases, comme bash! Voici une méthode plus flexible utilisant un script bash et un fichier .env.

Un exemple .fichier env

EXAMPLE_URL=http://example.com
# Note that the variable below is commented out and will not be used:
# EXAMPLE_URL=http://example2.com 
SECRET_KEY=ABDFWEDFSADFWWEFSFSDFM

# You can even define the compose file in an env variable like so:
COMPOSE_CONFIG=my-compose-file.yml
# You can define other compose files, and just comment them out
# when not needed:
# COMPOSE_CONFIG=another-compose-file.yml

Ensuite, exécutez ce script bash dans le même répertoire, qui devrait tout déployer correctement:

#!/bin/bash

docker rm -f `docker ps -aq -f name=myproject_*`
set -a
source .env
cat ${COMPOSE_CONFIG} | envsubst | docker-compose -f - -p "myproject" up -d

Référencez simplement vos variables env dans votre fichier de composition avec la syntaxe bash habituelle (c'est-à-dire ${SECRET_KEY} pour insérer le SECRET_KEY à partir du fichier .env).

Notez l' COMPOSE_CONFIG est définie dans mon .env fichier et utilisé dans mon script bash, mais vous pouvez facilement remplacer {$COMPOSE_CONFIG} avec my-compose-file.yml dans le script bash.

Notez également que j'ai étiqueté ce déploiement en nommant tous mes conteneurs avec le préfixe "myproject". Vous pouvez utiliser n'importe quel nom que vous voulez, mais il permet d'identifier votre conteneurs afin que vous puissiez facilement les référencer plus tard. En supposant que vos conteneurs sont sans état, comme ils devraient l'être, ce script supprimera et redéploiera rapidement vos conteneurs en fonction de votre .env fichier params et votre composer le fichier YAML.

Mise à Jour Comme cette réponse semble assez populaire, j'ai écrit un article de blog qui décrit Mon flux de travail de déploiement Docker plus en profondeur: http://lukeswart.net/2016/03/lets-deploy-part-1 / cela peut être utile lorsque vous ajoutez plus complexité d'une configuration de déploiement, comme les configurations nginx, les certificats LetsEncrypt et les conteneurs liés.

Lorsque vous utilisez des variables d'environnement pour les volumes, vous devez:

1. Créer .env fichier dans le même dossier qui contient docker-compose.yaml fichier

2. Déclarer la variable dans le fichier .env:

   HOSTNAME=your_hostname
   

3. Modifier $hostname à ${HOSTNAME} à docker-compose.yaml fichier

   proxy:
     hostname: ${HOSTNAME}
     volumes:
       - /mnt/data/logs/${HOSTNAME}:/logs
       - /mnt/data/${HOSTNAME}:/data
   

Bien sûr, vous pouvez le faire dynamiquement sur chaque build comme:

echo "HOSTNAME=your_hostname" > .env && sudo docker-compose up

Il semble que docker-compose ait maintenant un support natif pour les variables d'environnement par défaut dans le fichier .

Tout ce que vous devez faire est de déclarer vos variables dans un fichier nommé .env et elles seront disponibles dans Docker-compose.yml.

Par exemple, pour le fichier .env avec le contenu:

MY_SECRET_KEY=SOME_SECRET
IMAGE_NAME=docker_image

Vous pouvez accéder à votre variable à l'intérieur de docker-compose.yml ou les transférer dans le conteneur:

my-service:
  image: ${IMAGE_NAME}
  environment:
    MY_SECRET_KEY: ${MY_SECRET_KEY}

Vous ne pouvez pas ... encore. Mais c'est une alternative, pensez comme un docker-compositeur.générateur yml:

Https://gist.github.com/Vad1mo/9ab63f28239515d4dafd

Fondamentalement un script shell qui remplacera vos variables. Vous pouvez également utiliser Grunt task pour construire votre fichier de composition docker à la fin de votre processus CI.

J'ai un script bash simple que j'ai créé pour cela, cela signifie simplement l'exécuter sur votre fichier avant utilisation: https://github.com/antonosmond/subber

Fondamentalement, créez simplement votre fichier de composition en utilisant des accolades doubles pour désigner des variables d'environnement, par exemple:

app:
    build: "{{APP_PATH}}"
ports:
    - "{{APP_PORT_MAP}}"

Tout ce qui est en accolades doubles sera remplacé par la variable d'environnement du même nom, donc si j'avais défini les variables d'environnement suivantes:

APP_PATH=~/my_app/build
APP_PORT_MAP=5000:5000

Sur l'exécution de subber docker-compose.yml le fichier résultant ressemblerait comme:

app:
    build: "~/my_app/build"
ports:
    - "5000:5000"

Le meilleur moyen est de spécifier des variables d'environnement en dehors du fichier docker-compose.yml. Vous pouvez utiliser le paramètre env_file et définir votre fichier d'environnement sur la même ligne. Ensuite, faire un docker-compose à nouveau devrait recréer les conteneurs avec les nouvelles variables d'environnement.

Voici comment mon menu fixe-composer.yml ressemble à:

services:
  web:
    env_file: variables.env

Note: docker-compose s'attend à ce que chaque ligne d'un fichier env soit au format VAR=VAL. Évitez d'utiliser export dans le fichier .env. En outre, le fichier .env devrait être placé dans le dossier où la commande Docker-compose est exécutée.

Pour autant que je sache, c'est un travail en cours. Ils veulent le faire, mais ce n'est pas encore sorti. Tu vois 1377 (le "nouveau" 495 cela a été mentionné par @ Andy).

J'ai fini par implémenter le " générer .yml dans le cadre de L'approche CI " proposée par @ Thomas.

Ajouter env à .fichier env

Tels que

VERSION=1.0.0

Puis enregistrez-le dans deploy.sh

INPUTFILE=docker-compose.yml
RESULT_NAME=docker-compose.product.yml
NAME=test

prepare() {
        local inFile=$(pwd)/$INPUTFILE
        local outFile=$(pwd)/$RESULT_NAME
        cp $inFile $outFile
        while read -r line; do
            OLD_IFS="$IFS"
            IFS="="
            pair=($line)
            IFS="$OLD_IFS"
               sed -i -e "s/\${${pair[0]}}/${pair[1]}/g" $outFile
            done <.env
     }

deploy() {
        docker stack deploy -c $outFile $NAME
}


prepare
deploy