Jak przekazać zmienne środowiskowe do kontenerów Docker?

Question

Jestem nowy w Docker i nie jest jasne, jak uzyskać dostęp do zewnętrznej bazy danych z kontenera. Czy jest najlepszy sposób na kodowanie w łańcuchu połączenia?

# Dockerfile 
ENV DATABASE_URL amazon:rds/connection?string 

Answer 1

Możesz przekazywać zmienne środowiskowe do swoich kontenerów za pomocą flagi -e.

Przykładem ze skryptu startowego:

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 

Lub, jeśli nie chcą mieć wartość w wierszu polecenia, gdzie będzie wyświetlany przez ps itd -e może ciągnąć się wartość od obecnej sytuacji, jeśli tylko dać go bez =:

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

Jeśli masz wiele zmiennych środowiskowych, a zwłaszcza jeśli są miało być tajne, można use an env-file:

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

Flaga --env plik pobiera nazwę pliku jako argument i oczekuje, że każdy wiersz będzie w formacie VAR = VAL, naśladując argument przekazany do --env. Linie komentarza muszą być poprzedzone tylko z #

Answer 2

można przekazać za pomocą -e parametry z polecenia docker run .. jak wspomniano here jak wspomniano przez @errata.
Jednak możliwe Wadą tego podejścia jest to, że poświadczenia zostaną wyświetlone w szczegóły procesu, gdzie można go uruchomić.
Aby uczynić go bardziej bezpieczne, można napisać swoje dane w pliku konfiguracyjnym i zrobić docker run z --env-file jak wspomniano here. Następnie możesz kontrolować dostęp do tego pliku konfiguracyjnego, aby inni, którzy mają dostęp do tego komputera, nie zobaczyli Twoich danych uwierzytelniających.

Answer 3

Jeśli używasz "doker-compose" jako metody do rozpędzania kontenera (-ów), faktycznie jest użyteczny sposób przekazania zmiennej środowiskowej zdefiniowanej na serwerze do kontenera Docker.

W pliku docker-compose.yml, powiedzmy, że kręcą się podstawową Hapi-js pojemnik i kod wygląda następująco:

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

Powiedzmy, że serwer lokalny, że projekt doker jest ma zmienną środowiskową o nazwie "NODE_DB_CONNECT", którą chcesz przekazać do swojego kontenera hapi-js, a chcesz, aby jego nowa nazwa brzmiała "HAPI_DB_CONNECT". Następnie w pliku docker-compose.yml, należy przekazać zmienną środowiskową lokalną do pojemnika i zmienić go tak:

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

Mam nadzieję, że to pomoże Ci uniknąć twarde kodowania bazy danych połączyć łańcuch w dowolnym pliku w pojemniku!

Answer 4

Zastosowanie -e lub wartość --env ustawić zmienne środowiska (domyślnie []).

Przykładem ze skryptu startowego:

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

Jeśli chcesz korzystać z wielu środowisk z wiersza poleceń, a następnie przed użyciem każda zmienna flagę -e.

Przykład:

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

Uwaga: Upewnij się umieścić nazwę kontenera po zmiennej środowiskowej, a nie wcześniej.

Jeśli trzeba skonfigurować wiele zmiennych, użyj --env-file flagę

Na przykład,

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

Dla każdej innej pomocy, zajrzeć do pomocy Docker:

$ docker run --help 

Oficjalna dokumentacja: https://docs.docker.com/compose/environment-variables/

Answer 5

W przypadku Amazon AWS ECS/ECR należy zarządzać zmiennymi środowiskowymi (, szczególnie tajemnicami) za pośrednictwem prywatnego zasobnika S3. Zobacz wpis na blogu: How to Manage Secrets for Amazon EC2 Container Service–Based Applications by Using Amazon S3 and Docker.

Answer 6

Poniższy przykład pokazuje, jak można dziedziczyć zmienne powłoki env w pliku docker-compose.yml, a następnie wszystkie pliki Dockerfile wywoływane przez docker-compose w celu tworzenia obrazów. Zauważyłem, że jest to użyteczne, jeśli powiemy w poleceniu DockerfileRUN, że muszę wykonywać polecenia specyficzne dla środowiska.

(twoja powłoka ma RAILS_ENV=development już istniejących w środowisku)

doker-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 

ten sposób nie potrzebują aby określić zmienne środowiskowe w plikach lub docker-composebuild/up komendy:

docker-compose build 
docker-compose up