Soy nuevo en Docker y no está claro cómo acceder a una base de datos externa desde un contenedor. ¿Es la mejor forma de codificar en la cadena de conexión?

# Dockerfile
ENV DATABASE_URL amazon:rds/connection?string

Puede pasar variables de entorno a sus contenedores con la -ebandera.

Un ejemplo de un script de inicio:

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

O, si no desea tener el valor en la línea de comandos donde se mostrará ps, etc., -epuede obtener el valor del entorno actual si solo lo proporciona sin =:

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

Si tiene muchas variables de entorno y especialmente si están destinadas a ser secretas, puede usar un archivo env :

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

El indicador --env-file toma un nombre de archivo como argumento y espera que cada línea esté en el formato VAR = VAL, imitando el argumento pasado a --env. Las líneas de comentarios solo necesitan tener el prefijo #

Puede pasar usando -eparámetros con el docker run ..comando como se menciona aquí y como lo menciona @errata.
Sin embargo, la posible desventaja de este enfoque es que sus credenciales se mostrarán en la lista de procesos, donde la ejecuta.
Para hacerlo más seguro, puede escribir sus credenciales en un archivo de configuración y hacer docker runcon --env-filecomo se ha mencionado aquí . Luego puede controlar el acceso a ese archivo de configuración para que otras personas que tengan acceso a esa máquina no vean sus credenciales.

Si está utilizando 'docker-compose' como método para hacer girar sus contenedores, en realidad hay una forma útil de pasar una variable de entorno definida en su servidor al contenedor Docker.

En su docker-compose.ymlarchivo, supongamos que está girando un contenedor básico de hapi-js y el código se ve así:

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

Supongamos que el servidor local en el que se encuentra su proyecto de Docker tiene una variable de entorno llamada 'NODE_DB_CONNECT' que desea pasar a su contenedor hapi-js y desea que su nuevo nombre sea 'HAPI_DB_CONNECT'. Luego, en el docker-compose.ymlarchivo, debe pasar la variable de entorno local al contenedor y cambiarle el nombre de esta manera:

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

¡Espero que esto te ayude a evitar codificar una cadena de conexión de base de datos en cualquier archivo de tu contenedor!

Utilizando docker-compose, puede heredar variables env en docker-compose.yml y, posteriormente, cualquier Dockerfile (s) llamado por docker-composeconstruir imágenes. Esto es útil cuando el Dockerfile RUNcomando debe ejecutar comandos específicos para el entorno.

(su shell RAILS_ENV=developmentya existe en el entorno)

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

De esta manera yo no necesidad de especificar las variables de entorno en archivos o docker-compose build/ upcomandos:

docker-compose build
docker-compose up

Use el -evalor o --env para establecer variables de entorno (predeterminado []).

Un ejemplo de un script de inicio:

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

Si desea utilizar múltiples entornos desde la línea de comando, antes de cada variable de entorno utilice el -eindicador.

Ejemplo:

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

Nota: Asegúrese de colocar el nombre del contenedor después de la variable de entorno, no antes de eso.

Si necesita configurar muchas variables, use la --env-filebandera

Por ejemplo,

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

Para cualquier otra ayuda, consulte la ayuda de Docker:

 $ docker run --help

Documentación oficial: https://docs.docker.com/compose/environment-variables/

Hay un buen truco para canalizar las variables de entorno de la máquina host a un contenedor acoplable:

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

Use esta técnica con mucho cuidado, porque env > env_filevolcará TODAS las variables ENV de la máquina host env_filey las hará accesibles en el contenedor en ejecución.

Para Amazon AWS ECS / ECR, debe administrar sus variables de entorno ( especialmente los secretos ) a través de un depósito privado S3. Consulte la publicación del blog Cómo administrar secretos para aplicaciones basadas en Amazon EC2 Container Service mediante Amazon S3 y Docker .

Otra forma es usar los poderes de /usr/bin/env:

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

Si tiene las variables de entorno env.shlocalmente y desea configurarlo cuando se inicia el contenedor, puede intentar

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

Este comando iniciaría el contenedor con un shell bash (quiero un shell bash ya que sourcees un comando bash), obtiene el env.sharchivo (que establece las variables de entorno) y ejecuta el archivo jar.

Se env.shve así,

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

Agregué el printenvcomando solo para probar que el comando fuente real funciona. Probablemente debería eliminarlo cuando confirme que el comando de origen funciona bien o las variables de entorno aparecerían en los registros de su ventana acoplable.

Usando jq para convertir el env a JSON:

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

esto requiere jq versión 1.6 o posterior

esto empuja al host host como json, esencialmente así en Dockerfile:

ENV HOST_ENV  (all env from the host as json)

también podemos hospedar la variable de entorno de la máquina usando -e flag y $:

Antes de ejecutar, necesita exportar (significa conjunto) la variable y archivo env local o justo antes de usar

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 

Al usar este método, establezca la variable env automáticamente con su nombre de pila en mi caso (MG_HOST, MG_USER)

Adicional:

Si está utilizando Python, puede acceder a estas variables de entorno dentro de Docker al

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>') Es una forma de recopilar los datos almacenados dentro de a .envy pasarlos a Docker, sin que nada se almacene de forma insegura (por lo que no puede simplemente mirar docker historyy tomar las teclas.

Digamos que tiene un montón de cosas de AWS en su .envgusto, así:

AWS_ACCESS_KEY: xxxxxxx
AWS_SECRET: xxxxxx
AWS_REGION: xxxxxx

ejecutando docker con `` docker run --rm -it --env-file <(bash -c 'env | grep AWS_') lo tomará todo y lo pasará de forma segura para que sea accesible desde dentro del contenedor.