Migrar desde Auth0

Auris ofrece paridad de funcionalidades con Auth0 en autenticación, autorización y gestión de usuarios, además de capacidades que Auth0 cobra como extra o no ofrece (FGA estilo Zanzibar, aprovisionamiento SCIM integrado, Motor de Acciones con editor visual y despliegue auto-alojado). Esta guía te explica cómo realizar una migración completa de Auth0 a Auris con un tiempo de inactividad mínimo.

Mapeo de Funcionalidades

La siguiente tabla mapea las funcionalidades de Auth0 con sus equivalentes en Auris:

| Funcionalidad de Auth0 | Equivalente en Auris | Notas |

|------------------------|---------------------|-------|

| Universal Login | Páginas de Inicio de Sesión Alojadas | OAuth2 Authorization Code + PKCE, con marca del tenant |

| Rules / Actions | Motor de Acciones | JavaScript en sandbox, 6 puntos de activación, editor visual Blueprint |

| RBAC (Roles + Permisos) | Roles y Permisos V2 | Tri-estado ALLOW/DENY, alcance por aplicación |

| Organizations | Organizaciones B2B | Multi-organización con 4 roles de miembro, invitaciones basadas en tokens |

| Auth0 FGA (OpenFGA) | Auris FGA | ReBAC estilo Zanzibar, DSL compatible con OpenFGA |

| Social Connections | Inicio de Sesión Social | 9 proveedores (Google, GitHub, Microsoft, Apple, Facebook, Discord, LinkedIn, Twitter/X, Slack) |

| Enterprise Connections (SAML/OIDC) | SSO Empresarial | SAML 2.0 + OIDC vía Keycloak IdP brokering, verificación de dominio |

| Machine-to-Machine | Client Credentials | Grant client_credentials de OAuth2, basado en scopes, JWT con type: 'm2m' |

| Hooks / Webhooks | Webhooks | Firmados con HMAC-SHA256, reintentos con retroceso exponencial |

| Custom Claims | Custom JWT Claims | Por aplicación, 5 tipos de valor (estático, atributo de usuario, basado en rol, expresión) |

| MFA | Autenticación Multifactor | TOTP, SMS OTP, WebAuthn/Passkeys, MFA adaptativo con puntuación de riesgo |

| Passwordless (Email) | Magic Links | Inicio de sesión por correo basado en token con registro automático |

| Passwordless (SMS) | SMS OTP | Proveedor Twilio, con límite de frecuencia y tiempo de espera |

| Attack Protection | Protección Contra Ataques | Reglas de IP, bloqueo por fuerza bruta, CAPTCHA (Turnstile/hCaptcha/reCAPTCHA), detección de inicio de sesión sospechoso |

| Log Streaming | Transmisión de Logs | Webhook, S3, Datadog, Splunk |

| User Import/Export | Importación/Exportación de Usuarios | CSV y JSON, procesamiento asíncrono con seguimiento del progreso |

| SCIM | Aprovisionamiento SCIM 2.0 | Compatible con RFC 7644, mapeo de atributos, operaciones masivas |

| Custom Domains | Dominios Personalizados | Páginas de autenticación white-label, SSL automático |

| Rate Limiting | Limitación de Tasa | 4 niveles, ventana deslizante, cabeceras estándar |

| Branding | Marca | Logotipo, colores, favicon, nombre de empresa |

Pasos de Migración

Paso 1: Exportar Usuarios desde Auth0

Usa la API de Gestión de Auth0 para exportar tus usuarios. Puedes usar el Panel de Auth0 (Gestión de Usuarios > Importar/Exportar) o la API directamente:


 
# Crear un trabajo de exportación
 
curl -X POST https://TU_DOMINIO_AUTH0/api/v2/jobs/users-exports \
 
  -H "Authorization: Bearer $AUTH0_MANAGEMENT_TOKEN" \
 
  -H "Content-Type: application/json" \
 
  -d '{
 
    "format": "json",
 
    "fields": [
 
      { "name": "user_id" },
 
      { "name": "email" },
 
      { "name": "email_verified" },
 
      { "name": "name" },
 
      { "name": "given_name" },
 
      { "name": "family_name" },
 
      { "name": "created_at" },
 
      { "name": "app_metadata" },
 
      { "name": "user_metadata" }
 
    ]
 
  }'


 
# Comprobar el estado de la exportación
 
curl https://TU_DOMINIO_AUTH0/api/v2/jobs/ID_TRABAJO \
 
  -H "Authorization: Bearer $AUTH0_MANAGEMENT_TOKEN"
 
 
 
# Cuando el estado sea "completed", descarga el archivo desde la URL de ubicación

Auth0 no exporta los hashes de contraseñas de los usuarios que se registraron con correo/contraseña. Estos usuarios deberán restablecer su contraseña tras la migración, o puedes usar el patrón de migración diferida descrito a continuación.

Paso 2: Transformar e Importar Usuarios en Auris

Transforma el formato de exportación de Auth0 al formato de importación de Auris:


 
// transform-auth0-users.ts
 
import fs from 'fs'
 
 
 
interface Auth0User {
 
  user_id: string
 
  email: string
 
  email_verified: boolean
 
  name: string
 
  given_name: string
 
  family_name: string
 
  created_at: string
 
  app_metadata: Record<string, unknown>
 
  user_metadata: Record<string, unknown>
 
}
 
 
 
interface AurisImportUser {
 
  email: string
 
  firstName: string
 
  lastName: string
 
  emailVerified: boolean
 
  // La contraseña se omite — los usuarios establecerán una nueva mediante restablecimiento de contraseña
 
}
 
 
 
const auth0Users: Auth0User[] = JSON.parse(
 
  fs.readFileSync('auth0-export.json', 'utf-8')
 
)
 
 
 
const aurisUsers: AurisImportUser[] = auth0Users.map((user) => ({
 
  email: user.email,
 
  firstName: user.given_name || user.name?.split(' ')[0] || '',
 
  lastName: user.family_name || user.name?.split(' ').slice(1).join(' ') || '',
 
  emailVerified: user.email_verified,
 
}))
 
 
 
fs.writeFileSync('auris-import.json', JSON.stringify(aurisUsers, null, 2))
 
console.log(`Se transformaron ${aurisUsers.length} usuarios`)

Subir a Auris:


 
curl -X POST https://auth.tudominio.com/api/users/import \
 
  -H "Authorization: Bearer $AURIS_ACCESS_TOKEN" \
 
  -H "x-tenant: your-tenant-id" \
 
  -F "[email protected]" \
 
  -F "format=json"

Monitorizar el progreso de importación:


 
curl https://auth.tudominio.com/api/users/import/ID_TRABAJO_IMPORTACION \
 
  -H "Authorization: Bearer $AURIS_ACCESS_TOKEN" \
 
  -H "x-tenant: your-tenant-id"

Paso 3: Crear Aplicaciones en la Consola de Auris

Para cada Aplicación de Auth0, crea una Aplicación correspondiente en Auris:

Abre Consola → Aplicaciones → Crear Aplicación
Establece el Tipo de Aplicación para que coincida con el tipo de aplicación de Auth0:
- Auth0 “Single Page Application” o “Regular Web Application” = Auris WEB
- Auth0 “Native” = Auris MOBILE
- Auth0 “Machine to Machine” = Auris M2M
Configura las URLs de Callback Permitidas con los mismos URIs de redirección de Auth0
Configura los Orígenes Permitidos con los mismos orígenes de Auth0
Anota el nuevo Client ID (y el Client Secret para aplicaciones M2M)

Paso 4: Reemplazar el SDK de Auth0 con el SDK de Auris

Instala el SDK de Auris y elimina el de Auth0:


 
# Eliminar Auth0
 
npm uninstall @auth0/auth0-spa-js @auth0/auth0-react @auth0/nextjs-auth0
 
 
 
# Instalar Auris
 
npm install @auris/js @auris/react
 
# Para Next.js:
 
npm install @auris/nextjs

Paso 5: Actualizar el Código de tu Aplicación

La API del SDK de Auris es intencionalmente similar a la de Auth0 para minimizar el esfuerzo de migración.

Configuración del Provider (React):


 
// ANTES (Auth0)
 
import { Auth0Provider } from '@auth0/auth0-react'
 
 
 
function App() {
 
  return (
 
    <Auth0Provider
 
      domain="your-tenant.auth0.com"
 
      clientId="auth0-client-id"
 
      authorizationParams={{
 
        redirect_uri: window.location.origin + '/callback',
 
      }}
 
    >
 
      <MyApp />
 
    </Auth0Provider>
 
  )
 
}
 
 
 
// DESPUÉS (Auris)
 
import { AurisProvider } from '@auris/react'
 
 
 
function App() {
 
  return (
 
    <AurisProvider
 
      domain="auth.tuempresa.com"
 
      clientId="auris-client-id"
 
      redirectUri={window.location.origin + '/callback'}
 
    >
 
      <MyApp />
 
    </AurisProvider>
 
  )
 
}

Hook de Autenticación:


 
// ANTES (Auth0)
 
import { useAuth0 } from '@auth0/auth0-react'
 
 
 
function Profile() {
 
  const {
 
    loginWithRedirect,
 
    logout,
 
    user,
 
    isAuthenticated,
 
    isLoading,
 
    getAccessTokenSilently,
 
  } = useAuth0()
 
 
 
  if (isLoading) return <p>Cargando...</p>
 
  if (!isAuthenticated) return <button onClick={loginWithRedirect}>Iniciar sesión</button>
 
 
 
  return (
 
    <div>
 
      <p>Bienvenido/a, {user.name}</p>
 
      <button onClick={() => logout({ logoutParams: { returnTo: window.location.origin } })}>
 
        Cerrar sesión
 
      </button>
 
    </div>
 
  )
 
}
 
 
 
// DESPUÉS (Auris)
 
import { useAuris } from '@auris/react'
 
 
 
function Profile() {
 
  const {
 
    loginWithRedirect,
 
    logout,
 
    user,
 
    isAuthenticated,
 
    isLoading,
 
    getAccessToken,
 
  } = useAuris()
 
 
 
  if (isLoading) return <p>Cargando...</p>
 
  if (!isAuthenticated) return <button onClick={loginWithRedirect}>Iniciar sesión</button>
 
 
 
  return (
 
    <div>
 
      <p>Bienvenido/a, {user.name}</p>
 
      <button onClick={() => logout({ returnTo: window.location.origin })}>
 
        Cerrar sesión
 
      </button>
 
    </div>
 
  )
 
}

Llamadas a la API con Token de Acceso:


 
// ANTES (Auth0)
 
const token = await getAccessTokenSilently()
 
 
 
// DESPUÉS (Auris)
 
const token = await getAccessToken()
 
 
 
// El resto del código de llamada a la API permanece igual
 
const response = await fetch('/api/protected', {
 
  headers: { Authorization: `Bearer ${token}` },
 
})

Comprobación de Permisos (React):


 
// ANTES (Auth0 — comprobación manual del claim)
 
const { user } = useAuth0()
 
const hasPermission = user?.['https://myapp.com/permissions']?.includes('read:data')
 
 
 
// DESPUÉS (Auris — hook de permisos integrado)
 
import { useCheckPermission } from '@auris/react'
 
 
 
const canReadData = useCheckPermission('read:data')

Middleware de Next.js:


 
// ANTES (Auth0)
 
import { withMiddlewareAuthRequired } from '@auth0/nextjs-auth0/edge'
 
export default withMiddlewareAuthRequired()
 
 
 
// DESPUÉS (Auris)
 
import { aurisMiddleware } from '@auris/nextjs/middleware'
 
export default aurisMiddleware({
 
  protectedPaths: ['/dashboard(.*)'],
 
  publicPaths: ['/', '/about', '/pricing'],
 
  loginUrl: '/auth/login',
 
})

Paso 6: Actualizar las URIs de Redirección

Actualiza las URLs de Callback en tu aplicación de Auris para que coincidan con lo que envía tu app:

Reemplaza https://your-tenant.auth0.com/ por https://auth.tuempresa.com/ en todas las URIs de redirección
Si usabas la ruta de callback predeterminada de Auth0 (/api/auth/callback), actualízala a la ruta de callback de Auris

Paso 7: Migrar Rules a Actions

Las Rules y Actions de Auth0 se mapean a los triggers del Motor de Acciones de Auris:

| Trigger de Auth0 | Trigger de Auris |

|-----------------|-----------------|

| post-login | post-login |

| pre-user-registration | pre-signup |

| post-user-registration | post-signup |

| post-change-password | post-change-password |

Ejemplo de Action en Auth0:


 
// Auth0 Action (post-login)
 
exports.onExecutePostLogin = async (event, api) => {
 
  if (!event.user.email_verified) {
 
    api.access.deny('Por favor verifica tu correo antes de iniciar sesión.')
 
  }
 
 
 
  api.idToken.setCustomClaim('https://myapp.com/role', event.user.app_metadata.role)
 
}

Action equivalente en Auris:


 
// Auris Action (trigger post-login)
 
// Creado en Consola → Acciones → Nueva Acción
 
 
 
async function action(context) {
 
  if (!context.user.emailVerified) {
 
    return { deny: true, message: 'Por favor verifica tu correo antes de iniciar sesión.' }
 
  }
 
 
 
  return {
 
    claims: {
 
      role: context.user.metadata?.role || 'user'
 
    }
 
  }
 
}

Crea las acciones en la Consola en Acciones, o usa la API:


 
curl -X POST https://auth.tudominio.com/api/actions \
 
  -H "Authorization: Bearer $AURIS_ACCESS_TOKEN" \
 
  -H "x-tenant: your-tenant-id" \
 
  -H "Content-Type: application/json" \
 
  -d '{
 
    "name": "Forzar verificación de correo",
 
    "trigger": "post-login",
 
    "code": "async function action(context) {\n  if (!context.user.emailVerified) {\n    return { deny: true, message: \"Por favor verifica tu correo antes de iniciar sesión.\" }\n  }\n  return {}\n}",
 
    "status": "ACTIVE",
 
    "order": 1
 
  }'

Paso 8: Migrar RBAC

Exporta roles y permisos desde Auth0 y recréalos en Auris:


 
# Listar roles de Auth0
 
curl https://TU_DOMINIO_AUTH0/api/v2/roles \
 
  -H "Authorization: Bearer $AUTH0_MANAGEMENT_TOKEN"

Para cada rol, créalo en Auris:


 
curl -X POST https://auth.tudominio.com/api/roles \
 
  -H "Authorization: Bearer $AURIS_ACCESS_TOKEN" \
 
  -H "x-tenant: your-tenant-id" \
 
  -H "Content-Type: application/json" \
 
  -d '{
 
    "name": "Editor",
 
    "description": "Puede editar contenido",
 
    "color": "#3B82F6"
 
  }'

A continuación, asigna permisos al rol usando la Consola de Auris (Roles > [Rol] > Permisos) o la API. Auris admite permisos tri-estado (ALLOW/DENY) que son más granulares que el modelo binario de Auth0.

Paso 9: Cambio de DNS

Una vez que todo esté probado:

Configura un dominio personalizado en Auris (p. ej., auth.tuempresa.com)
Actualiza el DNS para que apunte tu dominio de autenticación a Auris
Actualiza todas las aplicaciones para usar el nuevo dominio
Monitoriza los logs de auditoría de Auris durante las primeras horas tras el cambio

Gestión de Contraseñas (Migración Diferida)

Como Auth0 no exporta los hashes de contraseñas, tienes dos opciones:

Opción A: Forzar Restablecimiento de Contraseña (Más Sencillo)

Tras importar los usuarios, activa un correo masivo de restablecimiento de contraseña:

Todos los usuarios importados reciben un correo de “Establece tu contraseña”
Los usuarios hacen clic en el enlace y establecen una nueva contraseña en Auris
No se requieren cambios de código en tu aplicación

Opción B: Migración Diferida (Sin Fricción)

Ejecuta Auth0 y Auris en paralelo temporalmente. Cuando un usuario inicia sesión:

Auris intenta autenticar al usuario
Si el usuario no tiene contraseña en Auris (importado sin una), Auris devuelve un error específico
Tu aplicación captura este error e intenta autenticarse contra Auth0 como alternativa
Si Auth0 tiene éxito, tu aplicación crea la contraseña en Auris vía la API de Administración
Los inicios de sesión posteriores van directamente a través de Auris

Este enfoque migra las contraseñas de forma transparente a medida que los usuarios inician sesión, con cero fricción.

El patrón de migración diferida requiere mantener tu tenant de Auth0 activo durante el período de migración. Planifica desactivarlo después de un período razonable (p. ej., 30-90 días) cuando la mayoría de usuarios activos hayan migrado.

Plan de Reversión

Si surgen problemas durante la migración:

Mantén Auth0 activo durante al menos 30 días después del cambio
Reversión DNS: Apunta tu dominio de autenticación de vuelta a Auth0 (según el TTL, esto tiene efecto en minutos u horas)
Reversión del SDK: Revierte los paquetes @auris/* a @auth0/* en el código de tu aplicación y vuelve a desplegar
Sin pérdida de datos: Los usuarios creados en Auris durante el período de migración pueden exportarse y re-importarse en Auth0 si es necesario

Para minimizar el riesgo de reversión, ejecuta ambos sistemas en paralelo durante un período de prueba antes del cambio completo de DNS.

Lista de Verificación Post-Migración

Después de completar la migración, verifica que:

Guías Relacionadas

Inicio de Sesión Alojado (PKCE) — Implementar el flujo de inicio de sesión
Roles y Permisos — Configurar RBAC
Autorización Detallada — Migrar desde Auth0 FGA
Importación/Exportación de Usuarios — Migración masiva de usuarios
Dominios Personalizados — Personalizar tus páginas de autenticación con tu marca
Migrar desde Firebase — Guía de migración alternativa