Verwendung der Dateien args :, environment :, env_file: und .env mit dem Befehl docker-compose

Ich habe mich wegen der Verwendung von "args:", "environment:", "environment:", "env_file:" und der ".env" -Datei in docker-compose v3 verlaufen, also habe ich es für mich selbst organisiert.

Zusammenfassung

Über args:

Es ist eine "Build-Variable" ――So existiert es zum Zeitpunkt des "Laufens" nicht
Wenn Sie dieselbe Variable deklarieren, ist dies "docker-compose.yml> Dockerfile" --Die Deklaration in "docker-compose.yml" entspricht der Deklaration in "Dockerfile".

Über Umwelt:

Sie können Umgebungsvariablen festlegen --Die in docker-compose.yml deklarierten Variablen werden zum Zeitpunkt von run hinzugefügt / überschrieben.
Beachten Sie, dass das, was Sie mit der Anweisung "ENV" von "Dockerfile" deklarieren, zum Zeitpunkt der Erstellung wie eine Variable der Anweisung "ARG" verwendet werden kann. --Und zum Zeitpunkt von build müssen Sie vorsichtig sein, da die in docker-compose.yml deklarierte Variable nicht wie oben erwähnt übergeben wird.

Über env_file:

Es ist ein Mechanismus zum Hinzufügen von Umgebungsvariablen aus einer Datei
Wenn eine Umgebungsvariable mit demselben Namen vorhanden ist, lautet die Priorität "Umgebung:> env_file:"
Wenn Sie mehrere "env_file:" angeben, wird der letztere Wert in der Liste hinzugefügt / überschrieben.

Über .env

Die spezielle Datei, die von "Docker-Compose" verwendet wird, ist ".env".
Die Datei, die die Variablensubstitutionsfunktion bequem macht, ist ".env".
(Wahrscheinlich) Sie können den Dateinamen .env nicht als anderen Namen verwenden. --Variationen, die in .env deklariert und definiert sind, können als Variablen in docker-compose.yml verwendet werden.

Der Code lautet https://github.com/hokutoasari/how-to-use-args-environment-env-file-dotenv-file-with-docker-compose.

Verwendung von Argumenten:

Erstens das offizielle Dokument.

https://docs.docker.com/compose/compose-file/#args

Add build arguments, which are environment variables accessible only during the build process.

Kostenlose Übersetzung: Sie können Variablen für den Build festlegen.

Ein Mechanismus, mit dem Sie Build-Variablen festlegen können.

Da "Umgebungsvariablen" mit den sogenannten "Umgebungsvariablen" verwechselt werden, die durch "Umgebung:" später beschrieben werden, wird sie hier als "Build-Variablen" gelesen.

ARG_VALUE1 - Deklarieren und setzen Sie die Werte wie folgt auf ARG_VALUE4 und überprüfen Sie das Verhalten.

	Dockerfile	docker-compose.yml
ARG_VALUE1	arg1_in_Dockerfile
ARG_VALUE2	arg2_in_Dockerfile	arg2_in_yml
ARG_VALUE3		arg3_in_yml
ARG_VALUE4

./args/Dockerfile

`./args/Dockerfile`


FROM busybox

ARG ARG_VALUE1="arg1_in_Dockerfile."
ARG ARG_VALUE2="arg2_in_Dockerfile."

RUN echo "ARG_VALUE1 is ${ARG_VALUE1}" \
  && echo "ARG_VALUE2 is ${ARG_VALUE2}" \
  && echo "ARG_VALUE3 is ${ARG_VALUE3}" \
  && echo "ARG_VALUE4 is ${ARG_VALUE4}"
RUN echo "ARG_VALUE1 is $ARG_VALUE1" >> /tmp/outs.txt \
  && echo "ARG_VALUE2 is $ARG_VALUE2" >> /tmp/outs.txt \
  && echo "ARG_VALUE3 is $ARG_VALUE3" >> /tmp/outs.txt \
  && echo "ARG_VALUE4 is $ARG_VALUE4" >> /tmp/outs.txt

CMD cat /tmp/outs.txt \
  && echo "-----" \
  && echo "ARG_VALUE1 is ${ARG_VALUE1}" \
  && echo "ARG_VALUE2 is ${ARG_VALUE2}" \
  && echo "ARG_VALUE3 is ${ARG_VALUE3}" \
  && echo "ARG_VALUE4 is ${ARG_VALUE4}"

./args/docker-compose.yml

`./args/docker-compose.yml`


version: '3'
services:
  with-args:
    build:
      context: ./
      args:
        ARG_VALUE2: "arg2_in_yml"
        ARG_VALUE3: "arg3_in_yml"

Lauf.

% docker-compose build --no-cache && docker-compose up
...Abkürzung...
Step 4/6 : RUN echo "ARG_VALUE1 is ${ARG_VALUE1}"   && echo "ARG_VALUE2 is ${ARG_VALUE2}"   && echo "ARG_VALUE3 is ${ARG_VALUE3}"   && echo "ARG_VALUE4 is ${ARG_VALUE4}"
 ---> Running in 64893f52d5bc
ARG_VALUE1 is arg1_in_Dockerfile.
ARG_VALUE2 is arg2_in_yml
ARG_VALUE3 is
ARG_VALUE4 is
Removing intermediate container 64893f52d5bc
 ---> a66e7626d5eb
...Abkürzung...
[Warning] One or more build-args [ARG_VALUE3] were not consumed
...Abkürzung...
with-args_1  | ARG_VALUE1 is arg1_in_Dockerfile.
with-args_1  | ARG_VALUE2 is arg2_in_yml
with-args_1  | ARG_VALUE3 is
with-args_1  | ARG_VALUE4 is
with-args_1  | -----
with-args_1  | ARG_VALUE1 is
with-args_1  | ARG_VALUE2 is
with-args_1  | ARG_VALUE3 is
with-args_1  | ARG_VALUE4 is
args_with-args_1 exited with code 0

Ergebnis.

	Dockerfile	docker-compose.yml	Zur Bauzeit
ARG_VALUE1	arg1_in_Dockerfile		arg1_in_Dockerfile
ARG_VALUE2	arg2_in_Dockerfile	arg2_in_yml	arg2_in_yml
ARG_VALUE3		arg3_in_yml	[Warning]
ARG_VALUE4

Der Wert wird von args: in docker-compose.yml überschrieben --Warnung, wenn nicht verwendete Variablen in args: in docker-compose.yml deklariert sind
Es gibt keine Warnung für Variablen, die in "Dockerfile" verwendet werden, aber nicht in "docker-compose.yml" deklariert sind. ――Natürlich ist es zum Zeitpunkt des "Laufens" nicht verfügbar

So verwenden Sie die Umgebung:

Erstens das offizielle Dokument.

https://docs.docker.com/compose/compose-file/#environment

Add environment variables.

Ein Mechanismus, mit dem Sie Umgebungsvariablen hinzufügen können.

Im Gegensatz zu der oben erwähnten "Build-Variablen" ist dies eine Anweisung zum Setzen der sogenannten "Umgebungsvariablen".

ENV_VALUE1 - Deklarieren und setzen Sie die Werte wie folgt auf ENV_VALUE4 und überprüfen Sie das Verhalten.

	Dockerfile	docker-compose.yml
ENV_VALUE1	env1_in_Dockerfile
ENV_VALUE2	env2_in_Dockerfile	env2_in_yml
ENV_VALUE3		env3_in_yml
ENV_VALUE4

./environment/Dockerfile

**`./environment/Dockerfile*`**


FROM busybox

ENV ENV_VALUE1="env1_in_Dockerfile."
ENV ENV_VALUE2="env2_in_Dockerfile."

RUN echo "ENV_VALUE1 is ${ENV_VALUE1}" \
  && echo "ENV_VALUE2 is ${ENV_VALUE2}" \
  && echo "ENV_VALUE3 is ${ENV_VALUE3}" \
  && echo "ENV_VALUE4 is ${ENV_VALUE4}" \
RUN echo "ENV_VALUE1 is $ENV_VALUE1" >> /tmp/outs.txt \
  && echo "ENV_VALUE2 is $ENV_VALUE2" >> /tmp/outs.txt \
  && echo "ENV_VALUE3 is $ENV_VALUE3" >> /tmp/outs.txt \
  && echo "ENV_VALUE4 is $ENV_VALUE4" >> /tmp/outs.txt

CMD cat /tmp/outs.txt \
  && echo "-----" \
  && echo "ENV_VALUE1 is ${ENV_VALUE1}" \
  && echo "ENV_VALUE2 is ${ENV_VALUE2}" \
  && echo "ENV_VALUE3 is ${ENV_VALUE3}" \
  && echo "ENV_VALUE4 is ${ENV_VALUE4}"

./environment/docker-compose.yml

`./environment/docker-compose.yml`


version: '3'
services:
  with-environment:
    environment:
      ENV_VALUE2: "env2_in_yml"
      ENV_VALUE3: "env3_in_yml"

Lauf.

% docker-compose build --no-cache && docker-compose up
...Abkürzung...
Step 4/6 : RUN echo "ENV_VALUE1 is ${ENV_VALUE1}"   && echo "ENV_VALUE2 is ${ENV_VALUE2}"   && echo "ENV_VALUE3 is ${ENV_VALUE3}"   && echo "ENV_VALUE4 is ${ENV_VALUE4}"
 ---> Running in bb4ae383c1e7
ENV_VALUE1 is env1_in_Dockerfile.
ENV_VALUE2 is env2_in_Dockerfile.
ENV_VALUE3 is
ENV_VALUE4 is
Removing intermediate container bb4ae383c1e7
 ---> a01b51cd008a
...Abkürzung...
with-environment_1  | ENV_VALUE1 is env1_in_Dockerfile.
with-environment_1  | ENV_VALUE2 is env2_in_Dockerfile.
with-environment_1  | ENV_VALUE3 is
with-environment_1  | ENV_VALUE4 is
with-environment_1  | -----
with-environment_1  | ENV_VALUE1 is env1_in_Dockerfile.
with-environment_1  | ENV_VALUE2 is env2_in_yml
with-environment_1  | ENV_VALUE3 is env3_in_yml
with-environment_1  | ENV_VALUE4 is
environment_with-environment_1 exited with code 0

Ergebnis.

	Dockerfile	docker-compose.yml	Zur Bauzeit	Beim Ausführen
ENV_VALUE1	env1_in_Dockerfile		env1_in_Dockerfile	env1_in_Dockerfile
ENV_VALUE2	env2_in_Dockerfile	env2_in_yml	env2_in_Dockerfile	env2_in_yml
ENV_VALUE3		env3_in_yml		env3_in_yml
ENV_VALUE4

Zum Zeitpunkt des "Builds" wird der in "Dockerfile" beschriebene Wert verwendet.
Zum Zeitpunkt von "run" wird der in "docker-compose.yml" festgelegte Wert übergeben und überschrieben. --ENV Anweisung und Umgebung: Beachten Sie bis zuletzt, dass Umgebungsvariablen festgelegt werden.
Beachten Sie, dass der durch die Anweisung "ENV" vorbereitete Wert zum Zeitpunkt der Erstellung als "Build-Variable" verwendet werden kann.

So verwenden Sie env_file:

Erstens das offizielle Dokument.

https://docs.docker.com/compose/compose-file/#env_file

Add environment variables from a file.

Ein Mechanismus zum Hinzufügen sogenannter Umgebungsvariablen aus einer "Datei".

ENV_VALUE1 - Deklarieren und setzen Sie die Werte wie folgt auf ENV_VALUE5 und überprüfen Sie das Verhalten.

	Dockerfile	docker-compose.yml	some_env.env
ENV_VALUE1	env1_in_Dockerfile
ENV_VALUE2	env2_in_Dockerfile	env2_in_yml
ENV_VALUE3		env3_in_yml	env3_in_file
ENV_VALUE4			env4_in_file
ENV_VALUE5

./env_file/Dockerfile

`./env_file/Dockerfile`


FROM busybox

ENV ENV_VALUE1="env1_in_Dockerfile."
ENV ENV_VALUE2="env2_in_Dockerfile."

RUN echo "ENV_VALUE1 is ${ENV_VALUE1}" \
  && echo "ENV_VALUE2 is ${ENV_VALUE2}" \
  && echo "ENV_VALUE3 is ${ENV_VALUE3}" \
  && echo "ENV_VALUE4 is ${ENV_VALUE4}" \
  && echo "ENV_VALUE5 is ${ENV_VALUE5}"
RUN echo "ENV_VALUE1 is $ENV_VALUE1" >> /tmp/outs.txt \
  && echo "ENV_VALUE2 is $ENV_VALUE2" >> /tmp/outs.txt \
  && echo "ENV_VALUE3 is $ENV_VALUE3" >> /tmp/outs.txt \
  && echo "ENV_VALUE4 is $ENV_VALUE4" >> /tmp/outs.txt \
  && echo "ENV_VALUE5 is $ENV_VALUE5" >> /tmp/outs.txt

CMD cat /tmp/outs.txt \
  && echo "-----" \
  && echo "ENV_VALUE1 is ${ENV_VALUE1}" \
  && echo "ENV_VALUE2 is ${ENV_VALUE2}" \
  && echo "ENV_VALUE3 is ${ENV_VALUE3}" \
  && echo "ENV_VALUE4 is ${ENV_VALUE4}" \
  && echo "ENV_VALUE5 is ${ENV_VALUE5}"

./env_file/docker-compose.yml

`./env_file/docker-compose.yml`


version: '3'
services:
  with-env_file:
    build:
      context: ./
    environment:
      ENV_VALUE2: "env2_in_yml"
      ENV_VALUE3: "env3_in_yml"
    env_file:
      - some_env.env

./env_file/some_env.env

`./env_file/some_env.env`


ENV_VALUE3="env3_in_file"
ENV_VALUE4="env4_in_file"

Lauf.

% docker-compose build --no-cache && docker-compose up
...Abkürzung...
Step 4/6 : RUN echo "ENV_VALUE1 is ${ENV_VALUE1}"   && echo "ENV_VALUE2 is ${ENV_VALUE2}"   && echo "ENV_VALUE3 is ${ENV_VALUE3}"   && echo "ENV_VALUE4 is ${ENV_VALUE4}"   && echo "ENV_VALUE5 is ${ENV_VALUE5}"
 ---> Running in 5851a9b3aa91
ENV_VALUE1 is env1_in_Dockerfile.
ENV_VALUE2 is env2_in_Dockerfile.
ENV_VALUE3 is
ENV_VALUE4 is
ENV_VALUE5 is
Removing intermediate container 5851a9b3aa91
 ---> 39f56354d7cd
...Abkürzung...
with-env_file_1  | ENV_VALUE1 is env1_in_Dockerfile.
with-env_file_1  | ENV_VALUE2 is env2_in_Dockerfile.
with-env_file_1  | ENV_VALUE3 is
with-env_file_1  | ENV_VALUE4 is
with-env_file_1  | ENV_VALUE5 is
with-env_file_1  | -----
with-env_file_1  | ENV_VALUE1 is env1_in_Dockerfile.
with-env_file_1  | ENV_VALUE2 is env2_in_yml
with-env_file_1  | ENV_VALUE3 is env3_in_yml
with-env_file_1  | ENV_VALUE4 is env4_in_file
with-env_file_1  | ENV_VALUE5 is
env_file_with-env_file_1 exited with code 0

Ergebnis.

	Dockerfile	docker-compose.yml	some_env.env	Zur Bauzeit	Beim Ausführen
ENV_VALUE1	env1_in_Dockerfile			env1_in_Dockerfile	env1_in_Dockerfile
ENV_VALUE2	env2_in_Dockerfile	env2_in_yml		env2_in_Dockerfile	env2_in_yml
ENV_VALUE3		env3_in_yml	env3_in_file		env3_in_yml
ENV_VALUE4			env4_in_file		env4_in_file
ENV_VALUE5

Der Wert von environment: hat Vorrang vor dem Wert von env_file: --Wenn in "env_file:" angegeben und nicht in "docker-compose.yml" festgelegt, wird der in "env_file:" angegebene Wert verwendet.
Obwohl ich nicht experimentiert habe, wie im Dokument beschrieben, wird der letztere Wert in der Liste hinzugefügt / überschrieben, wenn Sie mehrere Dateien in "env_file:" angeben.

Verwendung der ENV-Datei

Die .env-Datei ist eine Datei, die speziell in Docker-Compose behandelt wird.

Wird in der Variablenersetzungsfunktion verwendet.

Variable Austauschfunktion

Die .env-Datei wird von der Variablenersetzungsfunktion von "Docker-Compose" verwendet. Versuchen Sie also zuerst die Variablenersetzungsfunktion.

Offizielle Dokumentation. https://docs.docker.com/compose/compose-file/#variable-substitution

Your configuration options can contain environment variables. Compose uses the variable values from the shell environment in which docker-compose is run.

Kostenlose Übersetzung: Sie können die Umgebungsvariable der Shell, die "Docker-Compose" ausführt, als Variable für Docker-Compose verwenden.

Bereiten Sie . / Variable-substitution / docker-compose.yml mit den folgenden Inhalten vor.

`./variable-substitution/docker-compose.yml`


version: '3'
services:
  variable-substitution:
    image: busybox:${BUSYBOX_VERSION}

Setzen Sie vorübergehend die Umgebungsvariable BUSYBOX_VERSION = latest und docker-compose up. (Da kein "Build" erforderlich ist, wird es direkt "aufgebaut".)

% env BUSYBOX_VERSION="latest" docker-compose up
...Abkürzung...
variable-substitution_variable-substitution_1 exited with code 0

Ich zog es sicher hoch und fertig.

Setzen Sie in ähnlicher Weise BUSYBOX_VERSION = musl auf die Umgebungsvariable und do docker-compose up.

% env BUSYBOX_VERSION="musl" docker-compose up
...Abkürzung...
variable-substitution_variable-substitution_1 exited with code 0

Dies wurde auch erfolgreich hochgezogen und beendet.

Überprüfen Sie zur Bestätigung die Bildliste mit "Docker-Bildern".

% docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
busybox             musl                8bce8d24824c        5 weeks ago         1.47MB
busybox             latest              f0b02e9d092d        5 weeks ago         1.23MB

Natürlich habe ich bestätigt, dass es ein Bild mit "neuesten", "musl" TAG gibt.

Auf diese Weise hat "Docker-Compose" einen Mechanismus, um die Umgebungsvariablen der Umgebung, in der die Shell ausgeführt wird, an "Docker-Compose" zu übergeben.

Dies ist eine der variablen Ersetzungsfunktionen.

.env Datei

Die offizielle Dokumentation sagt:

https://docs.docker.com/compose/compose-file/#variable-substitution

You can set default values for environment variables using a .env file, which Compose automatically looks for. Values set in the shell environment override those set in the .env file.

Kostenlose Übersetzung: docker-compose setzt die Standardumgebungsvariable, wenn die .env`-Datei gefunden wird. Außerdem werden die aus den Umgebungsvariablen der Shell festgelegten Werte mit den in der Datei ".env" festgelegten Werten überschrieben.

Bereiten Sie die Datei . / Variable-substitution-dotenv / .env wie unten gezeigt vor.

`./variable-substitution-dotenv/.env`


BUSYBOX_VERSION=latest

Gleicher Inhalt wie zuvor, aber bereiten Sie ". / Variable-substitution-dotenv / docker-compose.yml" vor.

`./variable-substitution-dotenv/docker-compose.yml`


version: '3'
services:
  variable-substitution-dotenv:
    image: busybox:${BUSYBOX_VERSION}

Versuchen Sie in diesem Zustand "up", ohne eine temporäre Umgebungsvariable festzulegen.

Es ist möglicherweise einfacher, den Vorgang zu verstehen, wenn Sie den vorgefertigten Container aus "Docker RM" löschen und die gezogenen Bilder auch mit "Docker RMI" löschen.

% docker-compose up
Creating network "variable-substitution-dotenv_default" with the default driver
Pulling variable-substitution-dotenv (busybox:latest)...
latest: Pulling from library/busybox
9758c28807f2: Pull complete
Digest: sha256:a9286defaba7b3a519d585ba0e37d0b2cbee74ebfe590960b0b1d6a5e97d1e1d
Status: Downloaded newer image for busybox:latest
Creating variable-substitution-dotenv_variable-substitution-dotenv_1 ... done
Attaching to variable-substitution-dotenv_variable-substitution-dotenv_1

Sie können sehen, dass "Neueste" erfolgreich aufgerufen wurde.

Schreiben Sie als Nächstes . / Variable-substitution-dotenv / .env in den folgenden Inhalt.

`./variable-substitution-dotev/.env`


BUSYBOX_VERSION=musl

Versuchen Sie in diesem Zustand erneut "Docker-Compose Up".

% docker-compose up
Pulling variable-substitution-dotenv (busybox:musl)...
musl: Pulling from library/busybox
7c3804618ebb: Pull complete
Digest: sha256:605de95bca536139f324abdecf88dcab492c8457346e7fc92e37dff6e263f341
Status: Downloaded newer image for busybox:musl
Recreating variable-substitution-dotenv_variable-substitution-dotenv_1 ... done
Attaching to variable-substitution-dotenv_variable-substitution-dotenv_1
variable-substitution-dotenv_variable-substitution-dotenv_1 exited with code 0

Sie können sehen, dass musl erfolgreich hochgezogen wurde.

Auf diese Weise ermöglicht die Verwendung der Datei ".env" die Übergabe von Variablen an "Docker-Compose", ohne die Umgebungsvariablen der Shell-Ausführungsumgebung zu verschmutzen.

Das offizielle Dokument enthält übrigens die folgenden Hinweise.

Note when using docker stack deploy The .env file feature only works when you use the docker-compose up command and does not work with docker stack deploy.

Freie Übersetzung

Hinweis: Für diejenigen, die "Docker Stack Deploy" verwenden Diese Funktion mit der Datei ".env" funktioniert nur mit dem Befehl "docker-compose up". Es funktioniert nicht mit "Docker Stack Deploy".

Da es sich bei der Verwendung von "Docker Stack Deploy" um einen Hinweis handelt, wird er meiner Meinung nach so geschrieben, dass er nur funktioniert, wenn Sie den Befehl "Docker-Compose Up" verwenden. In Wirklichkeit handelt es sich jedoch nicht nur um den Befehl "Docker-Compose Up", sondern auch um "Docker-Compose Up" `Arbeit für Befehle.

Insbesondere funktioniert es auch mit den Befehlen "Docker-Compose Build" und "Docker-Compose Config".

Wenn Sie als Test "Docker-Compose-Konfiguration" im aktuellen Status ausführen, ist dies wie folgt. (docker-compose config ist ein Befehl zum Überprüfen der endgültigen auszuführenden yml.)

% docker-compose config
services:
  variable-substitution:
    image: busybox:musl
version: '3'

Sie können sehen, dass der Teil "$ {BUSYBOX_VERSION}" zu einer Variablen erweitert wird und zu "Busybox: Musl" wird.

Schreiben Sie als Nächstes . / Variable-substitution-dotenv / .env auf den folgenden Inhalt und führen Sie docker-compose config aus, um Folgendes zu erhalten.

`./variable-substitution-dotenv/.env`


BUSYBOX_VERSION=latest

% docker-compose config
services:
  variable-substitution:
    image: busybox:latest
version: '3'

In ähnlicher Weise können Sie sehen, dass der Teil "$ {BUSYBOX_VERSION}" zu "Busybox: Neueste" erweitert wurde.

Es wurde bestätigt, dass Variablen mithilfe der Datei ".env" an "Docker-Compose" übergeben werden können.

Es ist leicht, die Funktion zum Ersetzen von Variablen mithilfe der .env-Datei und des Umgangs damit falsch zu verstehen.

Natürlich können die folgenden Konfigurationen ".env", "Dockerfile" und "docker-compose.yml" nicht "erstellt" werden.

./variable-substitution-dotenv-dockerfile-not-work/.env

`./variable-substitution-dotenv-dockerfile-not-work/.env`


BUSYBOX_VERSION="latest"

./variable-substitution-dotenv-dockerfile-not-work/Dockerfile

`./variable-substitution-dotenv-dockerfile-not-work/Dockerfile`


FROM busybox:${BUSYBOX_VERSION}

./variable-substitution-dotenv-dockerfile-not-work/docker-compose.yml

`./variable-substitution-dotenv-dockerfile-not-work/docker-compose.yml`


version: '3'
services:
  variable-substitution-dotenv-dockerfile-not-work:
    build:
      context: ./

Lauf.

% docker-compose build --no-cache
Building variable-substitution-dotenv-dockerfile-not-work
Step 1/1 : FROM busybox:${BUSYBOX_VERSION}
ERROR: Service 'variable-substitution-dotenv-dockerfile-not-work' failed to build : invalid reference format

Es ist natürlich, wenn Sie die Funktionsprüfung und das offizielle Dokument bisher gelesen haben, aber es befindet sich im folgenden Zustand.

Die am Anfang von "Dockerfile" verwendete Variable "BUSYBOX_VERSION" von "Busybox: $ {BUSYBOX_VERSION}" wird nicht als "Dockerfile" als "Build-Variable" deklariert.
Der Mechanismus zum Übergeben von Variablen an "Docker-Compose" unter Verwendung der ".env" -Datei übergibt natürlich nur Werte an "Docker-Compose".
Mit anderen Worten, die Variable wurde nicht an "Dockerfile" übergeben

Um "bauen" zu können, benötigen Sie die folgende Konfiguration.

./variable-substitution-dotenv-dockerfile-work/.env

`./variable-substitution-dotenv-dockerfile-work/.env`


BUSYBOX_VERSION="latest"

./variable-substitution-dotenv-dockerfile-work/Dockerfile

`./variable-substitution-dotenv-dockerfile-work/Dockerfile`


ARG BUSYBOX_VERSION
FROM busybox:${BUSYBOX_VERSION}

./variable-substitution-dotenv-dockerfile-work/docker-compose.yml

`./variable-substitution-dotenv-dockerfile-work/docker-compose.yml`


version: '3'
services:
  variable-substitution-dotenv-dockerfile-work:
    build:
      context: ./
      args:
        BUSYBOX_VERSION: ${BUSYBOX_VERSION}

Lauf.

% docker-compose build --no-cache
Building variable-substitution-dotenv-dockerfile-work
Step 1/2 : ARG BUSYBOX_VERSION
Step 2/2 : FROM busybox:${BUSYBOX_VERSION}
latest: Pulling from library/busybox
9758c28807f2: Pull complete
Digest: sha256:a9286defaba7b3a519d585ba0e37d0b2cbee74ebfe590960b0b1d6a5e97d1e1d
Status: Downloaded newer image for busybox:latest
 ---> f0b02e9d092d

Successfully built f0b02e9d092d
Successfully tagged variable-substitution-dotenv-dockerfile-work_variable-substitution-dotenv-dockerfile-work:latest

Deklarieren Sie die Variable BUSYBOX_VERSION mit der Anweisung ARG in der Dockerfile --Deklarieren Sie die Variable BUSYBOX_VERSION im Abschnitt args: von docker-compose.yml
Weisen Sie auch in der args: -Klausel von docker-compose.yml der Variablendeklaration BUSYBOX_VERSION die Variable BUSYBOX_VERSION von .env zu.
Legen Sie den Wert der Variablen BUSYBOX_VERSION in der Datei .env fest

Durch Ändern des in ".env" definierten Werts von "BUSYBOX_VERSION" können Sie den Wert ändern, ohne die Umgebungsvariablen der Shell-Ausführungsumgebung zu verschmutzen.

Im obigen Beispiel wird der Variablenname "BUSYBOX_VERSION" jedoch an verschiedenen Stellen verwendet (".env", "Dockerfile" und "docker-compose.yml"), was etwas schwer zu verstehen ist.

Um es etwas klarer und expliziter auszudrücken: ".env", "Dockerfile" und "docker-compose.yml" lauten wie folgt.

./variable-substitution-dotenv-dockerfile-work-easy-to-read/.env

`./variable-substitution-dotenv-dockerfile-work-easy-to-read/.env`


DOCKER_COMPOSER_BUSYBOX_VERSION="latest"

./variable-substitution-dotenv-dockerfile-work-easy-to-read/Dockerfile

`./variable-substitution-dotenv-dockerfile-work-easy-to-read/Dockerfile`


ARG BUSYBOX_VERSION="latest"
FROM busybox:${BUSYBOX_VERSION}

./variable-substitution-dotenv-dockerfile-work-easy-to-read/docker-compose.yml

`./variable-substitution-dotenv-dockerfile-work-easy-to-read/docker-compose.yml`


version: '3'
services:
  variable-substitution-dotenv-dockerfile-work-easy-to-read:
    build:
      context: ./
      args:
        BUSYBOX_VERSION: ${DOCKER_COMPOSER_BUSYBOX_VERSION}

Deklarieren Sie die Variable BUSYBOX_VERSION in Dockerfile mit der Anweisung ARG und deklarieren Sie die Verwendung von latest als Standardwert, wenn kein Wert von Docker-Compose übergeben wird. --Deklarieren Sie die Variable BUSYBOX_VERSION im Abschnitt args: von docker-compose.yml
Weisen Sie auch in der args: -Klausel von docker-compose.yml der Variablendeklaration BUSYBOX_VERSION die Variable DOCKER_COMPOSER_BUSYBOX_VERSION von .env zu.
Setzen Sie den Wert der Variablen DOCKER_COMPOSER_BUSYBOX_VERSION in der Datei .env

Die Wörter "Variablen" und "Umgebungsvariablen" sind oft verwirrend. Wenn Sie sich also die spezifischen Variablennamen ansehen, können Sie sehen, was als Variablen und Werte vererbt wird.

Nur weil der Name (Bezeichnung) verwirrend ist, können Sie den Mechanismus zum Übergeben des Variablennamens und -werts als .env-> docker-compose.yml-> Dockerfile verstehen.

In Bezug auf die Funktion zum Ersetzen von Variablen mit der Datei ".env" (ich bezweifle, dass dieser Ausdruck korrekt ist ...) ** Die Funktion zum Ersetzen von Variablen mit der Datei ".env" hat eine Variable in "docker-compose.yml" Es ist möglicherweise einfacher zu verstehen, wenn Sie es als einen Mechanismus zum Übergeben von Werten betrachten **.

Ein wenig beiseite

Tatsächlich empfehle ich den folgenden Schreibstil nicht, wie oben dargestellt.

ARG BUSYBOX_VERSION="latest"
FROM busybox:${BUSYBOX_VERSION}

Beispielsweise bleiben aufgrund der Einschränkungen von Github-Aktionen (usw.) die folgenden Fälle weiterhin bestehen.

Die erste Anweisung in der Dockerfile-Datei muss FROM sein.

https://docs.github.com/ja/free-pro-team@latest/actions/creating-actions/dockerfile-support-for-github-actions#from

Erstens ist es angesichts der Einheitlichkeit der Umgebung (Entwicklung | Ausführung) wünschenswert, einen zuverlässigen Wert für den TAG-Wert von FROM zu verwenden, ohne auch nur "neueste" zu verwenden.

Natürlich kann es Fälle geben, in denen dies nicht der Fall ist, aber es gibt Probleme wie das Nichtwilligen größerer Versions-Upgrades in Abhängigkeit vom Build-Timing.

Anwendungsbeispiel

Wenn Sie beispielsweise "Docker-Compose Build" ausführen, können Sie die Ausführung von "Garnlauf {Skript}" durch lokale, Staging-, Produktions- und andere Umgebungen steuern.

Angenommen, Sie haben separate Build-Umgebungen für Lokal, Staging und Produktion und jede hat eine .env-Datei.

Lokale .env *

`.env`


#...Abkürzung...
DOCKER_COMPOSE_BUILD_TYPE="dev"
#...Abkürzung...

Für die Inszenierung von .env *

`.env`


#...Abkürzung...
DOCKER_COMPOSE_BUILD_TYPE="dev"
#...Abkürzung...

Für die Produktion .env *

`.env`


#...Abkürzung...
DOCKER_COMPOSE_BUILD_TYPE="prod"
#...Abkürzung...

Nehmen Sie außerdem an, dass diese .envs gitignore sind und nicht vom Repository verwaltet werden.

In diesem Zustand ist es durch Vorbereiten von "Dockerfile" und "docker-compose.yml" wie folgt möglich, jede Umgebung unter Beibehaltung eines einzelnen Quellcodes zu steuern.

Dockerfile

#...Abkürzung...
ARG BUILD_TYPE="local"
#...Abkürzung...
RUN yarn run ${BUILD_TYPE}
#...Abkürzung...

docker-compose.yml

`docker-compose.yml`


#...Abkürzung...
    build:
#...Abkürzung...
      args:
        BUILD_TYPE: ${DOCKER_COMPOSE_BUILD_TYPE}
#...Abkürzung...

Sie können auch "Umgebung:" verwenden, um das Protokollziel, den Mail-Treiber und den DB-Treiber für jede Umgebung zu ändern.

Wenn Sie mit PHP entwickeln, können Sie xdebug aktivieren und deaktivieren und verschiedene Einstellungswerte über .env jeder Person frei ändern.