En este modelo de base de datos les explico como modelar una base de datos para un sistema Saas o software as a service usando RBAC es decir Role Based Access Control, control de aceso basado en roles.
Vamos a usar el modelo de SaasDragon Pro que es una plantilla SaaS multi-tenant con arquitectura MVC que desarrollé para mi tienda de sistemas PHP y MySQL, la idea es que cualquiera pueda partir de una base sólida para armar su propio SaaS sin empezar desde cero.
En este artículo vamos a ver solo el módulo de tenants, roles y usuarios, que es el que controla qué puede hacer cada usuario dentro del sistema según el rol que tenga asignado.
Este modelo de base de datos es parte de mi Directorio Maestro de Modelos de Bases de Datos.
El modelo de base de datos consta de 7 tablas.
- tenant: Tabla para manejar las organizaciones o clientes del sistema
- user: Tabla de usuarios
- role: Tabla para manejar los roles
- permission: Tabla para manejar los permisos
- user_role: Tabla que relaciona los usuarios con sus roles
- role_permission: Tabla que relaciona los roles con sus permisos
- user_permission_override: Tabla para dar o quitar permisos puntuales a un usuario
Como ven las tablas son fáciles y ahora veamos la explicación de cada tabla.
Tenant
La tabla tenant identifica cada organización o cliente dentro del sistema, es útil cuando una misma instalación de la aplicación le da servicio a varias empresas al mismo tiempo.
- id: Llave primaria
- name: Nombre del tenant
- created_at: Fecha de creación
create table tenant (
id int not null auto_increment primary key,
name varchar(200) not null,
created_at datetime not null
);
User
La tabla user guarda los usuarios del sistema.
- id: Llave primaria
- tenant_id: Relaciona al usuario con su tenant
- username: Nombre de usuario
- email: Correo del usuario
- password_hash: Contraseña ya encriptada
- is_active: Indica si el usuario está activo
- created_at: Fecha de creación
- updated_at: Fecha de última modificación
create table user (
id int not null auto_increment primary key,
tenant_id int,
username varchar(50) not null,
email varchar(200) not null,
password_hash varchar(200) not null,
is_active boolean not null default 1,
created_at datetime not null,
updated_at datetime not null,
foreign key (tenant_id) references tenant(id)
);
Role
La tabla role maneja los roles del sistema, por ejemplo admin, editor o viewer.
- id: Llave primaria
- name: Nombre del rol
- description: Descripción del rol
- parent_role_id: Opcional, sirve para que un rol herede los permisos de otro rol
- created_at: Fecha de creación
create table role (
id int not null auto_increment primary key,
name varchar(50) not null,
description varchar(500),
parent_role_id int,
created_at datetime not null,
foreign key (parent_role_id) references role(id)
);
Permission
La tabla permission guarda los permisos disponibles en el sistema, cada permiso se identifica por un recurso y una acción, por ejemplo el recurso orders con la acción delete.
- id: Llave primaria
- name: Nombre completo del permiso
- resource: Recurso sobre el que aplica
- action: Acción permitida
- description: Descripción del permiso
create table permission (
id int not null auto_increment primary key,
name varchar(100) not null,
resource varchar(50) not null,
action varchar(50) not null,
description varchar(500)
);
User_role
La tabla user_role relaciona un usuario con uno o varios roles, dando la posibilidad de que un mismo usuario tenga distintos roles a la vez.
- user_id: Id del usuario
- role_id: Id del rol
- assigned_at: Fecha en la que se asignó ese rol
create table user_role (
user_id int not null,
role_id int not null,
assigned_at datetime not null,
primary key (user_id, role_id),
foreign key (user_id) references user(id),
foreign key (role_id) references role(id)
);
Role_permission
La tabla role_permission relaciona un rol con uno o varios permisos, es la tabla que realmente define qué puede hacer cada rol dentro del sistema.
- role_id: Id del rol
- permission_id: Id del permiso
create table role_permission (
role_id int not null,
permission_id int not null,
primary key (role_id, permission_id),
foreign key (role_id) references role(id),
foreign key (permission_id) references permission(id)
);
User_permission_override
La tabla user_permission_override sirve para manejar excepciones puntuales, es decir, otorgarle o quitarle un permiso a un usuario específico sin necesidad de crear un rol nuevo solo para ese caso.
- id: Llave primaria
- tenant_id: Id del tenant al que pertenece la excepción
- user_id: Usuario afectado
- permission_id: Permiso al que aplica la excepción
- granted: Indica si se está otorgando o quitando el permiso
- expires_at: Opcional, sirve para que la excepción tenga fecha de vencimiento
- deleted_at: Permite desactivar la excepción sin borrarla del todo
- created_at: Fecha de creación
create table user_permission_override (
id int not null auto_increment primary key,
tenant_id int not null,
user_id int not null,
permission_id int not null,
granted boolean not null,
expires_at datetime,
deleted_at datetime,
created_at datetime not null,
foreign key (tenant_id) references tenant(id),
foreign key (user_id) references user(id),
foreign key (permission_id) references permission(id)
);
Descargar
Si quieren probar el modelo completo con las 7 tablas y varios ejemplos de uso (insertar tenants, roles, permisos, asignar roles a usuarios y hasta una consulta para saber si un usuario puede realizar una acción según su rol y sus excepciones), les dejo el script SQL listo para importar.
Conoce SaaSDragon Pro
Si este módulo de tenants, roles y usuarios te resultó útil, imaginate tenerlo ya integrado junto con el resto del sistema, sin tener que armarlo desde cero. SaasDragon Pro incluye este módulo y mucho más, listo para que arranques tu propio SaaS en PHP y MySQL.