Configuración de variables de entorno seguras fuera del directorio público

Las variables de entorno contienen secretos críticos: credenciales de bases de datos, claves API y configuraciones sensibles. Guardarlas dentro del directorio público (por ejemplo public_html o www) expone esos secretos a errores humanos, exploits y fugas accidentales. En esta guía técnica y práctica veremos cómo ubicar, proteger y gestionar variables de entorno fuera del directorio público para entornos PHP, Node.js, Docker y servidores Linux, con ejemplos y buenas prácticas aplicables a aplicaciones y sitios WordPress.

Por qué no deben vivir en el directorio público

Colocar archivos de configuración sensibles dentro del directorio servido por el servidor web facilita fugas por:

  • Acceso directo vía HTTP ante una mala configuración del servidor.
  • Errores de inclusión o descargas accidentales de archivos (.env, config.php).
  • Exposición al sistema de control de versiones si se suben por error (p. ej. git).

Además, los archivos dentro del webroot suelen tener permisos más laxos y mayor superficie de ataque. Guardar variables de entorno fuera del webroot reduce el riesgo y permite aplicar controles de acceso a nivel de sistema.

Dónde ubicar variables de entorno de forma segura

Ubica los secretos en rutas no accesibles por el servidor web, por ejemplo:

  • /etc//env o /etc//config.env
  • /var/www//shared/.env (fuera de /var/www//public)
  • Archivos en /home//.config/ con permisos restringidos
  • Sistemas de secret management: Vault, AWS Secrets Manager, Azure Key Vault (si está disponible)

Ejemplos prácticos por stack

PHP y aplicaciones (incluye WordPress)

Mueve el archivo de configuración fuera del webroot y referencia su ruta desde el bootstrap de la aplicación. Ejemplo simple:

// Estructura de archivos (ejemplo)
/var/www/misitio/
  shared/.env       # fuera del public
  public/index.php  # webroot
  src/bootstrap.php
// src/bootstrap.php
$env = parse_ini_file(__DIR__ . '/../shared/.env', true);
// o usar vlucas/phpdotenv
// $dotenv = Dotenv\Dotenv::createImmutable(__DIR__ . '/../shared');
// $dotenv->load();

Para WordPress puedes incluir este archivo en wp-config.php con una ruta absoluta y asegurarte de que el archivo no sea legible por otros usuarios:

define('ENV_FILE', '/var/www/misitio/shared/.env');
if (file_exists(ENV_FILE)) {
    $vars = parse_ini_file(ENV_FILE);
    foreach ($vars as $k => $v) {
        putenv("$k=$v");
        $_ENV[$k] = $v;
    }
}

Documentación útil sobre funciones de entorno en PHP: PHP.net – getenv.

Node.js

Para Node.js evita dejar .env en el webroot o en el repositorio. Colócalo fuera del directorio público y carga variables con dotenv apuntando a la ubicación absoluta:

// server.js
require('dotenv').config({ path: '/var/www/misitio/shared/.env' });

En producción, prefiere inyectar variables vía el entorno del sistema (systemd, Docker, o CI/CD) en lugar de archivos .env.

Docker y contenedores

Evita construir secretos en imágenes o comitearlos. Opciones seguras:

  • Usar docker run -e o --env-file, pero mantén el archivo en el host fuera del webroot.
  • Usar Docker Secrets (swarm) o montajes de archivos desde /run/secrets.
  • Inyectar variables a través de orquestadores (Kubernetes Secrets) en lugar de archivos en la imagen.

Configuración del servidor: evitar accesos accidentales

Si por alguna razón quedara un archivo sensible bajo el webroot, añade reglas que bloqueen su entrega. Ejemplos:

# NGINX: bloquear archivos .env
location ~ /\.env(.*)$ {
    deny all;
    return 404;
}

Documentación sobre NGINX: NGINX.

Además, configura el servidor para no listar directorios y para no interpretar archivos de configuración como descargables.

Permisos y propietario de archivos

Asegura que solo los procesos y usuarios necesarios lean los secretos:

  • Propietario: usuario de la aplicación (por ejemplo www-data o un usuario de servicio).
  • Permisos: chmod 640 o incluso 640 y propietario de grupo restringido.
  • Evita permisos 644 o 777 en archivos que contienen secretos.
sudo chown root:www-data /var/www/misitio/shared/.env
sudo chmod 640 /var/www/misitio/shared/.env

Inyección de variables desde systemd y PHP-FPM

En entornos con systemd puedes usar EnvironmentFile para mantener variables fuera del webroot y mantenerlas gestionables por el administrador:

[Service]
EnvironmentFile=/etc/misitio/env.conf
Environment=NODE_ENV=production
ExecStart=/usr/bin/node /srv/app/server.js

Para PHP-FPM, si necesitas que las variables del sistema estén disponibles en procesos PHP, configura los env en el pool o habilita clear_env = no y declara variables en /etc/php/7.x/fpm/pool.d/www.conf:

; example
clear_env = no
env[APP_ENV] = $APP_ENV
env[APP_SECRET] = $APP_SECRET

CI/CD, repositorios y control de versiones

Previene filtraciones en el flujo de desarrollo:

  • Incluye .env y archivos de config sensibles en .gitignore.
  • Usa variables de entorno del runner/CI en lugar de archivos en el repositorio.
  • Revisa cambios con herramientas de secret scanning (Git hooks, scanners en CI).

Rotación, auditoría y buenas prácticas operativas

Un secreto seguro no es eterno. Implementa:

  • Rotación periódica de claves y credenciales.
  • Registro y alertas de accesos inusuales a archivos de secretos (auditoría del sistema).
  • Least privilege: solo los servicios que requieren el secreto deben tener permisos.
  • Uso de solutions gestionadas para secretos cuando sea viable (Vault, AWS KMS), especialmente en infraestructuras distribuidas).

OWASP tiene buenas guías sobre gestión de secretos y riesgos asociados: OWASP.

Checklist rápido para despliegues seguros

  • Guardar archivos de entorno fuera del webroot.
  • Permisos mínimos (propietario y grupo correctos, 640/600).
  • No incluir archivos sensibles en repositorios; usar .gitignore.
  • Inyectar variables desde systemd, orquestador o secret manager en producción.
  • Configurar el servidor para bloquear accesos directos a patrones de archivo sensibles.
  • Auditar y rotar claves regularmente.

Errores comunes y cómo evitarlos

  • Subir .env por accidente: prevenir con hooks pre-commit y reglas en CI.
  • Conceder permisos 644 a un archivo con secretos: aplicar chmod 640 o 600.
  • Confiar en seguridad por oscuridad: siempre asumir que la configuración puede fallar y aplicar defensa en profundidad.

Conclusión

Almacenar variables de entorno fuera del directorio público es una medida técnica de bajo coste y alto impacto en la seguridad operativa. Implementarla implica decidir ubicaciones no accesibles por el servidor web, controlar permisos, usar mecanismos de inyección de entorno (systemd, contenedores, orquestadores) y aplicar políticas de rotación y auditoría. Estas prácticas reducen el riesgo de fugas accidentales y facilitan la gestión en entornos profesionales y escalables. Para profundizar en funciones específicas y comportamiento de variables en lenguajes como PHP consulte la documentación oficial en PHP.net, y para configuraciones de servidor revise NGINX y las recomendaciones de OWASP sobre gestión de secretos.