# Servidor web
Esta sección explica el modelo de programación web de Devkron 2.0 LTS: qué pasa desde que llega una petición HTTP hasta que sale la respuesta, qué datos recibe su programa, cómo responde y qué archivos del sitio puede usar para enrutar, autorizar o retocar la respuesta. Todo lo demás de esta parte de la documentación (plantillas, autenticación, CRUD-L, FSO) se construye sobre lo que se explica aquí.
La instalación y configuración del servidor (`fastcgi.json`, el servicio de systemd o de Windows, nginx, IIS con iis2dkl, la licencia) están en [Instalación y configuración](/es/devkron/2.0/instalacion/). Aquí se da por hecho que el servidor ya responde.
## Cómo funciona, en una página
Devkron no es un servidor HTTP: es un **servidor FastCGI** (`dkl -fastcgi`) al que un servidor web (nginx, o IIS 10 con `iis2dkl`) le pasa cada petición. Por cada petición:
1. El servidor FastCGI arma un registro con toda la información de la petición: la variable global **`@http_context`**.
2. Ejecuta el **controlador** `fastcgi/http.dkl` de la instalación, que decide qué archivo atiende la petición (enrutamiento), aplica la autorización y ejecuta su programa `.dkl` o entrega el archivo estático.
3. Su programa lee `@http_context<"request/...">` y escribe la respuesta en `@http_context<"response/...">`, o simplemente produce HTML con el contexto declarativo.
4. El servidor FastCGI convierte `response` en la respuesta HTTP (estado, encabezados, cookies y cuerpo) y la entrega al servidor web.
El programa más pequeño que responde a una petición es un archivo `.dkl` con HTML:
```dkl
#include "dkli.dkh"
#set "meta-xml-declaration" "\r\n"
html(lang="es")
{
head
{
title{$"Título de la página"}
}
body
{
h1{$"Encabezado"}
p{$"Párrafo de texto"}
}
}
```
Guardado como `web/misitio.localhost/index.dkl` y pedido con `http://misitio.localhost/`, responde (salida real de 2.0):
```text
HTTP/1.1 200 OK
Content-Type: text/html;charset=utf-8
Título de la páginaEncabezado
Párrafo de texto
```
## Dónde van los sitios
El controlador busca cada sitio en `web//` dentro de la carpeta de trabajo del servidor (la de la instalación): una petición a `https://tienda.ejemplo.com/ventas/` se busca en `web/tienda.ejemplo.com/ventas/`. Si no existe la carpeta del host, se usa `web/` (el sitio predeterminado). Sin licencia, el servidor solo atiende hosts `*.localhost` y `127.0.0.1`.
Dentro del sitio:
- Una URL que apunta a una carpeta se resuelve con el primer documento predeterminado que exista, en este orden: `index.dkl`, `index.html`, `index.htm`, `index.txt`, `default.dkl`, `default.html`, `default.htm`, `default.txt`, `readme.md`.
- Los archivos `.dkl` se ejecutan; los demás se entregan tal cual (`.txt`, `.htm`, `.html`, `.css` y `.js` como texto con su tipo; `.jpg`, `.jpeg`, `.png` y `.pdf` como binarios con su tipo; cualquier otro como `application/octet-stream`).
- Los archivos `.dk` y `.dkh` no se entregan como texto, pero el controlador estándar **sí los ejecuta** si alguien los pide por su URL (una biblioteca de funciones no produce salida; un `.dk` con código suelto sí se ejecuta). Por eso las piezas que no deben llamarse directamente (modelos, configuraciones con credenciales, `auth.dk`) van en `_protected/` con la carpeta restringida, o fuera de la carpeta del sitio. Vea [La carpeta protegida](/es/devkron/2.0/marcos/servidor-web/enrutamiento.md#la-carpeta-protegida).
- La **carpeta protegida** `_protected/` guarda la configuración del sitio (mapas de rutas, `auth.dk`, `render.dk`, proveedores de identidad). Vea [Enrutamiento](/es/devkron/2.0/marcos/servidor-web/enrutamiento.md#la-carpeta-protegida).
## Contenido
| Página | Qué aprenderá |
|---|---|
| [La petición y la respuesta: @http_context](/es/devkron/2.0/marcos/servidor-web/http-context.md) | Todos los miembros de `request` y `response`, encabezados, parámetros, cuerpo, archivos subidos y cookies, con un volcado real |
| [Responder HTML, XML, JSON, texto o archivos](/es/devkron/2.0/marcos/servidor-web/respuestas.md) | Las cuatro formas de responder, códigos de estado, redirecciones, descargas y el formato `{success, data}` |
| [Enrutamiento](/es/devkron/2.0/marcos/servidor-web/enrutamiento.md) | `ext.map`, `routes.map` (parámetros, opcionales y numéricos), `paths.map`, `routing.dk`, la carpeta protegida |
| [Autorización y post-procesamiento](/es/devkron/2.0/marcos/servidor-web/auth-y-render.md) | `auth.dk` y `render.dk` del sitio, la variable `@http_request` y cómo detener una petición |
| [El controlador y la pila de Devkron](/es/devkron/2.0/marcos/servidor-web/controlador-y-pila.md) | Qué hace cada archivo de `fastcgi/`, sus variables configurables, términos de despliegue (instancia, servidor ascendente, upstream) y cómo se relacionan los marcos con el servidor |
## Lo que cambió respecto a 1.x
El contenido de `@http_context` es idéntico llave por llave al de 1.x. Lo que cambió es el servidor:
- **Los códigos de estado ahora llegan al navegador.** `response/http_status` se envía como `Status:` a nginx: un programa que falla responde **500** (antes 200 con la página de error) y `404.dkl` responde 404. Revise los clientes JavaScript que solo leían el cuerpo. Detalle en [Errores HTTP 500](/es/devkron/2.0/migracion/errores-http.md).
- Ya no se pierde el último encabezado de la petición: sobra la línea `fastcgi_param HTTP_COOKIE $http_cookie;` que se agregaba en nginx (no estorba si se deja).
- Los temporales de archivos subidos se borran siempre al terminar la petición; los cuerpos grandes ya no se cargan completos en memoria.
- Cada petición tiene sus propias globales, `#path` y `errordet()`: lo que hace una no se filtra a la siguiente.
Vea la lista completa en [Migrar de 1.x a 2.0](/es/devkron/2.0/migracion/).