# Desplegar Devkron Edge Casos completos de despliegue, de lo más simple a lo más aislado. En todos, la instalación tiene la misma forma: `dkle`, `dkle.json`, `web//` y `_config/.dkle.json` (ver [Instalación](/es/devkron/2.0/dkle/instalacion.md)). ## Caso A: un servidor, dkle atiende HTTPS directo El caso más común para un conector expuesto a Internet: un servidor en la nube, el host `conectores.ejemplo.com` apuntando a él por DNS y `dkle` en los puertos 80 y 443, con certificados de Let's Encrypt. `/opt/dkle/dkle.json`: ```json { "http": { "listen": [":80"], "redirect_https": true }, "https": { "listen": [":443"], "acme": { "email": "infra@ejemplo.com" } }, "health": { "path": "/_health", "local_only": true } } ``` `/opt/dkle/web/conectores.ejemplo.com/webhook.dkl` es el conector y `/opt/dkle/_config/conectores.ejemplo.com.dkle.json` su configuración: ```json { "app": { "erp_url": "https://erp.cliente.com/api" }, "env": ["PROVEEDOR_SECRETO"], "outbound": ["erp.cliente.com"], "limits": { "timeout_ms": 20000, "max_body_kb": 1024 } } ``` El servicio de systemd (con `AmbientCapabilities=CAP_NET_BIND_SERVICE` para los puertos 80 y 443, y el secreto en `EnvironmentFile`) está en [Instalación](/es/devkron/2.0/dkle/instalacion.md). Antes de abrir el tráfico, pruebe con el entorno de pruebas de Let's Encrypt (`"directory_url"` en `acme`, ver [Configuración](/es/devkron/2.0/dkle/configuracion.md)) y luego quítelo. ## Caso B: varios clientes en un proceso Un mismo `dkle` atiende los conectores de varios clientes, cada uno con su host: ``` /opt/dkle/ ├── dkle.json ├── _config/ │ ├── abc.conectores.ejemplo.com.dkle.json │ └── xyz.conectores.ejemplo.com.dkle.json └── web/ ├── abc.conectores.ejemplo.com/ └── xyz.conectores.ejemplo.com/ ``` Cada sitio tiene su propia configuración, sus secretos (`env` autorizadas por sitio), su caché, sus candados, sus destinos permitidos y sus límites. Un sitio no puede leer la configuración ni los datos de otro, ni incluir sus archivos. Con un certificado comodín (`*.conectores.ejemplo.com`) en `cert_dir`, o con Let's Encrypt, que pide uno por host, agregar un cliente es crear su carpeta y su archivo de configuración: no hay que reiniciar. `max_concurrent` y `timeout_ms` por sitio evitan que un cliente con mucho tráfico, o con un destino lento, acapare el servidor. ## Caso C: un proceso por cliente Cuando se quiere aislamiento a nivel de sistema operativo (memoria, CPU, usuario, versión de `dkle`), cada cliente tiene su propia instalación y su propio servicio, cada uno en su puerto, y un proxy al frente reparte por host: ``` /opt/dkle-abc/ (dkle.json escucha en 127.0.0.1:8101) servicio dkle-abc, usuario dkle-abc /opt/dkle-xyz/ (dkle.json escucha en 127.0.0.1:8102) servicio dkle-xyz, usuario dkle-xyz ``` Con systemd basta copiar la unidad (`dkle-abc.service`, `dkle-xyz.service`) cambiando `User`, `ExecStart` y `EnvironmentFile`, y limitar recursos con `MemoryMax=` y `CPUQuota=`. El proxy puede ser nginx (caso D). ## Caso D: detrás de nginx (o IIS) Si el servidor ya tiene nginx (por ejemplo, porque ahí corre Devkron 2.0), `dkle` puede quedar detrás, de dos formas. En las dos, declare a nginx como proxy de confianza para que `httpreq.ip()` sea la IP real del cliente: ```json { "http": { "listen": ["127.0.0.1:8080"] }, "fastcgi": { "listen": ["127.0.0.1:9100"] }, "trusted_proxies": ["127.0.0.1"] } ``` **Como proxy HTTP:** ```nginx server { listen 443 ssl; server_name conectores.ejemplo.com; # ssl_certificate y ssl_certificate_key como en sus demás sitios location / { proxy_pass http://127.0.0.1:8080; proxy_set_header Host $host; proxy_set_header X-Real-IP $remote_addr; proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; proxy_set_header X-Forwarded-Proto $scheme; } } ``` **Como FastCGI**, igual que Devkron 2.0: ```nginx server { listen 443 ssl; server_name conectores.ejemplo.com; location / { include fastcgi_params; fastcgi_pass 127.0.0.1:9100; } } ``` `dkle` elige el sitio por el `Host` de la petición, así que un mismo bloque `location` sirve para todos los conectores. Si nginx sirve archivos estáticos del mismo host, déjelos en sus propios `location`: `dkle` no los entrega. En Windows con IIS, el puente [iis2dkl](/es/devkron/2.0/instalacion/iis.md) se apunta a la dirección FastCGI de `dkle` en lugar de la de Devkron. ## Caso E: tareas periódicas `dkle` no tiene programador interno. La tarea es una ruta del sitio, marcada como local, y el programador del sistema operativo la llama: ```json { "local_only": ["/tareas/*"] } ``` `web/conectores.ejemplo.com/tareas/sincronizar.dkl`: ```dkl #include "dkli.dkh" #! program "sincronizar" { #include "edge.dkh" // Que no corran dos sincronizaciones a la vez si una se tarda más que el intervalo // (threads.lock con 0 ms no espera: devuelve 0 si el candado ya está tomado) if not(threads.lock("sincronizar", 0)) { do httpres.text("ya hay una en curso") return 0 } // ... pedir los cambios al ERP y enviarlos a la tienda ... do threads.unlock("sincronizar") do httpres.text("listo") } ``` Linux (`crontab -e` del usuario del servicio): ``` */15 * * * * curl -fsS -X POST -H "Host: conectores.ejemplo.com" http://127.0.0.1:8080/tareas/sincronizar.dkl >/dev/null ``` Windows (Programador de tareas, cada 15 minutos): ```powershell $accion = New-ScheduledTaskAction -Execute "curl.exe" -Argument '-fsS -X POST -H "Host: conectores.ejemplo.com" http://127.0.0.1:8080/tareas/sincronizar.dkl' $cada15 = New-ScheduledTaskTrigger -Once -At (Get-Date) -RepetitionInterval (New-TimeSpan -Minutes 15) Register-ScheduledTask -TaskName "Sincronizar conector" -Action $accion -Trigger $cada15 -User "NT AUTHORITY\NETWORK SERVICE" ``` La tarea comparte con el resto del conector la caché, los tokens y la configuración, y su resultado queda en la misma bitácora. Si `dkle` solo escucha HTTPS, agregue un `http.listen` en `127.0.0.1` para las tareas. ## Caso F: dentro de la red del cliente, con httptn Cuando el conector necesita llegar a un sistema que está en la red del cliente (un ERP local, una base de datos con su propia API) y no se quiere abrir un puerto en su firewall, `dkle` corre en un equipo de esa red (un Raspberry Pi con la versión ARM64 basta) escuchando solo en local, y el agente de [httptn](/es/productos/tools/httptn/) abre un túnel de salida hacia su servidor público. El servidor de httptn recibe las peticiones de Internet y las entrega por el túnel a `dkle`. ```json { "http": { "listen": ["127.0.0.1:8080"] } } ``` - En el agente de httptn, el destino es `http://127.0.0.1:8080`. - Si el conector valida un token del llamador (`httpreq.bearer()`), use una versión de httptn que conserve el encabezado `Authorization`: la que viene en la distribución 2.0.1 de Devkron lo quita. - Proteger las rutas locales de un `dkle` publicado por túnel le toca a quien arma el entorno: para `dkle`, una petición que llega por el túnel viene de `127.0.0.1`, así que `local_only` no la distingue de una tarea local. Publique por el túnel solo los hosts que deben ser públicos, o valide un token en las rutas de tareas. ## Antes de publicar 1. `dkle check --root /opt/dkle`: sin errores. 2. Pruebe cada ruta con `dkle run` y, si el conector llama a otros sistemas, con `--mock` hacia un servidor de pruebas. 3. Revise `outbound`, `local_only`, `limits` y que `debug` esté en `false` en producción. 4. Proteja `_config/` (y la carpeta de certificados) con permisos: solo el usuario del servicio debe leerlas. 5. Tenga a la mano la bitácora (`journalctl -u dkle -f`) y la ruta de estado (`curl http://127.0.0.1:8080/_health`) para la primera hora.