# Variables de entorno Las variables de entorno sirven para dos cosas en Devkron: **configurar el motor** sin tocar archivos (cultura, cachés, diagnóstico) y **dar parámetros a sus programas** sin escribirlos en el código (servidor de una API, modo de operación, rutas). Esta página lista las variables que reconoce Devkron 2.0, explica cómo leer las suyas desde DKL y cómo dárselas al servidor FastCGI en Linux y en Windows. ## Variables que reconoce Devkron | Variable | Efecto | |---|---| | `DEVKRON_CULTURE` | cultura de presentación (`es-MX`, `es_MX.UTF-8`, `invariant`) si no hay `-culture` ni la llave `culture` de `fastcgi.json`. Vea [Cultura](/es/devkron/2.0/migracion/cultura.md) | | `DEVKRON_NATIVE=0` | apaga la compilación nativa; gana siempre (interruptor de emergencia) | | `DEVKRON_NATIVE_CACHE_DIR`, `DEVKRON_NATIVE_KEY_FILE` | carpeta de la caché de compilados y archivo de su llave | | `DEVKRON_COMPILE_ALL=1` | validación: compila todo en primer plano (en FastCGI la enciende aunque falte `native_compile`) | | `DEVKRON_NATIVE_STRICT=1` | un error del compilador detiene la ejecución (pruebas) | | `DEVKRON_NATIVE_STATS=1`, `DEVKRON_NATIVE_NOTES=1` | diagnóstico de la compilación nativa en stderr al salir | | `DEVKRON_NATIVE_MAX_CONTEXTS`, `DEVKRON_NATIVE_MAX_ASSEMBLY_KB`, `DEVKRON_NATIVE_MAX_PROGRAM_MB`, `DEVKRON_NATIVE_GC_AFTER_COMPILE_MB` | topes de memoria de lo compilado (equivalen a las llaves `native_max_*` de `fastcgi.json`) | | `DEVKRON_DIRECT_OUTPUT=0` | salida como árbol (apaga la salida directa) | | `DEVKRON_OUTPUT_STATS=1` | diagnóstico de la salida directa | | `DEVKRON_TREE_CACHE=1` / `=0` | caché del árbol en memoria: la enciende en consola / la apaga en FastCGI (si `fastcgi.json` no trae `tree_cache`) | | `DEVKRON_TREE_CACHE_DIR=ruta` | caché persistente del árbol (consola y FastCGI); la carpeta solo debe poder escribirla el usuario que ejecuta Devkron | | `DEVKRON_TREE_CACHE_MB` | (2.0.3) tope de memoria de la caché del árbol en MB, por proceso; 512 por omisión, `0` = sin tope. Al pasarlo se descartan los archivos de uso más antiguo (se vuelven a analizar si se piden). La llave `tree_cache_mb` de `fastcgi.json` gana. Vea [Rendimiento](/es/devkron/2.0/migracion/rendimiento.md) | | `DEVKRON_TREE_CACHE_SHARE=0` | (2.0.3) no comparte el árbol de un archivo entre sitios (uno por sitio, como 2.0.2); solo para diagnóstico | | `DEVKRON_TREE_CACHE_MAX_ENTRIES` | (2.0.3) tope de entradas de la caché del árbol; 65 536 por omisión | | `DEVKRON_TREE_CACHE_STATS=1` | (2.0.3) escribe en stderr `##arbol entradas=… arboles=… compartidos=… mb=…` cada vez que se analiza y guarda un archivo (diagnóstico) | | `DEVKRON_FASTCGI_WARMUP=0` | sin calentamiento al arrancar (si `fastcgi.json` no trae `warmup`) | | `DEVKRON_NO_CACHE=1` | apaga todas las cachés y la compilación (solo diagnóstico; mucho más lento) | | `DEVKRON_NO_COMPILE=1`, `DEVKRON_NO_COMPILE_STMT=1` | apaga la compilación interna de expresiones y sentencias (diagnóstico) | | `DEVKRON_NO_STRACCUM=1` | apaga la acumulación eficiente de cadenas (diagnóstico) | | `DEVKRON_COMPILE_STATS=1` | cuenta de expresiones y sentencias compiladas (diagnóstico) | | `DEVKRON_DBR_MAX_REPOS` | (2.0.2) repositorios de conexiones en base de datos en la caché del proceso; 32 por omisión ([Repositorios de conexiones](/es/devkron/2.0/instalacion/repositorio-conexiones.md)) | | `DEVKRON_DBR_REPO_IDLE_SEC` | (2.0.2) segundos sin uso tras los que se cierra la conexión de un repositorio en base de datos; 600 por omisión | | `DOTNET_GCgen0size` | **no la fije**: con concurrencia baja el rendimiento hasta 58 % y multiplica la memoria. Vea [Rendimiento](/es/devkron/2.0/migracion/rendimiento.md) | | `DOTNET_SYSTEM_IO_DISABLEFILELOCKING=1` | desactiva el bloqueo exclusivo de archivos; solo para el servicio que escribe en un montaje NFS v3 que se pausa al bloquear. Vea [Escribir en volúmenes de red](/es/devkron/2.0/migracion/linuxfixes.md) | | `LANG`, `LC_ALL` (Linux) | cultura del sistema, la última en la precedencia de la cultura de presentación | Las variables de diagnóstico imprimen en stderr al terminar. Por ejemplo: ```bash DEVKRON_OUTPUT_STATS=1 dkl hola.dkl -hide-log ``` ```text Hola mundo ##salida directa=1 arbol=0 inserciones=0 cortes=0 marcadores=0 vivos=0 ``` ## Leer variables de entorno desde DKL DKL no tiene una función propia para leer variables de entorno, pero se puede usar el método de .NET `System.Environment.GetEnvironmentVariable` con `_map_function`. Se mapea el mismo método **dos veces**, con distinto tipo de retorno: - Con `*` (referencia) se puede preguntar con `isnull()` si la variable existe, pero esa referencia no se puede asignar a una variable de cadena. - Con `$` (cadena) se obtiene el valor, pero si la variable no existe devuelve nulo, y al usarlo en una expresión (por ejemplo, al concatenarlo) se produce el error `Tipos no coinciden`. El tipo de retorno se indica con su código (`$`, `#`, `*`, `void`), no con el nombre del tipo: con `"System.String"` en esa posición se produce el error `Input string was not in a correct format`. La función `env.get` combina las dos y devuelve un valor predeterminado cuando la variable no existe: ```dkl #include "dkli.dkh" #! program "variables de entorno" { #include "functions.dkh" do _map_function(-1, "System.Environment", "GetEnvironmentVariable", "sys.getenv.ref", "System.String", "*") do _map_function(-1, "System.Environment", "GetEnvironmentVariable", "sys.getenv.str", "System.String", "$") env.get::nombre, predeterminado { if isnull(sys.getenv.ref(nombre)) { return predeterminado } return sys.getenv.str(nombre) } servidor = env.get("MIAPP_DB_HOST", "localhost") puerto = env.get("MIAPP_DB_PORT", "3306") do print("Servidor: " + servidor + ", puerto: " + puerto) } ``` | Variables | Salida | |---|---| | ninguna definida | `Servidor: localhost, puerto: 3306` | | `MIAPP_DB_HOST=db.ejemplo.local` y `MIAPP_DB_PORT` definida pero vacía | `Servidor: db.ejemplo.local, puerto: ` | Una variable **definida pero vacía** devuelve `""`, no el valor predeterminado. Para usar `env.get` en varios programas, póngala en un archivo de inclusión (por ejemplo `env.dkh`, fuera de `web/`). Recuerde que un archivo incluido empieza en contexto declarativo: debe iniciar con `#!` antes de `module`: ```dkl #! module "env" { do _map_function(-1, "System.Environment", "GetEnvironmentVariable", "sys.getenv.ref", "System.String", "*") do _map_function(-1, "System.Environment", "GetEnvironmentVariable", "sys.getenv.str", "System.String", "$") env.get::nombre, predeterminado { if isnull(sys.getenv.ref(nombre)) { return predeterminado } return sys.getenv.str(nombre) } } ``` En una petición web, el servidor FastCGI **también copia el entorno del proceso** a `@http_context<"request/headers/…">`, junto con los parámetros que manda nginx (comportamiento heredado de 1.x). Por eso no ponga en el entorno del servicio valores que no deban ver todos los programas del servidor, y no muestre `request/headers` completo en una página. ## Variables para el servicio FastCGI en Linux (systemd) Si el servidor FastCGI corre como unidad de systemd ([Servicio en Linux](/es/devkron/2.0/instalacion/servicio-linux.md)), dele las variables con un archivo *drop-in*, sin modificar la unidad. En los ejemplos la unidad se llama `devkron.service`; use el nombre de la suya. 1. Cree el directorio y el archivo del drop-in: ```bash sudo mkdir -p /etc/systemd/system/devkron.service.d sudo nano /etc/systemd/system/devkron.service.d/entorno.conf ``` 2. Escriba las variables de una de estas dos formas. Con `Environment=` directamente en el drop-in. **Entrecomille la asignación completa**: systemd separa por espacios, y `Environment=MIAPP_TITULO=Mi aplicación` solo asignaría `Mi`: ```ini [Service] Environment="MIAPP_DB_HOST=db.ejemplo.local" Environment="MIAPP_TITULO=Mi aplicación de ejemplo" ``` Con `EnvironmentFile=`, apuntando a un archivo aparte. Es la opción recomendada para valores que no deben quedar a la vista, porque ese archivo puede tener permisos restringidos (por ejemplo `640`, dueño `root` y el grupo con el que corre el servicio): ```ini [Service] EnvironmentFile=/etc/devkron/miapp.env ``` Contenido de `/etc/devkron/miapp.env`: ```ini MIAPP_DB_HOST=db.ejemplo.local MIAPP_TITULO="Mi aplicación de ejemplo" ``` 3. Recargue la configuración de systemd y **reinicie** el servicio: ```bash sudo systemctl daemon-reload sudo systemctl restart devkron ``` Consideraciones: - El servicio no tiene recarga (`systemctl reload` falla con "Job type reload is not applicable"). Cada vez que cambie un valor hay que **reiniciarlo**; mientras no se reinicie, los programas siguen viendo el valor anterior. - systemd **no expande** variables como `$HOME` dentro de estos valores: se toman literalmente. - Si una línea de `Environment=` es inválida, systemd la ignora y lo registra en el journal (`Invalid environment assignment`). Revíselo con `journalctl -u devkron`. - Las variables quedan disponibles para todos los programas `.dkl` que atienda ese servicio, incluidos los archivos de inclusión. ## Variables en Windows Defínalas como variables del sistema o del usuario con que corre el servidor FastCGI, en PowerShell como administrador: ```powershell [Environment]::SetEnvironmentVariable("MIAPP_DB_HOST", "db.ejemplo.local", "Machine") [Environment]::SetEnvironmentVariable("DEVKRON_CULTURE", "es-MX", "Machine") ``` Después **reinicie** la tarea o el servicio que lanza `dkl -fastcgi` ([Servicio en Windows](/es/devkron/2.0/instalacion/servicio-windows.md)): un proceso solo ve las variables que existían cuando arrancó. ## En una sola ejecución de consola ```bash MIAPP_DB_HOST=db.ejemplo.local DEVKRON_CULTURE=es-MX dkl tarea.dkl -hide-log ``` ```powershell $env:MIAPP_DB_HOST = "db.ejemplo.local"; dkl tarea.dkl -hide-log ```