Legen Sie Umgebungsvariablen in Docker fest

1. Erstellen Sie ein neues Projekt
2. Erstellen Sie eine Dockerdatei
3. Setzen Sie Umgebungsvariablen mit der Anweisung ARG
4. Legen Sie Umgebungsvariablen mit der Anweisung ENV fest
5. Umgebungsvariablen dynamisch festlegen
6. Abschluss

Umgebungsvariablen werden verwendet, um zusätzliche Konfigurationen oder Metadaten hinzuzufügen, um die Entwicklung einer Anwendung zu unterstützen, und können in verschiedenen Formen existieren.

Wenn wir beispielsweise eine Java-Anwendung entwickeln, legen wir normalerweise eine Umgebungsvariable fest, die auf den Speicherort des Java-Entwicklungskits verweist, um sicherzustellen, dass wir unsere Anwendungen kompilieren und ausführen können.

Ebenso können wir Umgebungsvariablen für unsere Container festlegen, wenn wir Docker zum Entwickeln unserer Anwendung verwenden. In diesem Tutorial lernen wir, wie man ENV-Variablen setzt und wie man bei Bedarf auf die Variablen aus einem laufenden Container zugreift.

Erstellen Sie ein neues Projekt

Öffnen Sie WebStorm IDEA und wählen Sie Datei > Neu > Projekt. Wählen Sie im sich öffnenden Fenster Node.js und ändern Sie den Projektnamen von untitled in docker-env-variables oder verwenden Sie einen beliebigen Namen.

Stellen Sie sicher, dass Sie die Node-Laufzeitumgebung installiert haben, damit die Abschnitte Node interpreter und Package manager automatisch vom Computer hinzugefügt werden können. Drücken Sie abschließend die Schaltfläche Erstellen, um das Projekt zu generieren.

Da unsere Anwendung expressjs verwendet, verwenden Sie den folgenden Befehl, um expressjs in unserer Anwendung zu installieren.

~/WebstormProjects/docker-env-variables$ npm install express

Erstellen Sie nach der Installation von expressjs eine Datei namens index.js im Ordner docker-env-variables und kopieren Sie den folgenden Code und fügen Sie ihn in die Datei ein.

const express = require('express')
const app = express()
const port = 3000

app.get('/', (req, res) => {
    res.json(
        [{
            name: 'Lenovo Legion 5 pro',
            type: 'electronic',
            price: 1500
        },
            {
                name: 'Xiaomi pro 14',
                type: 'electronic',
                price: 1300
            },
        ])
})

app.listen(port, () => {
    console.log(`Example app listening on port ${port}`)
})

In dieser Datei haben wir eine Anwendung simuliert, die eine Reihe von Produkten in einer E-Commerce-Umgebung zurückgibt, und wir werden diese Anwendung verwenden, um die in diesem Lernprogramm behandelten Beispiele zu testen.

Erstellen Sie eine Dockerdatei

Erstellen Sie eine Datei namens Dockerfile im Ordner docker-env-variables. Ein Dockerfile ist eine Datei, die uns hilft, Konfigurationen für unser benutzerdefiniertes Image zu definieren.

Es gibt zwei Ansätze, die wir verwenden können, um Umgebungsvariablen zu setzen: die Anweisung ARG und die Anweisung ENV.

Der Unterschied zwischen diesen beiden Anweisungen besteht darin, dass ein laufender Container nicht auf die Umgebungsvariablen zugreifen kann, die mit der Anweisung ARG gesetzt wurden, da sie nur beim Erstellen des Images verfügbar sind. Die folgenden Abschnitte zeigen, wie Sie diese Anweisungen verwenden, um unser Ziel zu erreichen.

Setzen Sie Umgebungsvariablen mit der Anweisung ARG

Kopieren Sie die folgenden Anweisungen und fügen Sie sie in die Datei namens Dockerfile ein, die wir im vorherigen Abschnitt erstellt haben.

FROM node:16.17.0-alpine
ARG APP_NAME
ARG APP_VERSION=1.0.0
RUN echo "build an image of ${APP_NAME} version ${APP_VERSION}"
WORKDIR /com/ecommerce
ADD package*.json ./
RUN npm install
COPY . .
CMD node index.js

Die Anweisung FROM legt unser Basisbild fest, auf dem unser benutzerdefiniertes Bild erstellt werden soll. In unserem Fall haben wir alpine verwendet, was die Lightweight-Version von Node.

Das ARG definiert Variablen, die der Docker-Builder verwenden kann, um ein Image zu erstellen. Die mit dieser Anweisung bereitgestellten Variablen können erforderlich oder optional sein.

Die Docker-Dokumentation enthält eine Referenz, in der wir die anderen Anweisungen lesen können.

In unserem Fall haben wir eine optionale Variable namens APP_NAME und eine erforderliche Variable namens APP_VERSION bereitgestellt.

Beachten Sie, dass diese Variablen nur beim Erstellen eines Images verfügbar sind. Der nächste Abschnitt überprüft dies.

Erstellen Sie ein Bild

Verwenden Sie den folgenden Befehl, um ein Image mit dem Tag docker-env:latest zu erstellen.

~/WebstormProjects/docker-env-variables$ docker build --tag docker-env:latest .

Dieser Befehl führt unser Dockerfile nacheinander aus, und wir können jeden ausgeführten Schritt anzeigen, wie unten gezeigt.

 => [1/6] FROM docker.io/library/node:16.17.0-alpine@sha256:2c405ed42fc0fd6aacbe5730042640450e5ec030bada7617beac88f742b6  0.0s
 => CACHED [2/6] RUN echo "build an image of ${APP_NAME} version 1.0.0"                                                   0.0s
 => [3/6] WORKDIR /com/ecommerce                                                                                          0.6s
 => [4/6] ADD package*.json ./                                                                                            0.8s
 => [5/6] RUN npm install                                                                                                 6.7s
 => [6/6] COPY . .

Beim Erstellen eines Images können wir die Werte leerer Umgebungsvariablen bereitstellen oder die Standardumgebungswerte mit dem Befehl --build-arg überschreiben, wie unten gezeigt.

~/WebstormProjects/docker-env-variables$ docker build --build-arg APP_NAME=ecommerce-app --tag docker-env:latest .

Führen Sie einen Container aus

Verwenden Sie den folgenden Befehl, um einen Container namens docker-env-prod auszuführen, der Port 3000 auf dem Host verfügbar macht.

~/WebstormProjects/docker-env-variables$ docker run --name docker-env-prod -d -p 3000:3000 docker-env:latest

Dieser Befehl führt eine Instanz unserer Anwendung aus und wir können im Browser unter localhost:3000 (http://localhost:3000/) darauf zugreifen. Wir wollen jedoch prüfen, ob wir auf die mit der Anweisung ARG gesetzten Umgebungsvariablen zugreifen können.

Um dies zu überprüfen, verwenden Sie den folgenden Befehl, um im interaktiven Modus auf unser Container-Dateisystem zuzugreifen.

~/WebstormProjects/docker-env-variables$ docker exec -it docker-env-prod /bin/sh

Ausgang:

/com/ecommerce #

Um die aktuellen Umgebungsvariablen anzuzeigen, verwenden Sie den folgenden Befehl und beachten Sie, dass die beiden Variablen, die wir mit der Anweisung ARG gesetzt haben, nicht angezeigt werden.

/com/ecommerce # printenv

Ausgang:

NODE_VERSION=16.17.0
HOSTNAME=1bbf5ec4141e
YARN_VERSION=1.22.19
SHLVL=1
HOME=/root
TERM=xterm
PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
PWD=/com/ecommerce

Legen Sie Umgebungsvariablen mit der Anweisung ENV fest

Machen Sie die vorherigen Docker-Anweisungen im Dockerfile als Kommentar und kopieren Sie die folgenden Anweisungen und fügen Sie sie nach dem Kommentar in die Datei ein.

FROM node:16.17.0-alpine
ENV APP_NAME=ecommerce-app
ENV APP_VERSION=1.0.0
RUN echo "build an image of ${APP_NAME} version ${APP_VERSION}"
WORKDIR /com/ecommerce
ADD package*.json ./
RUN npm install
COPY . .
CMD node index.js

Die Anweisungen in dieser Dockerfile sind die gleichen wie in der vorherigen, und die einzige Änderung, die wir vorgenommen haben, ist das Ersetzen der ARG-Anweisung durch die ENV-Anweisung.

Der ENV setzt Umgebungsvariablen, die der Docker-Builder verwenden kann, um ein Image zu erstellen. Die Umgebungsvariablen haben die Form von Schlüssel-Wert-Paaren.

Beachten Sie, dass diese Variablen nicht optional sind und jeder deklarierte Wert einen Wert im Vergleich zur vorherigen Anweisung haben muss, der optionale Variablen zulässt.

Da das vorherige Beispiel gezeigt hat, wie ein Container daraus erstellt und ausgeführt wird, verwenden Sie in diesem Beispiel dieselben Ansätze, um dasselbe zu erreichen. Mit der Anweisung ENV können wir wie unten gezeigt auf unsere beiden Umgebungsvariablen APP_NAME und APP_VERSION zugreifen.

NODE_VERSION=16.17.0
HOSTNAME=0cca1ee1340d
YARN_VERSION=1.22.19
SHLVL=1
HOME=/root
APP_NAME=ecommerce-app
TERM=xterm
PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
PWD=/com/ecommerce
APP_VERSION=1.0.0

Umgebungsvariablen dynamisch festlegen

Beim Erstellen von Bildern auf der Befehlszeile können wir die Anweisung ARG verwenden, um Variablen dynamisch Werte zuzuweisen, die mit der Anweisung ENV definiert wurden.

Um dies in Aktion zu sehen, machen Sie die vorherigen Anweisungen in der Dockerfile als Kommentare und kopieren Sie die folgenden Anweisungen und fügen Sie sie in die Datei ein.

FROM node:16.17.0-alpine
ARG HOST_MACHINE
ENV APP_NAME=ecommerce-app
ENV APP_VERSION=1.0.0
ENV DEV_ENV=$HOST_MACHINE
RUN echo "build an image of ${APP_NAME} version ${APP_VERSION}"
WORKDIR /com/ecommerce
ADD package*.json ./
RUN npm install
COPY . .
CMD node index.js

Beachten Sie, dass wir eine ARG-Anweisung mit einer Variablen namens HOST_MACHINE hinzugefügt haben, die einer ENV-Anweisung mit dem Variablennamen DEV_ENV dynamisch zugewiesen wird, indem auf den Variablennamen $HOST_MACHINE verwiesen wird.

Wir können einen Standardwert für den Variablennamen HOST_MACHINE erstellen, der auch der Variablen DEV_ENV zugewiesen wird, oder den Befehl --build-arg auf der Befehlszeile verwenden, um HOST_MACHINE einen Wert zuzuweisen, und wir werden die gleichen Ergebnisse erzielen.

Abschluss

In diesem Tutorial haben wir gelernt, wie man Umgebungsvariablen setzt und wie man von einem laufenden Container aus auf diese Variablen zugreift. Wir haben gelernt, wie man die Anweisung ARG und die Anweisung ENV verwendet und wie man Umgebungsvariablen dynamisch setzt.

Der wichtigste Punkt dabei ist, dass auf die Umgebungsvariablen, die mit der Anweisung ARG gesetzt wurden, nicht von einem laufenden Container aus zugegriffen werden kann.