DOMINICODE

Category: JavaScript

  • Diferencias Clave Entre Local Storage y Cookies

    Diferencias Clave Entre Local Storage y Cookies

    Qué diferencias hay Local Storage vs Cookies, cuándo usar uno y otro

    Tiempo estimado de lectura: 6 min

    • Las cookies viajan con cada petición HTTP, mientras que Local Storage no lo hace.
    • Cada tecnología tiene implicaciones de seguridad, rendimiento y experiencia de usuario.
    • Cuando usar cada uno depende de las necesidades específicas de almacenamiento.

    Tabla de contenidos

    Qué hace cada una (resumen técnico)

    • Cookies: pequeños pares clave‑valor (≈4 KB) diseñados para ser enviados automáticamente por el navegador en cada request al servidor. Se pueden crear desde el servidor (Set‑Cookie) o desde cliente. Soportan flags: HttpOnly, Secure, SameSite. (Docs: MDN — Cookies)
    • Local Storage: API Web Storage (HTML5). Almacén key/value en el navegador, persistente, mayor capacidad por dominio (5–10 MB típicos). Solo accesible desde JavaScript — nunca se envía automáticamente al servidor. (MDN — localStorage)

    Diferencias que importan en producción

    1. Transmisión y ancho de banda:
      • Cookies: se adjuntan en headers HTTP; cada KB añadida penaliza todas las requests. Evita almacenar grandes blobs en cookies.
      • Local Storage: no afecta tráfico; ideal para caché UI y datos voluminós.
    2. Persistencia y scope:
      • Cookies: caducidad configurable, scope por dominio/path y subdominios.
      • Local Storage: persistencia indefinida hasta borrado manual, scope por origen (protocol + host + port).
    3. Seguridad (XSS vs CSRF) — el punto crítico:
      • Cookies con HttpOnly impiden lectura por JavaScript: buen remedio contra robo de tokens vía XSS.
      • Local Storage es totalmente legible por JS: si hay XSS, el atacante puede exfiltrar cualquier dato allí guardado.
      • Cookies se envían automáticamente → riesgo CSRF salvo que uses SameSite, tokens CSRF o estrategias de double‑submit. (Guía SameSite) Para entender XSS/CSRF: OWASP tiene guías prácticas — XSS CSRF

    Reglas prácticas: cuándo usar cada uno

    Usa Cookies cuando:

    • Guardas tokens de autenticación o session IDs sensibles. Implementa HttpOnly + Secure + SameSite donde aplique.
    • Necesitas que el servidor reconozca automáticamente al cliente en cada petición.
    • Requieres expiración y control centralizado del ciclo de sesión.

    Usa Local Storage cuando:

    • Guardas preferencias de UI, temas, estado de formularios, pequeños cachés que mejoran UX.
    • Necesitas almacenamiento más grande y rápido sin impactar la red (listas estáticas, drafts).
    • No guardas secretos ni tokens que comprometan cuentas si se filtran.

    Ejemplos concretos

    Guardar preferencia de tema (Local Storage):

    localStorage.setItem('theme', 'dark');
const theme = localStorage.getItem('theme');

    Setear cookie segura desde servidor (Node/Express):

    res.cookie('session', sessionId, { httpOnly: true, secure: true, sameSite: 'Lax', maxAge: 1000*60*60 });

    Evita este patrón inseguro (no lo copies): Almacenar JWT de acceso en localStorage en una app pública: fácil exfiltración si tienes XSS.

    Errores comunes que cuestan

    • Poner el token principal en localStorage “porque es más cómodo”. Resultado: una inyección de script y sesión comprometida.
    • Volcar demasiado estado en cookies y degradar las peticiones móviles.
    • No configurar SameSite o CSRF tokens cuando usas cookies, dejando la app abierta a forzados desde otros orígenes.

    Conclusión práctica

    No hay “mejor” absoluto. Pregunta primero: ¿este dato necesita viajar automáticamente al servidor y es sensible? → Cookies (bien configuradas). ¿Es estado de UI o caché que no debe hinchar el tráfico? → Local Storage. Decide por capas: auth en cookies seguras; UX y rendimiento en localStorage. Esa elección evita bugs, reduce superficie de ataque y mejora latencia en producción.

    FAQ

    ¿Cuál es la capacidad máxima de Cookies y Local Storage?

    Las cookies suelen tener un tamaño máximo de aproximadamente 4 KB, mientras que Local Storage puede almacenar entre 5 y 10 MB por dominio.

    ¿Cómo se manejan los datos en Local Storage?

    Los datos en Local Storage se manejan a través de JavaScript con métodos como setItem para agregar datos y getItem para recuperarlos, y permanecen allí hasta que se eliminen manualmente.

    ¿Qué medidas de seguridad debo tomar con Cookies?

    Debes usar flags como HttpOnly y Secure para proteger las cookies y configurar el atributo SameSite para reducir el riesgo de CSRF.

    ¿Se pueden utilizar Cookies y Local Storage juntos?

    Sí, puedes usar ambas tecnologías para diferentes propósitos en tu aplicación, como almacenar datos de sesión en cookies y preferencias de usuario en Local Storage.

  • Diferencias Clave entre Autenticación y Autorización

    Diferencias Clave entre Autenticación y Autorización

    Cuales son las diferencias entre Authentication vs Authorization

    Tiempo estimado de lectura: 8 min

    • Diferencia clara: Authentication es identidad; Authorization son permisos.
    • Protocolos comunes: OIDC para AuthN, OAuth 2.0 para AuthZ.
    • Errores comunes: confundir códigos HTTP 401 y 403.
    • Modelos de autorización: RBAC es simple, ABAC es granular.
    • Implementaciones prácticas: centralizar AuthN, validar scopes.

    Tabla de contenidos

    Introducción

    Cuales son las diferencias entre Authentication vs Authorization: la pregunta aparece temprano en cualquier diseño de seguridad porque confundir ambos conceptos no es una cuestión académica; es la forma más rápida de abrir agujeros en producción. En las primeras líneas: authentication responde “¿quién eres?”; authorization responde “¿qué puedes hacer?”.

    Cuales son las diferencias entre Authentication vs Authorization (resumen técnico)

    La distinción es simple en teoría y compleja en la práctica.

    • Authentication (AuthN): verificación de identidad. ¿Eres el usuario X? Métodos: contraseña, MFA, biometría. Protocolos: OpenID Connect (OIDC), SAML. Resultado típico: ID Token (JWT) o sesión autenticada.
    • Authorization (AuthZ): decisión de permisos. ¿Puede el usuario X leer el recurso Y? Estrategias: RBAC, ABAC, policies. Protocolo: OAuth 2.0 para delegación de permisos. Resultado: Access Token con scopes o reglas de autorización aplicadas en el recurso.

    Fuentes estándar: OAuth 2.0, OpenID Connect, OWASP.

    Por qué importa la separación: 401 vs 403 y consecuencias reales

    Un error frecuente en APIs REST es confundir códigos HTTP:

    • 401 Unauthorized → significa no autenticado (falta o token inválido). Solución: autenticar.
    • 403 Forbidden → significa autenticado pero sin permisos. Solución: revisar roles/scopes.

    Confundirlos genera logs inútiles y malas respuestas UX, y lo peor: entornos donde un JWT “lo arregla todo” sin validar scopes en los endpoints. OWASP mantiene guías prácticas sobre autenticación y autorización: OWASP Top Ten.

    Protocolos y artefactos: OIDC, OAuth2, JWT

    • OIDC = capa de identidad sobre OAuth2. Sirve para AuthN. Emite ID Tokens (JWT) con claims sobre el usuario. Doc: OpenID Connect.
    • OAuth2 = autorización delegada. Emite Access Tokens (pueden ser JWT u opacos) que describen scopes (ej. read:orders). RFC: RFC 6749.
    • JWT = formato común para transportar claims. Útil pero peligroso si se confía ciegamente en su contenido sin validarlo (firma, issuer, expiration).

    Ejemplo mínimo: un backend verifica la firma del JWT (iss, aud, exp) para AuthN; luego extrae scopes o roles para AuthZ en cada endpoint.

    Modelos de autorización: RBAC vs ABAC y cuándo usarlos

    • RBAC (Role-Based Access Control): simple y auditable. Ideal cuando los permisos son estables y los roles claros (Admin, Editor, Viewer).
    • ABAC (Attribute-Based Access Control): más granular. Evalúa atributos (usuario.department, resource.owner, timeOfDay). Recomendado cuando las reglas son contextuales y dinámicas.

    Para microservicios, considera un PDP (Policy Decision Point) centralizado y PEPs (Policy Enforcement Points) ligeros en cada servicio.

    Implementación práctica: patrón recomendado

    1. Centraliza AuthN en un Identity Provider (IdP) — Keycloak, Auth0, Okta. Use OIDC.
    2. Emite Access Tokens cortos y Refresh Tokens bien protegidos.
    3. En el gateway o API, valida AuthN (token válido). Luego aplica AuthZ por endpoint (roles/scopes/policies).
    4. Principe de menor privilegio: asigna mínimos scopes necesarios.
    5. Audita fallos de AuthN y AuthZ separadamente (métricas claras: fallos 401 vs 403).

    Ejemplo rápido (pseudocódigo):

    if not validate_token(request.auth): return 401
    if not has_scope(request.auth.scopes, “orders:write”): return 403
    // proceed with action

    Autenticación y autorización en automatización y agentes

    Cuando tu sistema incorpora agentes, workflows o LLMs que actúan sobre datos sensibles, la distinción se vuelve crítica. Un agente debería:

    • Autenticarse con una Service Account (AuthN).
    • Operar con permisos limitados (AuthZ: least privilege).

    En flujos n8n o pipelines de IA, diseña credenciales de service accounts con scopes mínimos y registra todas las acciones por agente. Evita usar credenciales humanas para automatizaciones.

    Para patrones prácticos en integraciones con n8n, agentes y pipelines seguros, revisa Dominicode Labs. Allí encontrarás blueprints que muestran cómo gestionar tokens, separar AuthN/AuthZ y desplegar flujos reproducibles en producción.

    Errores comunes y decisiones de criterio

    • No validar scopes en el backend: asumir que “si el token es válido, está autorizado”.
    • Usar JWTs con expiraciones largas sin refresh seguro.
    • Conceder a agentes permisos de administrador por comodidad.
    • Loggear datos sensibles en errores de autenticación.

    Criterio senior: autenticación como puerta de entrada; autorización como control continuo. Diseña ambos con capacidad de revocación, monitoreo y pruebas automáticas.

    Conclusión

    Entender las diferencias entre Authentication vs Authorization te permite diseñar sistemas donde la identidad se verifica correctamente y los permisos se aplican estrictamente. Usa OIDC para identificar, OAuth2 para delegar permisos, y aplica políticas claras (RBAC o ABAC) en cada servicio. Si trabajas con automatizaciones o agentes, implementa service accounts con scopes mínimos y sigue patrones reproducibles — como los que publicamos en Dominicode Labs — para no poner en producción atajos que acaben costando caro.

    FAQ

    ¿Qué es Authentication?

    Authentication es el proceso de verificar la identidad de un usuario. Asegura que una persona es quien dice ser, utilizando métodos como contraseñas, autenticación multifactor (MFA) y biometría.

    ¿Qué es Authorization?

    Authorization es el proceso que determina si un usuario autenticado tiene permisos para acceder a recursos específicos o realizar ciertas acciones dentro de un sistema.

    ¿Cuándo usar RBAC y ABAC?

    RBAC se utiliza cuando los roles son claramente definidos y los permisos son relativamente estáticos, mientras que ABAC es ideal para escenarios donde se requieren políticas más granulares y contextuales basadas en atributos.

    ¿Qué son JWT y sus riesgos?

    JWT (JSON Web Tokens) son un formato común para transportar claims entre partes. Aunque son prácticos, pueden ser peligrosos si se confía ciegamente en su contenido sin la debida validación de su firma, emisor y tiempo de expiración.

    ¿Cómo centralizar AuthN?

    Para centralizar la autenticación, se debe utilizar un proveedor de identidad (IdP) como Keycloak, Auth0 u Okta, asegurando que todas las autenticaciones pasen a través de un único punto de fallo.

  • Diferencias entre CSR, SSR, SSG e ISR en Desarrollo Web

    Diferencias entre CSR, SSR, SSG e ISR en Desarrollo Web

    Tiempo estimado de lectura: 6 min

    • Comprender los tipos de renderizado (CSR, SSR, SSG, ISR).
    • Impacto en rendimiento, SEO y costo operacional.
    • Criterios claros para elegir el método adecuado.
    • Patrones híbridos y su aplicación en producción.
    • Necesidad de automatización en regeneración de contenido.

    Tabla de contenidos

    Qué son y cuáles son sus diferencias: definiciones limpias

    • CSR (Client-Side Rendering): el servidor entrega un HTML mínimo y todo el render lo hace el navegador ejecutando JavaScript. Ideal para SPAs donde la lógica y el estado residen en el cliente.
    • SSR (Server-Side Rendering): el servidor renderiza HTML por cada petición y lo envía listo para mostrar; luego el cliente hidrata la página para interactividad.
    • SSG (Static Site Generation): todas las páginas se generan en el build (CI) y se sirven como archivos estáticos desde un CDN.
    • ISR (Incremental Static Regeneration): SSG con regeneración incremental; páginas estáticas se revalidan y regeneran en background según política.

    Fuentes oficiales: Next.js App Router docs, y guía de rendering de Google.

    Impacto técnico: latencia, coste y SEO (resumen práctico)

    • TTFB / FCP:
      • SSG/ISR: TTFB muy bajo por CDN. Excelente FCP.
      • SSR: HTML rápido, pero puede aumentar TTFB si el servidor trabaja mucho.
      • CSR: TTFB alto (esperas JS); FCP y LCP suelen penalizarse.
    • SEO:
      • Mejor: SSR, SSG, ISR.
      • Peor: CSR (si dependes del crawler que no ejecuta JS).
    • Carga en infra:
      • Alta: SSR (render por request).
      • Baja: SSG/ISR (CDN + regeneraciones puntuales).
      • Mínima: CSR (solo sirve assets).
    • Datos dinámicos:
      • SSR y CSR cubren escenarios por usuario.
      • SSG e ISR son para datos eventual-consistentes o actualizados bajo control.

    Criterios claros para escoger por ruta

    Elige según tres preguntas: ¿Es público y requiere SEO? ¿Necesitas datos por usuario en cada request? ¿Cuánta frescura de datos necesitas?

    • Usa CSR cuando:
      • Es una app privada (dashboard, internal tool).
      • Interactividad extrema y estado complejo en cliente.
      • SEO no es prioridad.
      • Ejemplo: editor de datos en tiempo real, SPA administradora.
    • Usa SSR cuando:
      • Contenido personalizado por request (cookies, auth, headers).
      • SEO crítico y datos deben ser frescos al segundo.
      • Tráfico moderado o tienes recursos para escalar server.
      • Ejemplo: feed social personalizado, páginas con precios dinámicos.
    • Usa SSG cuando:
      • Contenido estable y SEO importante (marketing, docs).
      • Quieres la máxima velocidad y costo bajo.
      • Ejemplo: documentación técnica, landing pages.
    • Usa ISR cuando:
      • Necesitas la velocidad de SSG pero con frescura periódica.
      • Tráfico alto y datos que cambian con cierta cadencia.
      • Ejemplo: catálogo e-commerce (revalida cada N segundos) o blog de noticias con alto tráfico.

    Patrones híbridos: la práctica real en producción

    En apps modernas rara vez eliges una sola estrategia. Combina por ruta:

    • Home en SSG para FCP instantáneo.
    • Landing en ISR para actualizar sin rebuild.
    • Ficha de producto en ISR o SSR según necesidad de consistencia.
    • Carrito y checkout en CSR o SSR según seguridad y UX.

    En Next.js App Router puedes mezclar Server Components (SSG/SSR) y Client Components (CSR) en la misma página, usando Suspense boundaries para streaming y UX progresiva.

    Costes operativos y monitoreo

    No es solo arquitectura: monitoriza Core Web Vitals y coste por request en tu plataforma de hosting (Vercel, Netlify, AWS). SSR puede multiplicar facturación si no controlas cacheo y cold starts. SSG/ISR reduce costos pero añade complejidad en CI/CD y tiempo de build si no implementas generación parcial.

    Dominicode Labs: automatización práctica para el mundo real

    Cuando tu stack necesita frescura sin sacrificar velocidad, automatizar la regeneración es clave. En Dominicode Labs construimos plantillas y pipelines que conectan CMS y eventos de negocio con la estrategia de render adecuado:

    • Qué es: Dominicode Labs es nuestro laboratorio de ingeniería aplicada donde diseñamos workflows (n8n), agentes y pipelines de despliegue para arquitecturas híbridas.
    • Por qué tiene sentido: en sitios con miles de páginas, no quieres rebuilds completos; preferirás ISR on-demand disparado por webhooks o agentes de IA que actualizan solo las páginas afectadas.
    • Qué ofrece: ejemplos listos de ISR on-demand, flujos n8n para escuchar cambios en la base de datos o CMS y disparar regeneración; plantillas Next.js optimizadas para SSG/ISR + monitorización de Core Web Vitals.

    Conclusión operativa

    No existe una “mejor” palabra mágica. La decisión técnica es una combinación de:

    • naturaleza del contenido (estático vs personalizado),
    • requisitos de SEO,
    • presupuesto infra,
    • y tolerancia a consistencia eventual.

    Regla simple: prioriza SSG/ISR para contenido público y escalable, SSR para personalización crítica en tiempo real, y CSR para experiencias interactivas privadas. Mide siempre (Lighthouse, RUM) y automatiza regeneraciones donde la frescura importa —es ahí donde pasar de teoría a práctica te ahorrará dinero y dolores de cabeza en producción.

    FAQ

    ¿Cuál es la mejor opción para SEO? La mejor opción para SEO es SSR, SSG o ISR, ya que estos métodos generan contenido que es accesible para los crawlers de los motores de búsqueda sin depender de la ejecución de JavaScript.

    ¿Qué método elegir para una aplicación privada? Para una aplicación privada, CSR es la opción más adecuada, ya que permite interactividad y complejidad del estado en el cliente sin preocupaciones de SEO.

    ¿Cuáles son las ventajas de SSG? Las ventajas de SSG incluyen velocidad óptima y costos operativos bajos al servir contenido estático desde un CDN, ideal para contenido estable y estratégico.

    ¿ISR es lo mismo que SSG? No, ISR (Incremental Static Regeneration) es un método que permite regenerar páginas estáticas de forma incremental, combinando los beneficios de SSG con frescura periódica.

    ¿Cómo afecta el rendimiento la elección de renderizado? La elección de renderizado afecta directamente al tiempo de carga percibido y a métricas como TTFB, FCP y LCP. Últimamente, SSG e ISR son óptimos para un rendimiento rápido, mientras que CSR puede degradarlo si se basa excesivamente en JavaScript.