1 GESTIÓN DE USUARIOS Y PERMISOS EN MYSQL......................................................................................

2
2 GESTIÓN INTERNA DE USUARIOS Y PERMISOS EN MYSQL...................................................................2
2.1 EJEMPLOS DE ACCIÓN DIRECTA SOBRE TABLAS DE MYSQL....................................................................................4
3 GESTIÓN DE USUARIOS......................................................................................................................................5
3.1 CREACIÓN DE USUARIOS.........................................................................................................................................5
3.2 BORRADO DE USUARIOS.........................................................................................................................................7
3.3 OTRAS OPERACIONES SOBRE USUARIOS.................................................................................................................7
4 GESTIÓN DE PERMISOS......................................................................................................................................8
4.1 CONCESIÓN DE PRIVILEGIOS...................................................................................................................................8
4.2 REVOCAR PRIVILEGIOS.........................................................................................................................................10
4.3 OTRAS OPERACIONES SOBRE PRIVILEGIOS...........................................................................................................11
5 GESTIÓN DE ROLES...........................................................................................................................................11
5.1 CREACIÓN DE ROLES Y ASIGNACIÓN DE SUS PRIVILEGIOS...................................................................................11
5.2 ROLES OBLIGATORIOS..........................................................................................................................................12
5.3 CHEQUEAR LOS ROLES Y PRIVILEGIOS ASIGNADOS..............................................................................................13
5.4 ACTIVACIÓN DE ROLES........................................................................................................................................14
5.5 Eliminando roles y privilegios.............................................................................................................................15
1 Gestión de usuarios y permisos en MySQL

El sistema de permisos de MySQL se encarga de establecer quién puede establecer conexión con el
servidor y qué operaciones puede realizar sobre el mismo.

Cuando un usuario se conecta al servidor MySQL, su identidad queda determinada por el nombre
de usuario y por la dirección del equipo desde el que realizamos la conexión. Una vez que el
usuario está conectado, el servidor debe comprobar que ese usuario dispone de los permisos
necesarios para realizar las operaciones que requiera.

El acceso al servidor tiene lugar por tanto en dos etapas, en la primera se comprueba nuestra
identidad y en la segunda los permisos para hacer operaciones sobre los objetos del sistema.

2 Gestión interna de usuarios y permisos en MySQL

Todo lo referente a la gestión de usuarios y sus permisos correspondientes se gestiona a través de

ciertas tablas de la base de datos llamada “mysql”. Esta base de datos debe existir en cualquier
servidor, ya que sobre ella recae gran parte de la seguridad y de la configuración del sistema.

Como se trata de una base de datos gestionada por el propio servidor, un usuario con los permisos
adecuados (normalmente el root), podrá acceder directamente a su contenido e incluso modificarlo
directamente.

Para gestionar los usuarios y sus permisos se utilizan básicamente las siguientes tablas de la base de
datos mysql:
 User: Se utiliza para determinar qué usuarios pueden conectarse al sistema. Además, los
permisos definidos en esta tabla son globales, es decir, si tenemos un permiso a ‘Y’ sobre un
determinado permiso de esta tabla, podremos hacer esa operación sobre cualquier tabla de
cualquier base de datos. Es aconsejable otorgar privilegios en esta tabla sólo a los
administradores. Para otros usuarios, deberíamos dejar los privilegios de la tabla user con el
valor ‘N’ y otorgar los privilegios únicamente a niveles más específicos.
 Db: En ella se definen los permisos a nivel de base de datos de los usuarios.
 Host: Se usa en conjunción con la tabla Db cuando queremos que un registro de la tabla Db
se aplique a varios equipos. Por ejemplo, si queremos que un usuario pueda usar una base de
datos desde varios equipos en nuestra red. Un valor vacío del campo host en un registro de
la tabla Db, significa que los privilegios de dicho registro deben ser combinados con
aquellos que se encuentren en la tabla Host (a través de la operación AND).
 Tables_priv: En ella se definen los permisos a nivel de tabla de los usuarios.
 Columns_priv: En ella se definen los permisos a nivel de columnas de los usuarios.

La evaluación de permisos se realiza de forma jerárquica. Para comprobar si un usuario dispone de

un determinado permiso, primero se evalúa en la tabla global user. Si en ella tiene un valor de ‘Y’
se determina que el usuario cuenta con el permiso necesario. SI por el contrario está a ‘N’
pasaremos al siguiente nivel, es decir, a la tabla db donde se definen los permisos a nivel de base de
datos y así sucesivamente hasta llegar a las tablas tables_priv y columns_priv finalmente. Para
saber los permisos efectivos de un usuario, el servidor debe combinar la información de diversas
tablas de permisos.

La estructura de estas tablas es la siguiente:

User Db Host Tables_priv Columns_priv
Columnas de Host Host Host Host Host
alcance
User Db Db Db Db
Password User User User
Table_Name Table_Name
Column_Name
Columnas de … … … … …
privilegios
Otras … … … … …
columnas

Cada tabla de permisos contiene columnas de alcance y columnas de privilegio:

 Las columnas de alcance determinan el contexto de aplicación de los privilegios para cada
registro. Por ejemplo, un registro de la tabla user con los valores Host y User de ‘guara.org’
y ‘Antonio’, se usaría para autenticar conexiones hechas al servidor desde el equipo
guara.org por el cliente Antonio. De forma similar, un registro de la tabla db con las
columnas Host, User y Db con valores ‘guara.org’, ‘Antonio’ y ‘liga’ se usaría cuando el
usuario Antonio se conectase desde el equipo guara.org para acceder a la base de datos
llamada liga.
 Las columnas de privilegios indican qué privilegios se otorgan a cada cuenta. En las tablas
user, db y host, cada privilegio se declara como ENUM (‘N’,’Y’) DEFAULT ‘N’. En las
tablas tables_priv y columns_priv, las columnas de privilegios se declara como columnas de
tipo SET. Los valores en estas columnas pueden contener cualquier combinación de los
privilegios que afectan a tablas y columnas.

El servidor mysqld carga los contenidos de las tablas de permisos en memoria al arrancar. Podemos
hacer que lo vuelva a hacer en cualquier momento invocando al comando FLUSH PRIVILEGES.

La gestión de usuarios y permisos actuando directamente sobre estas tablas está recomendada sólo
en ocasiones muy puntuales. Lo normal es trabajar con herramientas gráficas como el MySQL
Administrator, o a través de los comandos SQL para gestionar usuarios y permisos. No obstante, es
bueno que el administrador de una base de datos MySQL conozca cómo se gestiona internamente
este tipo de información y pueda en casos muy puntuales trabajar directamente sobre estas tablas.
2.1 Ejemplos de acción directa sobre tablas de mysql

1) Ver los usuarios del sistema:

SELECT User,Host,Password FROM mysql.user;

2) Borrar al usuario ‘Pau’:

  mysql> use mysql;

        mysql> DELETE FROM user WHERE user = 'Pau';

3) La práctica propuesta en el tema anterior que consistía en cambiar la contraseña del usuario root
en un sistema en el que no nos acordamos de la contraseña del root sería así:

Iniciamos el servidor pidiéndole que no tenga en cuenta los privilegios otorgados a los usuarios:
mysqld --skip-grant-tables --skip-networking

Dependiendo de la version de MySQL que tengamos, ejecutamos una de estas sentencias:

mysql -e "UPDATE mysql.user SET Password = PASSWORD('nuevo') WHERE User = 'root'"

mysql -e "UPDATE mysql.user SET Authentication_String = PASSWORD('nuevo') WHERE User = 'root'"

Una vez modificada la contraseña, apagaremos el servidor con el siguiente comando y lo

reiniciaríamos de forma normal:

  mysqladmin shutdown

De nada sirve controlar los privilegios de los usuarios dentro del servidor de bases de datos si
fuera del servidor, en el entorno del sistema operativo, estos usuarios tienen libre acceso al
sistema de ficheros. Para evitarlo debemos vigilar los permisos de acceso de los siguientes
archivos: las bases de datos y sus tablas, ficheros de logs y de estado, ficheros de
configuración, programas ejecutables como mysqld y scripts.

4) Modificar la contraseña de acceso del usuario ‘pepito@localhost’

USE mysql;
UPDATE user SET Password = PASSWORD('nuevapasswd') WHERE User = 'pepito' AND Host = 'localhost';
FLUSH PRIVILEGES;

5) Borrar a todos los usuarios que no tienen puesta contraseña:

USE mysql;
DELETE FROM user WHERE Password = '';
FLUSH PRIVILEGES;

6) Crear un usuario que tenga todos los permisos a nivel global y que pueda acceder desde
cualquier equipo:

USE mysql;
INSERT INTO user VALUES('%','monty',PASSWORD('some_pass'),'Y','Y','Y','Y','Y','Y','Y','Y','Y','Y','Y','Y','Y','Y');
FLUSH PRIVILEGES;
La razón de usar FLUSH PRIVILEGES al crear cuentas con INSERT es decirle al servidor que vuelva a
leer las tablas de permisos. De otro modo, los cambios no se tienen en cuenta hasta que se reinicie
el servidor. Con GRANT, FLUSH PRIVILEGES no es necesario.

La razón para usar la función PASSWORD() con INSERT es cifrar las contraseñas. El comando GRANT
cifra la contraseña, así que PASSWORD() no es necesario.

7) Crear un usuario que sólo tenga permiso de acceso al servidor, pero no para realizar otras
operaciones:

USE mysql;
INSERT INTO user (Host,User,Password) VALUES('localhost','dummy','');
FLUSH PRIVILEGES;

8) Crear un usuario que tenga los permisos de RELOAD y PROCESS a nivel global:

USE mysql;
INSERT INTO user SET Host='localhost',User='admin',Reload_priv='Y', Process_priv='Y';
FLUSH PRIVILEGES;

9) Crear un usuario llamado ‘custom’ que pueda acceder desde ciertos equipos, pero que no tenga
privilegios globales.

USE mysql;
INSERT INTO user (Host,User,Password) VALUES('localhost','custom',PASSWORD('obscure'));
INSERT INTO user (Host,User,Password) VALUES('whitehouse.gov','custom',PASSWORD('obscure'));
INSERT INTO user (Host,User,Password) VALUES('server.domain','custom',PASSWORD('obscure'));

Para otorgar ciertos privilegios al usuario ‘custom’ sobre ciertas bases de datos:
INSERT INTO db (Host,Db,User,Select_priv,Insert_priv,Update_priv,Delete_priv,Create_priv,Drop_priv)
VALUES('localhost','bankaccount','custom','Y','Y','Y','Y','Y','Y');
INSERT INTO db (Host,Db,User,Select_priv,Insert_priv,Update_priv,Delete_priv,Create_priv,Drop_priv)
VALUES('whitehouse.gov','expenses','custom', 'Y','Y','Y','Y','Y','Y');
INSERT INTO db (Host,Db,User,Select_priv,Insert_priv,Update_priv,Delete_priv,Create_priv,Drop_priv)
VALUES('server.domain','customer','custom', 'Y','Y','Y','Y','Y','Y');
FLUSH PRIVILEGES;

3 Gestión de usuarios.
3.1 Creación de usuarios
Cuando creamos un nuevo usuario en MySQL, éste queda identificado por su nombre de usuario
más el nombre o IP del ordenador desde el cual hemos dicho que accederá (podemos utilizar el
carácter comodín '%' para representar varios ordenadores). La sintaxis es:

usuario@ordenador

Ejemplos de usuarios:

pepito
pepito@'%'
pepito@localhost
pepito@'192.168.0.%'
pepito@'192.168.1.0/255.255.255.0'
 pepito@'%.midominio.org'

Por ejemplo, el usuario 'pepito@localhost' se considera diferente del usuario 'pepito@192.168.0.%',

aunque tengan el mismo nombre 'pepito', y por lo tanto pueden tener permisos diferentes.

Existen varias formas de crear usuarios en el sistema:

1) La forma clásica que utiliza la sentencia GRANT.

Utilizando la sentencia GRANT podemos crear un usuario a la par que otorgarle uno o varios
privilegios sobre los objetos de una base de datos, o la base de datos completa. Al encontrarse una
sentencia de tipo GRANT, el motor de MySQL revisa si el usuario existe previamente para el
contexto que estamos asignándole permisos, y si dicho usuario no está presente en el sistema, lo
crea.

Para crear un usuario sin privilegios usaremos la sentencia:

GRANT USAGE ON *.* TO anonimo IDENTIFIED BY 'clave';

Si creamos un usuario para una máquina o conjunto de máquinas determinado, ese usuario no podrá
conectar desde otras máquinas. Por ejemplo:

GRANT USAGE ON *.* TO anónimo@localhost IDENTIFIED BY 'clave';

Un usuario que se identifique como 'anónimo' sólo podrá entrar desde el mismo ordenador donde se
está ejecutando el servidor.

En este otro ejemplo, el usuario 'anonimo' sólo puede conectarse desde un ordenador cuyo IP sea
'10.28.56.15'.:

GRANT USAGE ON * TO anonimo@10.28.56.15 IDENTIFIED BY 'clave';

2) La sentencia Create User.

A partir de la versión MySQL 5.0.2 existe la posibilidad de crear usuarios sin necesidad de
asignarles privilegios, utilizando la sentencia CREATE USER.

CREATE USER 'fernando'@'localhost' IDENTIFIED BY 'fer_pass';

El usuario recién creado no tiene privilegio alguno, por lo que deberemos asignarle permisos
utilizando sentencias GRANT (esta vez sin la cláusula IDENTIFIED BY).

Si quiero que el usuario sólo pueda acceder desde la máquina donde está el servidor:

CREATE USER 'monty'@'localhost' IDENTIFIED BY 'some_pass';

Si quiero que el usuario sólo pueda acceder desde una máquina con una dirección IP concreta puedo
utilizar la sintaxis:

CREATE USER monty@192.168.1.31 IDENTIFIED BY 'some_pass';

Si quiero que el usuario sólo pueda acceder desde cualquier máquina de una red:
 CREATE USER monty@192.168.1.% IDENTIFIED BY 'some_pass';

También es posible especificar una dirección con una máscara de red determinada:

CREATE USER 'david'@'192.58.197.0/255.255.255.0';

También puedo utilizar nombres de máquina en lugar de direcciones IP:

CREATE USER monty@%.domain.com;

3) Insertando registros directamente en la tabla users

Este es el método visto en el primer apartado del tema. Sólo es recomendado en circunstancias muy
concretas.

4) A través de las múltiples herramientas de administración que existen.

Existen varias herramientas de administración del servidor MySQL. Estas herramientas utilizan un
interfaz gráfico normalmente, así programas como MySQL Administrator, PHPMyAdmin o
MySQL Manager, permiten gestionar de forma muy sencilla e intuitiva todo lo relacionado con
usuarios y permisos dentro de nuestro sistema y además sin tener que conocer la sintaxis de los
comandos a utilizar.

3.2 Borrado de usuarios

El comando DROP USER borra una o más cuentas MySQL . Para usarlo, se debe tener el permiso
global CREATE USER o el permiso DELETE para la base de datos mysql.

Hasta la llegada de la versión 5.0.2, DROP USER borra sólo cuentas que no tienen permisos. A
partir de MySQL 5.0.2, se modificó para eliminar permisos de cuenta también. Esto significa que el
procedimiento para borrar una cuenta depende en su versión de MySQL.

Hasta MySQL 5.0.2, se puede borrar una cuenta y sus permisos como sigue:

REVOKE ALL ON *.* FROM anónimo;

DROP USER anónimo;

A partir de MySQL 5.0.2, sólo es necesario ejecutar la segunda sentencia:

DROP USER anónimo;

3.3 Otras operaciones sobre usuarios

El comando RENAME USER renombra cuentas de usuario MySQL existentes. Para usarlo, debemos
tener el permiso CREATE USER global o el permiso UPDATE para la base de datos MySQL. Fue
añadido a partir de la versión 5.0.2. La sintaxis del comando para cambiar el nombre de un
usuario es:

RENAME USER viejo_usuario TO nuevo_usuario [, viejo_usuario TO nuevo_usuario] ...

Ejemplo:

RENAME USER Pepito TO Pepito@127.0.0.1;

El comando SET PASSWORD asigna una contraseña a una cuenta de usuario MySQL existente.
Puede utilizarse de dos formas:

 Para cambiar la contraseña del usuario actual que tiene abierta la conexión. En este caso
cualquier usuario podría cambiar su contraseña. La sintaxis sería:

SET PASSWORD = PASSWORD('contraseña');

 Para cambiar la contraseña de un usuario cualquiera del sistema. Sólo los clientes con el
permiso UPDATE para la base de datos mysql pueden hacerlo. La sintaxis en este caso sería:

SET PASSWORD FOR usuario = PASSWORD('contraseña');

Es posible también bloquear de forma temporal a un usuario o crearlo en estado bloqueado

inicialmente. Las sentencias que permiten esto son:

CREATE USER Fernando IDENTIFIED BY ‘123’ ACCOUNT LOCK;

ALTER USER Fernando ACCOUNT LOCK;

ALTER USER Fernando ACCOUNT UNLOCK;

Cuando se crea un usuario o posteriormente con Alter User, se pueden establecer ciertos aspectos
relativos a la duración y caducidad de las contraseñas:

CREATE USER Fernando PASSWORD EXPIRE;

Forzaría a que el usuario tuviera que cambiar la contraseña en el siguiente inicio de sesión.

CREATE USER Fernando PASSWORD EXPIRE NEVER;

La contraseña del usuario nunca caducaría

CREATE USER Fernando PASSWORD EXPIRE INTERVAL 180 DAY;

Establece una duración para la contraseña.

CREATE USER Fernando PASSWORD EXPIRE DEFAULT;

Establecería una duración para la contraseña fijada globalmente en la variable
default_password_lifetime.
4 Gestión de permisos.
4.1 Concesión de privilegios

El comando GRANT permite a los administradores de sistemas crear cuentas de usuario MySQL y
darles permisos.

Los permisos pueden darse en varios niveles:

 Nivel global. Se aplican a todas las bases de datos de un servidor dado. Se almacenan en la
tabla mysql.user. Se utiliza GRANT ALL ON *.* para otorgarlos.

 Nivel Base de datos. Se aplican a todos los objetos de una base de datos dada. Estos
permisos se almacenan en las tablas mysql.db y mysql.host. Se utiliza GRANT ALL ON
db_name.* para otorgarlos.

 Nivel de tabla. Se aplican a todas las columnas de una tabla dada. Se almacenan en la tabla
mysql.tables_priv. Se utiliza GRANT ALL ON db_name.tbl_name para otorgarlos.

 Nivel de columna. Se aplican a ciertas columnas en una tabla dada. Se almacenan en la tabla
mysql.columns_priv. Se utiliza GRANT UPDATE(col1,col2,…coln)ON
db_name.tbl_name para otorgarlos. Los únicos valores priv_type que puede especificar
para una columna son select, insert, y update.

La lista de todos los privilegios que pueden asignarse es la siguiente:

 ALL [PRIVILEGES] Da todos los permisos simples excepto GRANT OPTION
 ALTER Permite el uso de ALTER TABLE
 ALTER ROUTINE Modifica o borra rutinas almacenadas
 CREATE Permite el uso de CREATE TABLE
 CREATE ROUTINE Crea rutinas almacenadas
 CREATE TEMPORARY TABLES Permite el uso de CREATE TEMPORARY TABLE
 CREATE USER Permite el uso de CREATE USER, DROP USER, RENAME USER y REVOKE ALL
PRIVILEGES.
 CREATE VIEW Permite el uso de CREATE VIEW
 DELETE Permite el uso de DELETE
 DROP Permite el uso de DROP TABLE
 EXECUTE Permite al usuario ejecutar rutinas almacenadas
 FILE Permite el uso de SELECT ... INTO OUTFILE y LOAD DATA INFILE
 INDEX Permite el uso de CREATE INDEX y DROP INDEX
 INSERT Permite el uso de INSERT
 LOCK TABLES Permite el uso de LOCK TABLES en tablas para las que tenga el permiso
SELECT
 PROCESS Permite el uso de SHOW FULL PROCESSLIST
 REFERENCES No implementado
 RELOAD Permite el uso de FLUSH
 REPLICATION CLIENT Permite al usuario preguntar dónde están los servidores maestro o
esclavo
 REPLICATION SLAVE Necesario para los esclavos de replicación (para leer eventos del log
binario desde el maestro)
  SELECT Permite el uso de SELECT
 SHOW DATABASES Muestra todas las bases de datos
 SHOW VIEW Permite el uso de SHOW CREATE VIEW
 SHUTDOWN Permite el uso de mysqladmin shutdown
 SUPER Permite el uso de comandos CHANGE MASTER, KILL, PURGE MASTER LOGS, and SET
GLOBAL , el comando mysqladmin debug le permite conectar (una vez) incluso si se llega a
max_connections
 UPDATE Permite el uso de UPDATE
 USAGE Sinónimo de “no privileges”
 GRANT OPTION Permite dar permisos

La siguiente sentencia concede al usuario 'anonimo' el privilegio de ejecutar consultas sobre la tabla
'gente' de la base de datos 'prueba'.

GRANT SELECT ON prueba.gente TO anonimo;

Se pueden conceder varios privilegios en una única sentencia. Por ejemplo:

GRANT SELECT, UPDATE ON prueba.gente TO anonimo IDENTIFIED BY 'clave';

Para conceder privilegios globales se usa ON *.*. En este caso los privilegios se conceden en todas
las tablas de todas las bases de datos:

GRANT SELECT ON *.* TO anónimo;

Para conceder privilegios sobre todas las tablas de una base de datos determinada se usa ON
nombre_db.*:

GRANT SELECT, INSERT ON Prueba.* TO anónimo;

En el ejemplo anterior el usuario anónimo podrá consultar e insertar registros en cualquier tabla de
la base de datos Prueba.

En la siguiente sentencia concedemos una gran cantidad de permisos al usuario julia sobre las tablas
de la base de datos películas.

GRANT SELECT, INSERT, UPDATE, DELETE, INDEX, ALTER, CREATE, DROP ON peliculas.* TO julia;

Para conceder todos los permisos:

GRANT ALL ON *.* TO julia identified by 'Qe4w' WITH GRANT OPTION;

Cuando un permiso se concede with grant option, se le permite al usuario correspondiente delegar
un permiso que posee sobre otro usuario.

Además de la opción de poder asignar los permisos a otros usuarios, es posible definir otras
opciones dentro de la claúsula WITH:

 MAX_QUERIES_PER_HOUR: Número máximo de consultas que un usuario puede

realizar en una hora. No se contabilizan únicamente los SELECT, sino cualquier comando.

 MAX_UPDATES_PER_HOUR: Número máximo de actualizaciones que un usuario puede

 realizar en una hora. Sólo los comandos que modifican la base de datos o las tablas se
contabilizan.

 MAX_CONNECTIONS_PER_HOUR: Número máximo de conexiones que un usuario

puede conectar con el servidor por hora.

 MAX_USER_CONNECTIONS: Número máximo de conexiones que un usuario puede

tener abiertas a la vez.

Por ejemplo:

GRANT USAGE ON *.* TO USER@LOCALHOST WITH MAX_QUERIES_PER_HOUR 100;

Para eliminar un límite existente, ponemos su valor a cero. Por ejemplo:

GRANT USAGE ON *.* TO USER@LOCALHOST WITH MAX_QUERIES_PER_HOUR 0;

4.2 Revocar privilegios

La sentencia REVOKE se utiliza para quitar permisos asignados a usuarios. Su sintaxis y
funcionamiento es igual que el GRANT. La única diferencia es que en lugar de dar, quita.

REVOKE SELECT ON prueba.gente FROM anónimo;

Para borrar todos los privilegios a un usuario sobre una base de datos concreta utilizaríamos:

REVOKE ALL ON foo.* FROM rafal;

Si se ha concedido privilegios con la clásula WITH GRANT OPTION, puedes revocarlos de la

siguiente forma:

REVOKE GRANT OPTION ON elemento FROM nombre_de_usuario;

4.3 Otras operaciones sobre privilegios

Para ver los permisos que tiene asignado un usuario se puede utilizar el comando SHOW GRANTS.

SHOW GRANTS FOR anonimo;

Para mostrar los posibles privilegios que hay en el sistema:

SHOW PRIVILEGES;

5 Gestión de roles
Los roles en MySQL son un conjunto de privilegios identificados mediante un nombre. Al igual que
ocurre con las cuentas de usuario es posible añadir y quitar privilegios dentro de un rol con las
sentencias Grant y Revoke.

A las cuentas de usuario se les puede asociar roles, lo que garantizará a esa cuenta los privilegios
que se incluyan dentro de ellos.

Trabajar con roles puede facilitar significativamente la gestión de la seguridad dentro del servidor
de bases de datos de la organización, sobre todo en aquellas organizaciones con gran número de
usuarios y con funciones y perfiles claramente definidos. En las antiguas versiones del servidor
MySQL no estaban implementados..

La siguiente lista resume los comandos utilizados en MySQL para trabajar con roles:
 CREATE ROLE y DROP ROLE permiten su creación y borrado.
 GRANT y REVOKE permiten añadir o quitar privilegios dentro de un rol.
 SHOW GRANTS muestra los privilegios y roles asignados a los usuarios y a los roles.
 SET DEFAULT ROLE establece qué roles de cuenta están activos por defecto cuando la
cuenta inicie sesión.
 SET ROLE cambia los roles que están activos dentro de la sesión actual.
 La función CURRENT_ROLE() muestra los roles que están activos en la sesión actual.
 Las variables MANDATORY_ROLES y ACTIVATE_ALL_ROLES_ON_LOGIN se
pueden utilizar en el fichero de configuración para definir roles obligatorios para todos los
usuarios y para activar automáticamente todos los roles que los usuarios tengan asignados.

5.1 Creación de roles y asignación de sus privilegios

Para crear los roles usamos la sentencia CREATE ROLE:

CREATE ROLE 'app_developer';

Los nombres de los roles siguen la misma nomenclatura que los nombres de cuentas de usuario, es
decir, el formato nombre@host. Si la parte del host es omitida, se asigna automáticamente a '%'. La
parte del nombre y del host podrían ir sin comillas, siempre y cuando no contengan caracteres
especiales.

Para asignar privilegios a un rol podemos utilizar la sentencia GRANT como lo hemos venido
haciendo hasta ahora, con la diferencia de que en la parte del TO se referencia al rol en lugar de al
usuario:
GRANT ALL ON app_db.* TO 'app_developer';
GRANT SELECT ON app_db.* TO 'app_read';
GRANT INSERT, UPDATE, DELETE ON app_db.* TO 'app_write';
Una vez que los roles están creados, es posible asignárselos a las cuentas de usuario:
CREATE USER 'dev1'@'localhost' IDENTIFIED BY 'dev1pass';
CREATE USER 'read_user1'@'localhost' IDENTIFIED BY 'read_user1pass';
CREATE USER 'read_user2'@'localhost' IDENTIFIED BY 'read_user2pass';
CREATE USER 'rw_user1'@'localhost' IDENTIFIED BY 'rw_user1pass';

GRANT 'app_developer' TO 'dev1'@'localhost';

GRANT 'app_read' TO 'read_user1'@'localhost', 'read_user2'@'localhost';
GRANT 'app_read', 'app_write' TO 'rw_user1'@'localhost';

Como vemos, la sentencia GRANT para asignar roles difiere de la de asignación de privilegios, ya
que no tiene cláusula ON. Por ello, no se pueden mezclar roles y privilegios dentro de la misma
sentencia. Es posible asignar indistintamente roles y privilegios a un usuario, pero con sentencias
separadas.

5.2 Roles obligatorios

Es posible especificar roles como obligatorios para todos los usuarios, si los incluimos en la
variable del sistema MANDATORY_ROLES. El servidor asigna automáticamente los roles
obligatorios a los usuarios sin necesidad de asignárselos explícitamente.

Para especificar roles obligatorios en el fichero de configuración:

[mysqld]
mandatory_roles='role1,role2@localhost,r3@%.example.com'

Si queremos cambiarlo únicamente para la instancia actual del servidor:

SET mandatory_roles = 'role1,role2@localhost,r3@%.example.com';

Los roles incluidos en mandatory_roles no pueden ser quitados a un usuario con REVOKE o
borrados con DROP ROLE.

Si un rol referenciado en mandatory_roles no estuviera definido en el sistema (diccionario de

datos), ese rol no sería asignado a los usuarios y se generaría un warning en el log de errores.

Los roles obligatorios, al igual que los asignados explícitamente, no tienen efecto real, mientras no
estén activados. La activación de roles tiene lugar si la variable
ACTIVATE_ALL_ROLES_ON_LOGIN está habilitada, o si los usuarios los tienen habilitados por
defecto. Para activar roles en tiempo de ejecución debemos utilizar la sentencia SET ROLE.
5.3 Chequear los roles y privilegios asignados

Para verificar los privilegios y roles asignados a una cuenta, usaremos la sentencia SHOW
GRANTS. Por ejemplo:

mysql> SHOW GRANTS FOR 'dev1'@'localhost';

+-------------------------------------------------+
| Grants for dev1@localhost |
+-------------------------------------------------+
| GRANT USAGE ON *.* TO `dev1`@`localhost` |
| GRANT `app_developer`@`%` TO `dev1`@`localhost` |
+-------------------------------------------------+

Sin embargo, escrito así, no podríamos saber qué privilegios incluirían los roles. Si quisiéramos
mostrar también los privilegios asignados a los roles, deberíamos utilizar la cláusula USING con el
nombre o nombres de los roles:

mysql> SHOW GRANTS FOR 'dev1'@'localhost' USING 'app_developer';

+----------------------------------------------------------+
| Grants for dev1@localhost |
+----------------------------------------------------------+
| GRANT USAGE ON *.* TO `dev1`@`localhost` |
| GRANT ALL PRIVILEGES ON `app_db`.* TO `dev1`@`localhost` |
| GRANT `app_developer`@`%` TO `dev1`@`localhost` |
+----------------------------------------------------------+

mysql> SHOW GRANTS FOR 'rw_user1'@'localhost' USING 'app_read', 'app_write';

+------------------------------------------------------------------------------+
| Grants for rw_user1@localhost |
+------------------------------------------------------------------------------+
| GRANT USAGE ON *.* TO `rw_user1`@`localhost` |
| GRANT SELECT, INSERT, UPDATE, DELETE ON `app_db`.* TO `rw_user1`@`localhost` |
| GRANT `app_read`@`%`,`app_write`@`%` TO `rw_user1`@`localhost` |
+------------------------------------------------------------------------------+

SHOW GRANTS también se puede utilizar para mostrar los privilegios asignados a un determinado
rol:

mysql> SHOW GRANTS FOR 'app_write';

+---------------------------------------+
| Grants for app_write@% |
+---------------------------------------+
| GRANT USAGE ON *.* TO `app_write`@`%` |
+---------------------------------------+

5.4 Activación de Roles

Los roles asignados a una cuenta de usuario pueden estar activos o inactivos dentro de la sesión
abierta por ese usuario en el servidor. Si un rol está activo, sus privilegios se aplicarán y si no, no.
Para determinar qué roles están activos dentro de la actual sesión, podemos usar la función
CURRENT_ROLE(). Por ejemplo:

SELECT CURRENT_ROLE();

Por defecto, los roles asignados a una cuenta explícitamente o nombrados en la variable
mandatory_roles no se activan automáticamente, a no ser que la variable
activate_all_roles_on_login esté definida. Por defecto, esta variable está deshabilitada.

Para especificar qué roles deben estar activos cada vez que un usuario se conecta al servidor,
deberíamos utilizar la sentencia SET DEFAULT ROLE.

Por ejemplo, para activar por defecto todos los roles asignados a ciertos usuarios, podríamos
utilizar el comando:
SET DEFAULT ROLE ALL TO
dev1@localhost, read_user1@localhost, read_user2@localhost,rw_user1@localhost;

Ahora, si nos conectáramos con el usuario rw_user1, e invocáramos a la función CURRENT_ROLE(),

veríamos algo como esto:

mysql> SELECT CURRENT_ROLE();

+--------------------------------+
| CURRENT_ROLE() |
+--------------------------------+
| `app_read`@`%`,`app_write`@`%` |
+--------------------------------+

Para conocer cuáles son los roles por defecto que tiene asignado en un momento dado un usuario,
podemos hacer un select a la tabla del diccionario de datos MYSQL.DEFAULT_ROLES.

SELECT * FROM MySQL.DEFAULT_ROLES;

Dentro de una sesión, un usuario puede ejecutar SET ROLE para cambiar el conjunto de roles
activos:

mysql> SET ROLE NONE; SELECT CURRENT_ROLE();

+----------------+
| CURRENT_ROLE() |
+----------------+
| NONE |
+----------------+

mysql> SET ROLE ALL EXCEPT 'app_write'; SELECT CURRENT_ROLE();

+----------------+
| CURRENT_ROLE() |
+----------------+
| `app_read`@`%` |
+----------------+
mysql> SET ROLE DEFAULT; SELECT CURRENT_ROLE();
+--------------------------------+
| CURRENT_ROLE() |
+--------------------------------+
| `app_read`@`%`,`app_write`@`%` |
+--------------------------------+

5.5 Eliminando roles y privilegios

Para quitar un rol a una cuenta, utilizaremos la sentencia:

REVOKE role FROM user;

Los roles que aparecen en la variable mandatory_roles no se le pueden quitar a un usuario.

REVOKE se puede utilizar también para modificar los privilegios que se incluyen en un rol:
REVOKE INSERT, UPDATE, DELETE ON app_db.* FROM 'app_write';

Si modificamos los privilegios de un rol, ese cambio afectará a todos los usuarios que tuvieran
asignado y activo ese rol.

Para borrar un rol del sistema, utilizamos la sentencia DROP ROLE:

DROP ROLE 'app_read', 'app_write';

Al borrar un rol, lo estaremos eliminando automáticamente de cualquier cuenta que lo tuviera

asignado.

Los roles incluidos en mandatory_roles no pueden ser eliminados.