
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/o/env /etc//config.env /var/www/(fuera de/shared/.env /var/www/)/public - Archivos en
/home/con permisos restringidos/.config/ - 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 -eo--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-datao un usuario de servicio). - Permisos:
chmod 640o incluso640y 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
.envy 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.