Establecer variables de entorno en Docker

1. Crear un nuevo proyecto
2. Crear un archivo Docker
3. Establecer variables de entorno utilizando la instrucción ARG
4. Establecer variables de entorno utilizando la instrucción ENV
5. Establecer variables de entorno dinámicamente
6. Conclusión

Las variables de entorno se utilizan para agregar configuraciones adicionales o metadatos para ayudar a desarrollar una aplicación y pueden existir en diferentes formas.

Por ejemplo, cuando desarrollamos una aplicación Java, generalmente establecemos una variable de entorno que apunta a la ubicación del kit de desarrollo de Java para garantizar que podamos compilar y ejecutar nuestras aplicaciones.

De manera similar, podemos establecer variables de entorno para nuestros contenedores cuando usamos Docker para desarrollar nuestra aplicación. En este tutorial, aprenderemos cómo configurar las variables ENV y cómo acceder a las variables desde un contenedor en ejecución cuando sea necesario.

Crear un nuevo proyecto

Abra WebStorm IDEA y seleccione Archivo > Nuevo > Proyecto. En la ventana que se abre, seleccione Node.js y cambie el nombre del proyecto de sin título a docker-env-variables o use el nombre que prefiera.

Asegúrese de haber instalado el entorno de tiempo de ejecución de Node para que las secciones Node interpreter y Package manager se puedan agregar automáticamente desde la computadora. Finalmente, presione el botón etiquetado como Crear para generar el proyecto.

Dado que nuestra aplicación usa expressjs, use el siguiente comando para instalar expressjs en nuestra aplicación.

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

Después de instalar expressjs, cree un archivo llamado index.js en la carpeta docker-env-variables y copie y pegue el siguiente código en el archivo.

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}`)
})

En este archivo, hemos simulado una aplicación que devuelve una variedad de productos en un entorno de comercio electrónico y usaremos esta aplicación para probar los ejemplos cubiertos en este tutorial.

Crear un archivo Docker

Cree un archivo llamado Dockerfile en la carpeta docker-env-variables. Un Dockerfile es un archivo que nos ayuda a definir configuraciones para nuestra imagen personalizada.

Hay dos enfoques que podemos usar para establecer variables de entorno: la instrucción ARG y la instrucción ENV.

La diferencia entre estas dos instrucciones es que un contenedor en ejecución no puede acceder a las variables de entorno establecidas mediante la instrucción ARG, ya que solo están disponibles al construir la imagen. Las siguientes secciones muestran cómo usar estas instrucciones para lograr nuestro objetivo.

Establecer variables de entorno utilizando la instrucción ARG

Copie y pegue las siguientes instrucciones en el archivo llamado Dockerfile que creamos en la sección anterior.

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

La instrucción FROM establece nuestra imagen base sobre la cual crear nuestra imagen personalizada. En nuestro caso, hemos utilizado alpine, que extrae la versión ligera de Node.

El ARG define las variables que el constructor de Docker puede usar para construir una imagen. Las variables proporcionadas mediante esta instrucción pueden ser obligatorias u opcionales.

La documentación de Docker proporciona una referencia donde podemos leer las otras instrucciones.

En nuestro caso, hemos proporcionado una variable opcional llamada APP_NAME y una variable obligatoria llamada APP_VERSION.

Tenga en cuenta que estas variables solo estarán disponibles al crear una imagen. La siguiente sección verifica esto.

Crear una imagen

Utilice el siguiente comando para crear una imagen con la etiqueta docker-env:latest.

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

Este comando ejecuta nuestro Dockerfile de forma secuencial, y podemos ver cada paso que se está ejecutando, como se muestra a continuación.

 => [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 . .

Al crear una imagen, podemos proporcionar los valores de las variables de entorno vacías o anular los valores de entorno predeterminados mediante el comando --build-arg, como se muestra a continuación.

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

ejecutar un contenedor

Utilice el siguiente comando para ejecutar un contenedor llamado docker-env-prod que expone el puerto 3000 en el host.

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

Este comando ejecuta una instancia de nuestra aplicación y podemos acceder a ella en el navegador en localhost:3000 (http://localhost:3000/). Sin embargo, nuestro objetivo es comprobar si podemos acceder a las variables de entorno configuradas mediante la instrucción ARG.

Para verificar esto, use el siguiente comando para acceder a nuestro sistema de archivos contenedor en modo interactivo.

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

Producción :

/com/ecommerce #

Para mostrar las variables de entorno actuales, use el siguiente comando y tenga en cuenta que las dos variables que configuramos usando la instrucción ARG no se muestran.

/com/ecommerce # printenv

Producción :

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

Establecer variables de entorno utilizando la instrucción ENV

Haga las instrucciones anteriores de Docker en el Dockerfile como comentarios y copie y pegue las siguientes instrucciones en el archivo después del comentario.

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

Las instrucciones de este Dockerfile son las mismas que las del anterior, y el único cambio que hemos hecho es sustituir la instrucción ARG por la instrucción ENV.

El ENV establece las variables de entorno que el generador de Docker puede usar para crear una imagen. Las variables de entorno están en forma de pares clave-valor.

Tenga en cuenta que estas variables no son opcionales, y cada valor declarado debe tener un valor en comparación con la instrucción anterior que permite variables opcionales.

Dado que el ejemplo anterior ilustró cómo crear y ejecutar un contenedor a partir de él, use los mismos enfoques para lograr lo mismo en este ejemplo. Con la instrucción ENV, podemos acceder a nuestras dos variables de entorno, APP_NAME y APP_VERSION, como se muestra a continuación.

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

Establecer variables de entorno dinámicamente

Al construir imágenes en la línea de comando, podemos usar la instrucción ARG para asignar valores dinámicamente a las variables definidas usando la instrucción ENV.

Para ver esto en acción, haga las instrucciones anteriores en el Dockerfile como comentarios y copie y pegue las siguientes instrucciones en el archivo.

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

Tenga en cuenta que hemos agregado una instrucción ARG con una variable llamada HOST_MACHINE, que se asigna dinámicamente a una instrucción ENV con el nombre de variable DEV_ENV haciendo referencia al nombre de variable $HOST_MACHINE.

Podemos crear un valor predeterminado para el nombre de la variable HOST_MACHINE, que también se asignará a la variable DEV_ENV, o usar el comando --build-arg en la línea de comando para asignar un valor a HOST_MACHINE y nosotros obtendrá los mismos resultados.

Conclusión

En este tutorial, hemos aprendido cómo establecer variables de entorno y cómo acceder a estas variables desde un contenedor en ejecución. Hemos aprendido a usar la instrucción ARG, la instrucción ENV y cómo configurar dinámicamente las variables de entorno.

El punto principal a tener en cuenta de esto es que no se puede acceder a las variables de entorno establecidas mediante la instrucción ARG desde un contenedor en ejecución.