Ich bin neu in Docker und es ist unklar, wie man von einem Container aus auf eine externe Datenbank zugreift. Ist der beste Weg, um die Verbindungszeichenfolge fest zu codieren?

# Dockerfile
ENV DATABASE_URL amazon:rds/connection?string

Sie können Umgebungsvariablen mit dem -eFlag an Ihre Container übergeben .

Ein Beispiel aus einem Startskript:

sudo docker run -d -t -i -e REDIS_NAMESPACE='staging' \ 
-e POSTGRES_ENV_POSTGRES_PASSWORD='foo' \
-e POSTGRES_ENV_POSTGRES_USER='bar' \
-e POSTGRES_ENV_DB_NAME='mysite_staging' \
-e POSTGRES_PORT_5432_TCP_ADDR='docker-db-1.hidden.us-east-1.rds.amazonaws.com' \
-e SITE_URL='staging.mysite.com' \
-p 80:80 \
--link redis:redis \  
--name container_name dockerhub_id/image_name

Wenn Sie den Wert nicht in der Befehlszeile haben möchten, in der er angezeigt wird psusw., -ekönnen Sie den Wert aus der aktuellen Umgebung abrufen, wenn Sie ihn nur ohne Folgendes angeben =:

sudo PASSWORD='foo' docker run  [...] -e PASSWORD [...]

Wenn Sie viele Umgebungsvariablen haben und diese insbesondere geheim sein sollen, können Sie eine env-Datei verwenden :

$ docker run --env-file ./env.list ubuntu bash

Das Flag --env-file verwendet einen Dateinamen als Argument und erwartet, dass jede Zeile das Format VAR = VAL hat, das das an --env übergebene Argument nachahmt. Kommentarzeilen müssen nur mit # vorangestellt werden

Sie können -eParameter mit dem docker run ..Befehl übergeben, wie hier erwähnt und wie von @errata erwähnt.
Der mögliche Nachteil dieses Ansatzes besteht jedoch darin, dass Ihre Anmeldeinformationen in der Prozessliste angezeigt werden, in der Sie sie ausführen.
Um es sicherer zu machen, können Sie Ihre Anmeldeinformationen in einer Konfigurationsdatei schreiben und docker runmit --env-filewie erwähnt hier . Anschließend können Sie den Zugriff auf diese Konfigurationsdatei so steuern, dass andere Benutzer, die Zugriff auf diesen Computer haben, Ihre Anmeldeinformationen nicht sehen.

Wenn Sie "Docker-Compose" als Methode zum Hochfahren Ihrer Container verwenden, gibt es tatsächlich eine nützliche Möglichkeit, eine auf Ihrem Server definierte Umgebungsvariable an den Docker-Container zu übergeben.

docker-compose.ymlAngenommen, Sie drehen in Ihrer Datei einen einfachen Hapi-JS-Container und der Code sieht folgendermaßen aus:

hapi_server:
  container_name: hapi_server
  image: node_image
  expose:
    - "3000"

Angenommen, der lokale Server, auf dem sich Ihr Docker-Projekt befindet, verfügt über eine Umgebungsvariable mit dem Namen 'NODE_DB_CONNECT', die Sie an Ihren hapi-js-Container übergeben möchten, und der neue Name lautet 'HAPI_DB_CONNECT'. Dann würden Sie in der docker-compose.ymlDatei die lokale Umgebungsvariable an den Container übergeben und wie folgt umbenennen:

hapi_server:
  container_name: hapi_server
  image: node_image
  environment:
    - HAPI_DB_CONNECT=${NODE_DB_CONNECT}
  expose:
    - "3000"

Ich hoffe, dies hilft Ihnen dabei, das Festcodieren einer Datenbankverbindungszeichenfolge in einer beliebigen Datei in Ihrem Container zu vermeiden!

Mit docker-composekönnen Sie env-Variablen in docker-compose.yml und anschließend alle Docker-Dateien erben, die docker-composezum Erstellen von Images aufgerufen werden . Dies ist nützlich, wenn der Dockerfile RUNBefehl umgebungsspezifische Befehle ausführen soll.

(Ihre Shell ist RAILS_ENV=developmentbereits in der Umgebung vorhanden.)

docker-compose.yml :

version: '3.1'
services:
  my-service: 
    build:
      #$RAILS_ENV is referencing the shell environment RAILS_ENV variable
      #and passing it to the Dockerfile ARG RAILS_ENV
      #the syntax below ensures that the RAILS_ENV arg will default to 
      #production if empty.
      #note that is dockerfile: is not specified it assumes file name: Dockerfile
      context: .
      args:
        - RAILS_ENV=${RAILS_ENV:-production}
    environment: 
      - RAILS_ENV=${RAILS_ENV:-production}

Dockerfile :

FROM ruby:2.3.4

#give ARG RAILS_ENV a default value = production
ARG RAILS_ENV=production

#assign the $RAILS_ENV arg to the RAILS_ENV ENV so that it can be accessed
#by the subsequent RUN call within the container
ENV RAILS_ENV $RAILS_ENV

#the subsequent RUN call accesses the RAILS_ENV ENV variable within the container
RUN if [ "$RAILS_ENV" = "production" ] ; then echo "production env"; else echo "non-production env: $RAILS_ENV"; fi

Auf diese Weise muss ich keine Umgebungsvariablen in Dateien oder docker-compose build/ upBefehlen angeben :

docker-compose build
docker-compose up

Verwenden -eSie den Wert oder --env, um Umgebungsvariablen festzulegen (Standard []).

Ein Beispiel aus einem Startskript:

 docker run  -e myhost='localhost' -it busybox sh

Wenn Sie mehrere Umgebungen über die Befehlszeile verwenden möchten, verwenden Sie vor jeder Umgebungsvariablen das -eFlag.

Beispiel:

 sudo docker run -d -t -i -e NAMESPACE='staging' -e PASSWORD='foo' busybox sh

Hinweis: Stellen Sie sicher, dass der Containername nach der Umgebungsvariablen und nicht davor steht.

Wenn Sie viele Variablen einrichten müssen, verwenden Sie das --env-fileFlag

Zum Beispiel,

 $ docker run --env-file ./my_env ubuntu bash

Weitere Hilfe finden Sie in der Docker-Hilfe:

 $ docker run --help

Offizielle Dokumentation: https://docs.docker.com/compose/environment-variables/

Es gibt einen netten Hack, wie Host-Computer-Umgebungsvariablen an einen Docker-Container weitergeleitet werden:

env > env_file && docker run --env-file env_file image_name

Verwenden Sie sehr sorgfältig diese Technik, da env > env_filewird Dump alle Host - Maschine ENV Variablen env_fileund machen sie im laufenden Behälter zugänglich.

Für Amazon AWS ECS / ECR sollten Sie Ihre Umgebungsvariablen ( insbesondere Geheimnisse ) über einen privaten S3-Bucket verwalten. Siehe Blogbeitrag Verwalten von Geheimnissen für Amazon EC2 Container Service-basierte Anwendungen mithilfe von Amazon S3 und Docker .

Eine andere Möglichkeit besteht darin, die Kräfte von /usr/bin/env:

docker run ubuntu env DEBUG=1 path/to/script.sh

Wenn Sie die Umgebungsvariablen env.shlokal haben und sie beim Starten des Containers einrichten möchten, können Sie es versuchen

COPY env.sh /env.sh
COPY <filename>.jar /<filename>.jar
ENTRYPOINT ["/bin/bash" , "-c", "source /env.sh && printenv && java -jar /<filename>.jar"]

Dieser Befehl würde den Container mit einer Bash-Shell starten (ich möchte eine Bash-Shell, da sourcees sich um einen Bash-Befehl handelt), die env.shDatei als Quelle (die die Umgebungsvariablen festlegt) und die JAR-Datei ausführen.

Das env.shsieht so aus,

#!/bin/bash
export FOO="BAR"
export DB_NAME="DATABASE_NAME"

Ich habe den printenvBefehl nur hinzugefügt, um zu testen, ob der eigentliche Quellbefehl funktioniert. Sie sollten es wahrscheinlich entfernen, wenn Sie bestätigen, dass der Quellbefehl ordnungsgemäß funktioniert oder die Umgebungsvariablen in Ihren Docker-Protokollen angezeigt werden.

Verwenden von jq zum Konvertieren der Umgebung in JSON:

env_as_json=`jq -c -n env`
docker run -e HOST_ENV="$env_as_json" <image>

Dies erfordert jq Version 1.6 oder neuer

Dies verdrängt den Host env als json, im Wesentlichen wie in Dockerfile:

ENV HOST_ENV  (all env from the host as json)

Wir können auch Maschinenumgebungsvariablen mit dem Flag -e und $ hosten:

Vor dem Ausführen müssen lokale Env-Variablen und -Dateien oder kurz vor der Verwendung exportiert (dh festgelegt) werden

docker run -it -e MG_HOST=$MG_HOST -e MG_USER=$MG_USER -e MG_PASS=$MG_PASS -e MG_AUTH=$MG_AUTH -e MG_DB=$MG_DB -t image_tag_name_and_version 

Mit dieser Methode setzen Sie die env-Variable in meinem Fall automatisch mit Ihrem Vornamen (MG_HOST, MG_USER).

Zusätzlich:

Wenn Sie Python verwenden, können Sie über Docker auf diese Envment-Variable zugreifen

import os
host,username,password,auth,database=os.environ.get('MG_HOST'),os.environ.get('MG_USER'),os.environ.get('MG_PASS'),os.environ.get('MG_AUTH'),os.environ.get('MG_DB')

docker run --rm -it --env-file <(bash -c 'env | grep <your env data>') Ist eine Möglichkeit, die in a gespeicherten Daten zu erfassen .envund an Docker weiterzuleiten, ohne dass etwas unsicher gespeichert wird (Sie können also nicht nur docker historySchlüssel anzeigen und abrufen.

Angenommen, Sie haben eine Menge AWS-Inhalte auf Ihre .envArt und Weise:

AWS_ACCESS_KEY: xxxxxxx
AWS_SECRET: xxxxxx
AWS_REGION: xxxxxx

Wenn Sie Docker mit `` `Docker ausführen, führen Sie --rm -it --env-file <(bash -c 'env | grep AWS_') aus, um alles zu erfassen und sicher zu übergeben, damit Sie aus dem Container heraus darauf zugreifen können.