Cache y Seguridad¶
Cache clave-valor con SQLiteMemoryCache¶
SQLiteMemoryCache es una cache embebida, sin dependencias externas, con TTL,
tags y namespaces.
from wsbuilder import SQLiteMemoryCache, install_cache
cache = install_cache(app, SQLiteMemoryCache(default_ttl=60, cleanup_interval_seconds=0))
cache.set("user:1", {"name": "Alice"}, tags=["users", "team:docs"])
value = cache.get("user:1")
Funciones utiles:
set,get,delete,popadd,replaceget_many,set_many,mget,msetexpire,touch,ttlincr,decrtag,untag,invalidate_tag,invalidate_tagskeys,count,size_bytes,stats,metrics_snapshot
Tipos de valor soportados por defecto:
None,bool,int,float,str,bytes.- estructuras compatibles con JSON, como
dictylist.
allow_pickle=True permite otros objetos, pero solo debe usarse con datos de
confianza porque pickle no es un formato seguro frente a entradas no confiables.
Una entrada expirada se considera ausente para add y replace, incluso si
cleanup_interval_seconds=0.
Codigos ttl():
| Valor | Significado |
|---|---|
| numero positivo | segundos restantes |
-1 |
la clave existe sin expiracion |
-2 |
la clave no existe o ya expiro |
Cache HTTP de vistas con ViewResponseCache¶
Esta capa cachea respuestas de rutas view.
from wsbuilder import ViewResponseCache
http_cache = ViewResponseCache(default_ttl=20)
http_cache.add_global_rule(
ttl_seconds=30,
path_pattern="/pages/*",
mimetype_pattern="text/html*",
methods=("GET",),
name="public-pages",
)
app.enable_caches(http_cache)
Tambien puedes declarar cache por ruta:
@app.view("/pages/overview", cache={"ttl": 15, "vary_query": ["lang"]})
def overview(request):
return f"lang={request.query.get('lang', 'es')}"
El store que ViewResponseCache crea para si mismo esta acotado:
max_entries=5000 y max_bytes=64 MiB. Las claves derivan de la peticion, asi
que sin ese techo bastaria con variar el query string para llenar la memoria.
Cuando pasas tu propio store, sus limites mandan y nadie los sobreescribe.
http_cache = ViewResponseCache(default_ttl=20, max_entries=20000)
Las solicitudes con Authorization o Cookie no usan la cache compartida por
defecto. Una ruta puede habilitarlas de forma explicita:
@app.view("/account", cache={"ttl": 15, "allow_private": True})
def account(request):
return render_account(request)
Con allow_private=True, las cabeceras privadas presentes se incorporan
automaticamente a la clave. Si una respuesta declara Vary, todos sus nombres
deben aparecer en vary_headers; de lo contrario la respuesta no se almacena.
Notas practicas:
- solo actua sobre rutas
plain. - no cachea respuestas con
Set-Cookie. - respeta sin distinguir mayusculas las directivas
Cache-Controlprivadas o que requieren revalidacion. - por defecto cachea
status=200. - anade
X-WSBuilder-Cache: HITcuando sirve desde cache.
Configuracion por ruta:
| Clave | Uso |
|---|---|
ttl |
segundos de vida de la respuesta |
enabled |
False desactiva cache aunque exista regla global |
vary_query |
lista de parametros de query que forman parte de la clave |
vary_headers |
headers permitidos en Vary y parte de la clave |
allow_private |
permite cachear requests con Authorization o Cookie |
statuses |
codigos HTTP cacheables |
SecurityPolicy¶
SecurityPolicy combina ACL, listas blancas/negras, rate limiting, deteccion
de comportamiento sospechoso y bloqueos temporales.
from wsbuilder import SecurityPolicy
policy = SecurityPolicy(
rate_limit_requests=120,
rate_limit_window_seconds=60.0,
block_duration_seconds=300.0,
)
policy.deny(name="deny-admin-post", methods=("POST",), path="/api/admin")
app.enable_security(policy=policy)
Si la aplicacion esta detras de un proxy, no confies en
X-Forwarded-For sin delimitar sus redes:
policy = SecurityPolicy(
trust_x_forwarded_for=True,
trusted_proxy_cidrs=("10.0.0.0/8", "192.168.0.0/16"),
)
La cabecera solo se usa cuando el peer directo pertenece a una de esas redes.
La IP cliente se resuelve desde la derecha de la cadena, descartando saltos
confiables. Sin trusted_proxy_cidrs, se conserva siempre la IP del peer.
Metodos frecuentes:
add_whitelist,add_blacklistallow,deny,add_acl_ruleblock_ip,unblock_ipevaluate(request)observe_response(request, status_code)snapshot()
Parametros importantes del constructor:
| Parametro | Uso |
|---|---|
acl_default |
allow o deny cuando ninguna regla coincide |
rate_limit_requests |
cantidad maxima de requests por ventana |
rate_limit_window_seconds |
tamano de la ventana de rate limit |
violation_threshold |
bloquea al acumular denegaciones |
suspicious_status_codes |
codigos que cuentan como comportamiento sospechoso |
suspicious_threshold |
cantidad de respuestas sospechosas antes de bloquear |
block_duration_seconds |
duracion del bloqueo temporal |
max_tracked_clients |
maximo de IPs con contadores activos |
max_temporary_blocks |
maximo de bloqueos temporales simultaneos |
El seguimiento por cliente se indexa por IP remota, un dato que el emisor
controla. Por eso cada mapa tiene un techo: al llegar al limite se descarta el
cliente visto hace mas tiempo, de modo que un rango de origen muy amplio no
puede hacer crecer la memoria del proceso sin freno. El snapshot informa
tracked_clients_evicted_total y temporary_blocks_evicted_total.
Las entradas de la whitelist pueden prevalecer sobre blacklist y bloqueos de
comportamiento mediante whitelist_overrides_blacklist y
whitelist_bypass_behavior, ambos activos por defecto.
Los filtros ACL con path_prefix respetan limites de segmento: /api
coincide con /api y /api/users, pero no con /api-private.
Ejemplo con politica cerrada:
policy = SecurityPolicy(acl_default="deny")
policy.allow(methods=("GET",), path="/api/health")
policy.allow(methods=("GET",), path_prefix="/api/public")
app.enable_security(policy)
SecurityDecision¶
Es el resultado de evaluate(request) y ofrece:
allowedstatusmessagereasonresponse_headers()to_response()
App.dispatch() usa automaticamente ese resultado para producir texto o JSON
segun el tipo de ruta.
Headers y cookies¶
Utilidades incluidas:
normalize_header_nameget_headerhas_headerset_headeradd_headerparse_cookie_headerget_cookiebuild_set_cookie
Son helpers de bajo nivel utiles para middlewares, autenticacion ligera y tests. Los constructores rechazan nombres, valores y atributos con caracteres de control para evitar inyeccion de cabeceras.