16. Variables de entorno

 docker --version

Variables de Entorno en Docker

¿Qué son las Variables de Entorno?

Analogía: Imagina que estás entrando a una habitación con diferentes configuraciones de luz, temperatura y sonido. Las variables de entorno son como los interruptores y controles que ajustan cómo se comporta todo dentro de esa habitación (contenedor).

Definición simple

Son valores configurables que afectan cómo se ejecutan los programas dentro de un contenedor Docker. Son pares clave-valor que pasamos al contenedor cuando lo iniciamos.

¿Por qué usar Variables de Entorno?

1. Configuración Dinámica

bash
# Ejemplo: Configurar una base de datos
docker run -e DB_PASSWORD=mi_clave_secreta mysql

2. Seguridad

  • Separar configuración del código

  • No hardcodear credenciales

  • Diferentes valores para desarrollo/producción

3. Portabilidad

Mismo contenedor, diferente comportamiento según las variables.

Cómo usar Variables de Entorno

Método 1: Directamente en el comando

bash
docker run -e VARIABLE=valor nombre_imagen

Ejemplo práctico:

bash
# Levantar PostgreSQL con contraseña
docker run --name mi-db \
  -e POSTGRES_PASSWORD=clave123 \
  -d postgres

Método 2: Archivo .env

bash
# Crear archivo .env
echo "POSTGRES_PASSWORD=clave_segura" > .env
echo "POSTGRES_USER=mi_usuario" >> .env

# Usar el archivo
docker run --env-file .env postgres

Método 3: Variables del sistema

bash
# Usar variable del sistema host
export DB_PASS=mi_secreto
docker run -e PASSWORD=$DB_PASS mi_app

Diagrama Visual (ASCII)

text
┌─────────────────────────────────────────┐
│         HOST (Tu Computadora)          │
│                                         │
│  ┌───────────────────────────────────┐  │
│  │  Terminal                         │  │
│  │  $ docker run -e VAR=valor imagen │  │
│  └───────────────────────────────────┘  │
│                    │                    │
│                    ▼                    │
└─────────────────────────────────────────┘
                    │
                    ▼
┌─────────────────────────────────────────┐
│         CONTENEDOR DOCKER               │
│                                         │
│  ┌───────────────────────────────────┐  │
│  │  Variables de Entorno:            │  │
│  │  • VAR = "valor"                  │  │
│  │  • PATH = "/usr/bin"              │  │
│  │  • HOME = "/root"                 │  │
│  └───────────────────────────────────┘  │
│                    │                    │
│                    ▼                    │
│  ┌───────────────────────────────────┐  │
│  │  Aplicación                       │  │
│  │  Usa process.env.VAR              │  │
│  └───────────────────────────────────┘  │
└─────────────────────────────────────────┘

Ejemplos Paso a Paso

Ejemplo 1: WordPress con MySQL

bash
# Base de datos MySQL
docker run --name wordpress-db \
  -e MYSQL_ROOT_PASSWORD=rootpass \
  -e MYSQL_DATABASE=wordpress \
  -e MYSQL_USER=wpuser \
  -e MYSQL_PASSWORD=wppass \
  -d mysql:5.7

# WordPress
docker run --name wordpress \
  --link wordpress-db:mysql \
  -e WORDPRESS_DB_HOST=mysql \
  -e WORDPRESS_DB_USER=wpuser \
  -e WORDPRESS_DB_PASSWORD=wppass \
  -e WORDPRESS_DB_NAME=wordpress \
  -p 8080:80 \
  -d wordpress

Ejemplo 2: Aplicación Node.js

bash
# Dockerfile para la aplicación
# (Contenido hipotético)
# FROM node:14
# COPY . .
# CMD ["node", "app.js"]

docker run -d \
  -e NODE_ENV=production \
  -e PORT=3000 \
  -e API_KEY=abc123def456 \
  -p 3000:3000 \
  mi-app-node

Buenas Prácticas

✅ RECOMENDADO

  • Usar nombres descriptivos en MAYÚSCULAS

  • Documentar las variables necesarias

  • Usar archivos .env para múltiples variables

  • Validar variables requeridas al iniciar

❌ NO RECOMENDADO

  • Guardar contraseñas en Dockerfiles

  • Usar valores por defecto inseguros

  • Exponer variables sensibles en logs

  • Ignorar variables faltantes

Caso de Estudio: PostgreSQL

1. Buscar documentación oficial

bash
# Ver en Docker Hub qué variables soporta
# Visitar: https://hub.docker.com/_/postgres

2. Variables comunes de PostgreSQL

text
POSTGRES_PASSWORD      (OBLIGATORIA)
POSTGRES_USER          (opcional, default: postgres)
POSTGRES_DB            (opcional)
POSTGRES_INITDB_ARGS   (opcional)

3. Ejecutar con variables personalizadas

bash
# Descargar imagen
docker pull postgres

# Ejecutar con configuración
docker run --name mi-postgres \
  -e POSTGRES_PASSWORD=SuperSecreto123 \
  -e POSTGRES_USER=admin \
  -e POSTGRES_DB=mi_base_datos \
  -p 5432:5432 \
  -d postgres:alpine

# Verificar
docker logs mi-postgres

Preguntas Frecuentes

❓ ¿Dónde veo qué variables acepta una imagen?

Consulta la documentación en Docker Hub o el README del repositorio.

❓ ¿Las variables persisten?

No, son específicas para cada ejecución del contenedor.

❓ ¿Puedo cambiar variables sin reiniciar?

Generalmente no, se requieren al inicio.

❓ ¿Son seguras las variables?

Sí, pero evita pasarlas en scripts públicos o logs.

Cuestionario

Preguntas

  1. ¿Qué son las variables de entorno en Docker?
    a) Archivos de configuración del sistema
    b) Valores que afectan la ejecución de programas en contenedores
    c) Comandos de Docker
    d) Imágenes preconfiguradas

  2. ¿Cuál es la forma CORRECTA de pasar una variable al iniciar un contenedor?
    a) docker run --variable NAME=value imagen
    b) docker run -e NAME=value imagen
    c) docker run --env NAME:value imagen
    d) docker run -v NAME=value imagen

  3. ¿Por qué es mejor usar variables de entorno que hardcodear valores?
    a) Porque es más rápido
    b) Por seguridad y portabilidad
    c) Porque ocupa menos memoria
    d) Porque Docker lo exige

  4. ¿Qué hace el parámetro --env-file?
    a) Crea un archivo de variables
    b) Lee variables desde un archivo
    c) Envía variables al host
    d) Encripta las variables

  5. En el comando docker run -e DB_PASS=1234 -e PORT=3000 app, ¿cuántas variables se pasan?
    a) 0
    b) 1
    c) 2
    d) 3

  6. ¿Cuál es una buena práctica para variables con contraseñas?
    a) Usar "password" como valor por defecto
    b) Guardarlas en el Dockerfile
    c) Usar archivos .env y no versionarlos
    d) Mostrarlas en los logs para debugging

  7. ¿Qué ocurre si una variable obligatoria falta?
    a) El contenedor no inicia
    b) Docker usa un valor aleatorio
    c) La aplicación puede fallar
    d) Ambas a y c

  8. Para PostgreSQL, ¿qué variable es OBLIGATORIA?
    a) POSTGRES_USER
    b) POSTGRES_DB
    c) POSTGRES_PASSWORD
    d) POSTGRES_PORT

Respuestas

  1. b) Valores que afectan la ejecución de programas en contenedores

  2. b) docker run -e NAME=value imagen

  3. b) Por seguridad y portabilidad

  4. b) Lee variables desde un archivo

  5. c) 2 (DB_PASS y PORT)

  6. c) Usar archivos .env y no versionarlos

  7. d) Ambas a y c (El contenedor no inicia y la aplicación puede fallar)

  8. c) POSTGRES_PASSWORD

Tutorial Mejorado: Variables de Entorno en Docker

🎯 Concepto Claro y Simple

Las variables de entorno son como "instrucciones de configuración" que le damos a un contenedor Docker cuando lo iniciamos. Piensa en ellas como los ajustes que haces al arrancar un videojuego: idioma, dificultad, resolución...

🔍 ¿Para qué sirven?

Escenario Práctico:

Imagina que tienes una aplicación que necesita conectarse a una base de datos. En lugar de poner la contraseña directamente en el código (¡peligroso!), usas una variable de entorno:

bash
# MAL ❌ (contraseña en el código)
conexión = "usuario:contraseña123@servidor"

# BIEN ✅ (usando variable de entorno)
conexión = f"usuario:{os.getenv('DB_PASS')}@servidor"

🚀 Cómo Empezar PASO a PASO

Paso 1: Entender la sintaxis básica

bash
# Estructura básica
docker run -e NOMBRE_VARIABLE=VALOR nombre_imagen

# Ejemplo real
docker run -e LANG=es_MX -e TZ=America/Mexico_City ubuntu

Paso 2: Probar con un ejemplo sencillo

bash
# Usar la imagen 'alpine' (muy liviana)
docker run -e SALUDO="Hola Mundo" alpine env | grep SALUDO
# Output: SALUDO=Hola Mundo

📁 Tres Métodos para Pasar Variables

Método A: Una por una (para pocas variables)

bash
docker run \
  -e USUARIO=admin \
  -e CLAVE=secreta \
  mi-app

Método B: Archivo de configuración (para muchas)

bash
# 1. Crear archivo config.env
USUARIO=admin
CLAVE=secreta
MODO=produccion
PUERTO=3000

# 2. Usarlo
docker run --env-file config.env mi-app

Método C: Desde tu sistema (avanzado)

bash
# En tu terminal
export TOKEN_API=abc123

# En Docker (se pasa automáticamente)
docker run -e TOKEN_API mi-app

🐘 Ejemplo REAL: PostgreSQL

Buscar información oficial:

  1. Ve a hub.docker.com/_/postgres

  2. Busca "Environment Variables"

  3. Encuentras las variables soportadas

Ejecutar PostgreSQL correctamente:

bash
# ¡IMPORTANTE! PostgreSQL EXIGE una contraseña
docker run -d \
  --name mi-bd \
  -e POSTGRES_PASSWORD=UnaClaveSegura123! \
  -e POSTGRES_USER=mi_usuario \
  -e POSTGRES_DB=mi_base \
  -p 5432:5432 \
  postgres:alpine  # ← Versión más pequeña

# Verificar que funciona
docker logs mi-bd

🛡️ Seguridad - Lo MÁS IMPORTANTE

REGLA DE ORO: Nunca hagas esto

bash
# ❌ PELIGROSO - Queda en el historial de comandos
docker run -e PASSWORD=1234 app

# ❌ PELIGROSO - Visible con 'docker inspect'
docker run -e PASSWORD=1234 app

Hacerlo BIEN:

bash
# ✅ SEGURO - Usar archivo .env (agregar a .gitignore)
echo "DB_PASSWORD=$(openssl rand -base64 32)" > .env.secreto
docker run --env-file .env.secreto app

# ✅ SEGURO - Pedir al usuario
read -s -p "Contraseña DB: " db_pass
docker run -e DB_PASSWORD="$db_pass" app

📊 Resumen Visual

text
TU COMPUTADORA
     │
     ├─ Archivo .env (configuraciones)
     │
     └─ Comando: docker run -e VAR=valor
                  │
                  ▼
           CONTENEDOR DOCKER
                  │
                  ├─ VAR = "valor" ✓
                  ├─ App los lee
                  └─ Se comporta según config

💡 Consejos para Principiantes

  1. Empieza simple: Prueba con 1-2 variables primero

  2. Nombres claros: USAR_MAYÚSCULAS_Y_GUIONES_BAJO

  3. Documenta: Crea un archivo .env.example con ejemplos

  4. Prueba errores: ¿Qué pasa si falta una variable?

  5. Usa valores por defecto en tu código cuando sea posible

🎮 Ejercicio Práctico

Crear un contenedor Nginx personalizado:

bash
# 1. Crear archivo de configuración
cat > nginx-config.env << EOF
NGINX_PORT=8080
NGINX_HOST=localhost
SERVER_NAME=mi_sitio
EOF

# 2. Ejecutar (usando imagen oficial)
docker run -d \
  --env-file nginx-config.env \
  -p 8080:80 \
  nginx:alpine

# 3. Verificar
curl http://localhost:8080

❓ Preguntas para Reflexionar

  • ¿Qué variables necesitaría una app web típica?

  • ¿Cómo manejarías desarrollo vs producción?

  • ¿Dónde guardarías las variables más sensibles?

📚 Recursos Adicionales

  • Documentación oficial Docker: docker run --help

  • Busca "[nombre-imagen] environment variables" en Google

  • Practica con imágenes oficiales (postgres, mysql, nginx, node)

Recuerda: Las variables de entorno son tu amiga para hacer aplicaciones flexibles y seguras. ¡Empieza con ejemplos simples y ve avanzando gradualmente! 

Comentarios

Publicar un comentario

Entradas más populares de este blog

14. Publish and Detached modes

  docker --version  Modos Publish y Detached en Docker 📚 Introducción a los Conceptos Básicos ¿Qué son los modos Publish y Detached? Imagina que un contenedor Docker es como una  habitación aislada  dentro de un edificio: Detached mode : La habitación funciona independientemente, sin que tú estés dentro vigilándola Publish mode : Abres una ventana en la habitación para que el mundo exterior pueda comunicarse con lo que hay dentro 📦 Contenedores Docker: Una Analogía Simple text ┌─────────────────────────────────────────────┐ │ HOST (Tu Computadora) │ │ │ │ ┌─────────────────────────────────────────┐ │ │ │ CONTENEDOR DOCKER │ │ │ │ ┌─────────────────────────────────┐ │ │ │ │ │ Aplicación (e...
Leer más

12. Hola Mundo en Docker.

  docker --version Hola Mundo en Docker para Principiantes 📚 Conceptos Básicos ¿Qué es Docker? Imagina que Docker es como una  máquina de empaquetado y envío  para aplicaciones. Así como las compañías navieras usan contenedores estándar para transportar cualquier mercancía (muebles, electrónicos, alimentos), Docker crea "contenedores" estandarizados para cualquier aplicación. ¿Qué es una imagen Docker? Una imagen es como una  receta de cocina completa : 📋 Lista de ingredientes (dependencias) 🍳 Instrucciones de preparación (configuraciones) ⚙️ Utensilios necesarios (binarios, librerías) Todo empacado y listo para usar ¿Qué es un contenedor? Un contenedor es como  cocinar usando esa receta : 🍽️ Tomas la receta (imagen) 🔥 Usas tu cocina (sistema operativo) 🧑‍🍳 Preparas el platillo (ejecutas la aplicación) Cada vez que cocinas, es una instancia independiente 🚀 Tu Primer Hola Mundo en Docker Paso 1: Descargar tu primera imagen bash docker pull hello-world ¿...
Leer más

11¿Qué es Docker? y ¿Por qué debo saberlo?

  docker --version  ¿Qué es Docker? y ¿Por qué debo saberlo? 1. ¿Qué es Docker? 📦 Analogía: El "Lego Digital" para Aplicaciones Imagina que Docker es como un  sistema de empaquetado universal  para software. Igual que los contenedores de transporte (esos grandes cajones metálicos que ves en barcos) pueden llevar cualquier producto de forma estandarizada, Docker "empaqueta" tu aplicación con todo lo que necesita para funcionar. text ANTES DE DOCKER: ┌─────────────────────────────────────────────┐ │ Tu Aplicación │ ├─────────────────────────────────────────────┤ │ "Necesito Node v14, MySQL 5.7, Redis 6..." │ ├─────────────────────────────────────────────┤ │ Sistema Operativo Anfitrión │ │ (Windows/Mac/Linux con sus configs únicas) │ └─────────────────────────────────────────────┘ ⚠️ PROBLEMA: "En mi máquina sí funcionaba" CON DOCKER: ┌─────────────────────────────────────────────┐ │ [CONTENED...
Leer más