Amazon Redshift dejará de admitir la creación de nuevas UDF de Python a partir del parche 198. Las UDF de Python existentes seguirán funcionando hasta el 30 de junio de 2026. Para obtener más información, consulte la [publicación del blog](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/).
# Control de acceso basado en roles (RBAC)
Utilizando el control de acceso basado en roles (RBAC) para administrar los permisos de base de datos en Amazon Redshift, puede simplificar la administración de los permisos de seguridad en Amazon Redshift. Puede proteger el acceso a información confidencial controlando lo que los usuarios pueden hacer tanto en un nivel general como detallado. También puede controlar el acceso de los usuarios a tareas que normalmente solo se permiten a los superusuarios. Asignando permisos diferentes a roles diferentes y asignándolos a usuarios diferentes, puede tener un control más detallado del acceso de los usuarios.
Los usuarios con un rol asignado solo pueden realizar las tareas que estén especificadas por el rol asignado para el que tengan autorización. Por ejemplo, un usuario con el rol asignado que tenga los permisos CREATE TABLE y DROP TABLE solo tiene autorización para realizar esas tareas. Puede controlar el acceso de los usuarios concediendo diferentes niveles de permisos de seguridad a usuarios diferentes para que accedan a los datos que necesitan para su trabajo.
RBAC aplica el principio de permisos mínimos a los usuarios en función de sus requisitos de rol, con independencia de los tipos de objetos involucrados. La concesión y revocación de permisos se realiza en el nivel del rol, sin necesidad de actualizar los permisos en objetos de base de datos individuales.
Con RBAC, puede crear roles con permisos para ejecutar comandos que antes necesitaban permisos de superusuario. Los usuarios pueden ejecutar estos comandos, siempre que hayan recibido autorización con un rol que incluya tales permisos. De manera similar, también puede crear roles para limitar el acceso a determinados comandos y asignar el rol a superusuarios o usuarios que hayan recibido autorización con ese rol.
Para obtener información sobre cómo funciona Amazon Redshift RBAC, vea el siguiente video.
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/IhHQ7mZ-tp4)
# Jerarquía de roles
Los *roles* son conjuntos de permisos que se pueden asignar a un usuario o a otro rol. Puede asignar permisos del sistema o de base de datos a un rol. Un usuario hereda los permisos de un rol asignado.
En RBAC, los usuarios pueden tener roles anidados. Puede conceder roles tanto a usuarios como a roles. Cuando se concede un rol a un usuario, se autoriza a ese usuario con todos los permisos que incluya este rol. Cuando se concede un rol r1 a un usuario, se autoriza a ese usuario con los permisos de r1. El usuario ahora tiene los permisos de r1, así como cualquier otro permiso que ya tuviera.
Cuando se concede un rol (r1) a otro rol (r2), se autoriza a r2 con todos los permisos de r1. Además, cuando se concede r2 a otro rol (r3), los permisos de r3 son la combinación de los permisos de r1 y r2. La jerarquía de roles hace que r2 herede los permisos de r1. Amazon Redshift propaga los permisos con cada autorización de rol. Cuando se concede r1 a r2, y después r2 a r3, se autoriza a r3 con todos los permisos de los tres roles. Por lo tanto, si se concede r3 a un usuario, ese usuario tiene todos los permisos de los tres roles.
Amazon Redshift no permite crear un ciclo de autorización de roles. Un ciclo de autorización de roles ocurre cuando se asigna un rol anidado a un rol anterior en la jerarquía de roles; por ejemplo, asignar r3 a r1. Para obtener más información sobre cómo crear roles y administrar la asignación de roles, consulte [Administración de roles en RBAC](r_roles-managing.md).
# Asignación de roles
Los superusuarios y los usuarios normales con los permisos CREATE ROLE pueden utilizar la instrucción CREATE ROLE para crear roles. Los superusuarios y los administradores de roles pueden utilizar la instrucción GRANT ROLE para conceder un rol a otros usuarios. Pueden utilizar la instrucción REVOKE ROLE para revocar un rol a otros usuarios, y la instrucción DROP ROLE para eliminar roles. Los administradores de roles incluyen a los propietarios de roles y a los usuarios a los que se les ha concedido el rol con el permiso ADMIN OPTION.
Únicamente los superusuarios o administradores de roles pueden conceder y revocar roles. Se pueden conceder o revocar uno o varios roles a uno o varios roles o usuarios. Utilice la opción WITH ADMIN OPTION de la instrucción GRANT ROLE para proporcionar las opciones de administración de todos los roles concedidos a todos los concesionarios.
Amazon Redshift admite diferentes combinaciones de asignaciones de roles, como conceder varios roles o tener varios concesionarios. WITH ADMIN OPTION solo se aplica a los usuarios, no a los roles. De manera similar, utilice la opción WITH ADMIN OPTION en la instrucción REVOKE ROLE para eliminar el rol y la autorización administrativa del concesionario. Cuando se utiliza con ADMIN OPTION, solo se revoca la autorización administrativa al rol.
En el siguiente ejemplo, se revoca la autorización administrativa del rol `sample_role2` a `user2`.
```
REVOKE ADMIN OPTION FOR sample_role2 FROM user2;
```
Para obtener más información sobre cómo crear roles y administrar la asignación de roles, consulte [Administración de roles en RBAC](r_roles-managing.md).
# Roles definidos por el sistema de Amazon Redshift
Amazon Redshift proporciona algunos roles definidos por el sistema que se definen con permisos específicos. Los roles específicos del sistema van precedidos del prefijo `sys:`. Únicamente los usuarios con acceso adecuado pueden modificar los roles definidos por el sistema o crear roles definidos por el sistema personalizados. No se puede utilizar el prefijo `sys:` para un rol definido por el sistema personalizado.
La tabla siguiente resume los roles y sus permisos.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_roles-default.html)
## Roles y usuarios definidos por el sistema para el intercambio de datos
Amazon Redshift crea roles y usuarios para uso interno que corresponden a los recursos compartidos de datos y a sus consumidores. Cada nombre de rol y nombre de usuario internos tienen el prefijo de espacio de nombres reservado `ds:`. Tienen el siguiente formato:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_roles-default.html)
Se crea un rol de intercambio de datos para cada recurso compartido de datos. Contiene todos los permisos concedidos actualmente al recurso compartido de datos. Se crea un usuario de intercambio de datos para cada consumidor de un recurso compartido de datos. Se le concede permiso para un único rol de intercambio de datos. Un consumidor agregado a varios conjuntos de datos tendrá un usuario de intercambio de datos creado para cada recurso compartido de datos.
Estos usuarios y roles son necesarios para que el intercambio de datos funcione correctamente. No se pueden modificar ni eliminar, y no se puede acceder a ellos ni utilizarlos para ninguna tarea que realicen los clientes. Puede ignorarlos de forma segura. Para obtener más información sobre el uso compartido de datos, consulte [Compartir datos entre clústeres en Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/dg/datashare-overview.html).
**nota**
No puede usar el prefijo `ds:` para crear roles o usuarios definidos por el usuario.
# Permisos del sistema para RBAC
A continuación se presenta una lista de permisos del sistema que puede conceder o revocar a un rol.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_roles-system-privileges.html)
# Permisos de objetos de bases de datos
Además de permisos del sistema, Amazon Redshift incluye permisos de objetos de base de datos que definen las opciones de acceso. Entre esas opciones se incluyen la capacidad de leer datos en tablas y vistas, escribir datos, crear tablas y eliminar tablas. Para obtener más información, consulte [GRANT](r_GRANT.md).
Mediante RBAC, se pueden asignar permisos de objetos de base de datos a roles, de manera similar a como se puede hacer con los permisos del sistema. Después, se pueden asignar roles a los usuarios, autorizar a los usuarios con permisos del sistema, y autorizar a los usuarios con permisos de base de datos.
# ALTER DEFAULT PRIVILEGES para RBAC
Utilice la instrucción ALTER DEFAULT PRIVILEGES para definir el conjunto predeterminado de permisos de acceso que se deben aplicar a los objetos que el usuario especificado cree en el futuro. De manera predeterminada, los usuarios pueden cambiar solo sus propios permisos de acceso predeterminados. Con RBAC, se pueden establecer los permisos de acceso predeterminados para los roles. Para obtener más información, consulte el comando [ALTER DEFAULT PRIVILEGES](r_ALTER_DEFAULT_PRIVILEGES.md).
RBAC permite asignar permisos de objetos de base de datos a los roles, de manera similar a los permisos del sistema. Después, se pueden asignar roles a los usuarios, y autorizar a los usuarios con permisos del sistema o de base de datos.
# Consideraciones sobre el uso de roles en RBAC
Cuando trabaje con roles de RBAC, tenga presente lo siguiente:
+ Amazon Redshift no permite ciclos de autorizaciones de roles. No se puede conceder r1 a r2 y luego conceder r2 a r1.
+ RBAC funciona tanto para objetos nativos de Amazon Redshift como para tablas de Amazon Redshift Spectrum.
+ Como administrador de Amazon Redshift, puede activar RBAC actualizando el clúster al último parche de mantenimiento para comenzar.
+ Únicamente los superusuarios y los usuarios con el permiso del sistema CREATE ROLE pueden crear roles.
+ Únicamente los superusuarios y administradores de roles pueden modificar o eliminar roles.
+ El nombre de un rol no puede ser el mismo que el nombre de un usuario.
+ El nombre de un rol no puede contener caracteres no válidos, como “:/\$1n.”.
+ El nombre de un rol no puede ser una palabra reservada, como PUBLIC.
+ El nombre del rol no puede comenzar con el prefijo reservado para los roles predeterminados, `sys:`.
+ No se puede eliminar un rol que tenga el parámetro RESTRICT cuando está concedido a otro rol. La configuración predeterminada es RESTRICT. Amazon Redshift genera un error cuando se intenta eliminar un rol que ha heredado otro rol.
+ Los usuarios que no tengan permisos de administración para un rol no pueden conceder ni revocar un rol.
+ RBAC no es totalmente compatible con tablas y vistas del sistema. Los permisos de RBAC para las tablas y vistas del sistema no se conservan durante las actualizaciones, las degradaciones o los cambios de tamaño. Recomendamos utilizar [Roles definidos por el sistema de Amazon RedshiftRoles y usuarios definidos por el sistema para el intercambio de datos](r_roles-default.md) para administrar los permisos de tablas y vistas del sistema. Para obtener más información sobre las tablas del sistema, vaya a [Referencia de las tablas y vistas de sistema](cm_chap_system-tables.md).
# Administración de roles en RBAC
Para realizar las siguientes acciones, utilice estos comandos:
+ Para crear un rol, utilice el comando [CREATE ROLE](r_CREATE_ROLE.md).
+ Para cambiar el nombre de un rol o el propietario del rol, utilice el comando [ALTER ROLE](r_ALTER_ROLE.md).
+ Para eliminar un rol, utilice el comando [DROP ROLE](r_DROP_ROLE.md).
+ Para conceder un rol a un usuario, utilice el comando [GRANT](r_GRANT.md).
+ Para revocar un rol a un usuario, utilice el comando [REVOKE](r_REVOKE.md).
+ Para conceder permisos del sistema a un rol, utilice el comando [GRANT](r_GRANT.md).
+ Para revocar permisos del sistema a un rol, utilice el comando [REVOKE](r_REVOKE.md).
Para ver una lista de los roles de su clúster o grupo de trabajo, consulte [SVV\$1ROLES](r_SVV_ROLES.md).
# Tutorial: creación de roles y realización de consultas con RBAC
Con RBAC, puede crear roles con permisos para ejecutar comandos que antes necesitaban permisos de superusuario. Los usuarios pueden ejecutar estos comandos, siempre que hayan recibido autorización con un rol que incluya tales permisos.
En este tutorial, utilizará el control de acceso basado en roles (RBAC) para administrar los permisos en una base de datos que ha creado. A continuación, se conectará a la base de datos y la consultará desde dos roles diferentes para probar la funcionalidad de RBAC.
Los dos roles que se crean y utilizan para consultar la base de datos son `sales_ro` y `sales_rw`. Cree el rol `sales_ro` y consulte los datos como usuario con el rol `sales_ro`. El usuario `sales_ro` solo puede usar el comando SELECT y no puede usar el comando UPDATE. A continuación, cree el rol `sales_rw` y consulte los datos como usuario con el rol `sales_rw`. El usuario `sales_rw` puede usar el comando SELECT y el comando UPDATE.
Además, puede crear roles para limitar el acceso a determinados comandos y asignar el rol a superusuarios o a usuarios.
**Tareas**
+ [Requisitos previos](#tutorial-rbac-prereqs)
+ [Paso 1: cree un usuario administrador](#tutorial-rbac-step1)
+ [Paso 2: configure los esquemas](#tutorial-rbac-step2)
+ [Paso 3: cree un usuario de solo lectura.](#tutorial-rbac-step3)
+ [Paso 4: consulte los datos como usuario de solo lectura](#tutorial-rbac-step4)
+ [Paso 5: cree un usuario de solo escritura](#tutorial-rbac-step5)
+ [Paso 6: consulte los datos como el usuario con el rol heredado de solo lectura](#tutorial-rbac-step6)
+ [Paso 7: conceda permisos de actualización e inserción al rol de lectura/escritura](#tutorial-rbac-step7)
+ [Paso 8: consulte los datos como usuario de lectura/escritura](#tutorial-rbac-step8)
+ [Paso 9: analice y vacíe las tablas de una base de datos como usuario administrador](#tutorial-rbac-step9)
+ [Paso 10: trunque las tablas como usuario de lectura/escritura](#tutorial-rbac-step10)
+ [Funciones del sistema para RBAC (opcional)](#tutorial-rbac-system-functions)
+ [Vistas del sistema para RBAC (opcional)](#tutorial-rbac-system-views)
+ [Uso de seguridad a nivel de fila con RBAC (opcional)](#tutorial-rbac-rls)
## Requisitos previos
+ Cree un clúster de Amazon Redshift o un grupo de trabajo sin servidor que se cargue con la base de datos de ejemplo TICKIT. Para crear un grupo de trabajo sin servidor, consulte [Introducción a los almacenamientos de datos de Redshift sin servidor](https://docs.aws.amazon.com/redshift/latest/gsg/new-user-serverless.html). Para crear un clúster, consulte [Crear un clúster de Amazon Redshift de muestra](https://docs.aws.amazon.com/redshift/latest/gsg/rs-gsg-launch-sample-cluster.html). Para obtener más información acerca de la base de datos de ejemplo TICKIT, consulte [Base de datos de muestra](c_sampledb.md).
+ Tenga acceso a un usuario con permisos de superusuario o administrador de roles. Únicamente los superusuarios o administradores de roles pueden conceder o revocar roles. Para obtener más información acerca de los permisos requeridos para RBAC, consulte [Permisos del sistema para RBAC](r_roles-system-privileges.md).
+ Consulte el [Consideraciones sobre el uso de roles en RBAC](r_role-usage-notes.md).
## Paso 1: cree un usuario administrador
Para prepararse para este tutorial, cree un rol de administrador de base de datos y asígnelo a un usuario administrador de bases de datos en este paso. Debe crear el administrador de la base de datos como superusuario o administrador de roles.
Ejecute todas las consultas en el [editor de consultas v2 de Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2-using.html).
1. Para crear el rol de administrador db\$1admin, utilice el siguiente ejemplo.
```
CREATE ROLE db_admin;
```
1. Para crear un usuario de base de datos llamado dbadmin, utilice el siguiente ejemplo.
```
CREATE USER dbadmin PASSWORD 'Test12345';
```
1. Para conceder el rol definido por el sistema denominado sys:dba al rol db\$1admin, utilice el siguiente ejemplo. Cuando se le concede el rol sys:dba, el usuario dbadmin puede crear esquemas y tablas. Para obtener más información, consulte [Roles definidos por el sistema de Amazon RedshiftRoles y usuarios definidos por el sistema para el intercambio de datos](r_roles-default.md).
## Paso 2: configure los esquemas
En este paso, se conecta a la base de datos como administrador de bases de datos. A continuación, cree dos esquemas y agregue datos en ellos.
1. Conéctese a la base de datos dev como usuario dbadmin utilizando el editor de consultas v2. Para obtener más información sobre la conexión a una base de datos, consulte [Trabajo con el editor de consultas v2](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2-using.html).
1. Para crear los esquemas de las bases de datos de ventas y marketing, utilice el siguiente ejemplo.
```
CREATE SCHEMA sales;
CREATE SCHEMA marketing;
```
1. Para crear e insertar valores en las tablas del esquema de ventas, utilice el siguiente ejemplo.
```
CREATE TABLE sales.cat(
catid smallint,
catgroup varchar(10),
catname varchar(10),
catdesc varchar(50)
);
INSERT INTO sales.cat(SELECT * FROM category);
CREATE TABLE sales.dates(
dateid smallint,
caldate date,
day char(3),
week smallint,
month char(5),
qtr char(5),
year smallint,
holiday boolean
);
INSERT INTO sales.dates(SELECT * FROM date);
CREATE TABLE sales.events(
eventid integer,
venueid smallint,
catid smallint,
dateid smallint,
eventname varchar(200),
starttime timestamp
);
INSERT INTO sales.events(SELECT * FROM event);
CREATE TABLE sales.sale(
salesid integer,
listid integer,
sellerid integer,
buyerid integer,
eventid integer,
dateid smallint,
qtysold smallint,
pricepaid decimal(8,2),
commission decimal(8,2),
saletime timestamp
);
INSERT INTO sales.sale(SELECT * FROM sales);
```
1. Para crear e insertar valores en las tablas del esquema de marketing, utilice el siguiente ejemplo.
```
CREATE TABLE marketing.cat(
catid smallint,
catgroup varchar(10),
catname varchar(10),
catdesc varchar(50)
);
INSERT INTO marketing.cat(SELECT * FROM category);
CREATE TABLE marketing.dates(
dateid smallint,
caldate date,
day char(3),
week smallint,
month char(5),
qtr char(5),
year smallint,
holiday boolean
);
INSERT INTO marketing.dates(SELECT * FROM date);
CREATE TABLE marketing.events(
eventid integer,
venueid smallint,
catid smallint,
dateid smallint,
eventname varchar(200),
starttime timestamp
);
INSERT INTO marketing.events(SELECT * FROM event);
CREATE TABLE marketing.sale(
marketingid integer,
listid integer,
sellerid integer,
buyerid integer,
eventid integer,
dateid smallint,
qtysold smallint,
pricepaid decimal(8,2),
commission decimal(8,2),
saletime timestamp
);
INSERT INTO marketing.sale(SELECT * FROM marketing);
```
## Paso 3: cree un usuario de solo lectura.
En este paso, creará un rol de solo lectura y un usuario salesanalyst para el rol de solo lectura. El analista de ventas solo necesita acceso de solo lectura a las tablas del esquema de ventas para llevar a cabo la tarea que se le ha asignado de encontrar los eventos que generaron las mayores comisiones.
1. Conéctese a la base de datos como usuario dbadmin.
1. Para crear el rol sales\$1ro, utilice el siguiente ejemplo.
```
CREATE ROLE sales_ro;
```
1. Para crear el usuario salesanalyst, utilice el siguiente ejemplo.
```
CREATE USER salesanalyst PASSWORD 'Test12345';
```
1. Para conceder el uso del rol sales\$1ro y seleccionar el acceso a los objetos del esquema de ventas, utilice el siguiente ejemplo.
```
GRANT USAGE ON SCHEMA sales TO ROLE sales_ro;
GRANT SELECT ON ALL TABLES IN SCHEMA sales TO ROLE sales_ro;
```
1. Para conceder al usuario salesanalyst el rol sales\$1ro, utilice el siguiente ejemplo.
```
GRANT ROLE sales_ro TO salesanalyst;
```
## Paso 4: consulte los datos como usuario de solo lectura
En este paso, el usuario salesanalyst consulta los datos del esquema de ventas. A continuación, el usuario salesanalyst intenta actualizar una tabla y leer las tablas del esquema de marketing.
1. Conéctese a la base de datos como usuario salesanalyst.
1. Para encontrar las diez ventas con las comisiones más altas, utilice el siguiente ejemplo.
```
SET SEARCH_PATH TO sales;
SELECT DISTINCT events.dateid, sale.commission, cat.catname
FROM sale, events, dates, cat
WHERE events.dateid=dates.dateid AND events.dateid=sale.dateid AND events.catid = cat.catid
ORDER BY 2 DESC LIMIT 10;
+--------+------------+----------+
| dateid | commission | catname |
+--------+------------+----------+
| 1880 | 1893.6 | Pop |
| 1880 | 1893.6 | Opera |
| 1880 | 1893.6 | Plays |
| 1880 | 1893.6 | Musicals |
| 1861 | 1500 | Plays |
| 2003 | 1500 | Pop |
| 1861 | 1500 | Opera |
| 2003 | 1500 | Plays |
| 1861 | 1500 | Musicals |
| 1861 | 1500 | Pop |
+--------+------------+----------+
```
1. Para seleccionar diez eventos de la tabla de eventos del esquema de ventas, utilice el siguiente ejemplo.
```
SELECT * FROM sales.events LIMIT 10;
+---------+---------+-------+--------+--------------------+---------------------+
| eventid | venueid | catid | dateid | eventname | starttime |
+---------+---------+-------+--------+--------------------+---------------------+
| 4836 | 73 | 9 | 1871 | Soulfest | 2008-02-14 19:30:00 |
| 5739 | 41 | 9 | 1871 | Fab Faux | 2008-02-14 19:30:00 |
| 627 | 229 | 6 | 1872 | High Society | 2008-02-15 14:00:00 |
| 2563 | 246 | 7 | 1872 | Hamlet | 2008-02-15 20:00:00 |
| 7703 | 78 | 9 | 1872 | Feist | 2008-02-15 14:00:00 |
| 7903 | 90 | 9 | 1872 | Little Big Town | 2008-02-15 19:30:00 |
| 7925 | 101 | 9 | 1872 | Spoon | 2008-02-15 19:00:00 |
| 8113 | 17 | 9 | 1872 | Santana | 2008-02-15 15:00:00 |
| 463 | 303 | 8 | 1873 | Tristan und Isolde | 2008-02-16 19:00:00 |
| 613 | 236 | 6 | 1873 | Pal Joey | 2008-02-16 15:00:00 |
+---------+---------+-------+--------+--------------------+---------------------+
```
1. Para intentar actualizar el nombre del evento para el eventid 1, ejecute el siguiente ejemplo. Este ejemplo generará un error de permiso denegado porque el usuario salesanalyst solo tiene permisos SELECT en la tabla de eventos del esquema de ventas. Para actualizar la tabla de eventos, debe conceder al rol sales\$1ro permisos UPDATE. Para obtener más información sobre la concesión de permisos para actualizar una tabla, consulte el parámetro UPDATE para [GRANT](r_GRANT.md). Para obtener más información sobre el comando UPDATE, consulte [UPDATE](r_UPDATE.md).
```
UPDATE sales.events
SET eventname = 'Comment event'
WHERE eventid = 1;
ERROR: permission denied for relation events
```
1. Para intentar seleccionarlos todos en la tabla de eventos del esquema de marketing, use el siguiente ejemplo. Este ejemplo generará un error de permiso denegado porque el usuario salesanalyst solo tiene permisos SELECT en la tabla de eventos del esquema de ventas. Para seleccionar datos de la tabla de eventos del esquema de marketing, debe conceder al rol sales\$1ro permisos SELECT en la tabla de eventos del esquema de marketing.
```
SELECT * FROM marketing.events;
ERROR: permission denied for schema marketing
```
## Paso 5: cree un usuario de solo escritura
En este paso, el ingeniero de ventas responsable de crear la canalización de extracción, transformación y carga (ETL) para el procesamiento de datos en el esquema de ventas tendrá acceso de solo lectura, pero más adelante se le dará acceso de lectura y escritura para realizar sus tareas.
1. Conéctese a la base de datos como usuario dbadmin.
1. Para crear el rol sales\$1rw en el esquema de ventas, utilice el siguiente ejemplo.
```
CREATE ROLE sales_rw;
```
1. Para crear el usuario salesengineer, utilice el siguiente ejemplo.
```
CREATE USER salesengineer PASSWORD 'Test12345';
```
1. Para conceder al rol sales\$1rw acceso de uso y selección de los objetos del esquema de ventas asignándole el rol sales\$1ro, utilice el siguiente ejemplo. Para obtener más información sobre cómo los roles heredan los permisos en Amazon Redshift, consulte [Jerarquía de roles](t_role_hierarchy.md).
```
GRANT ROLE sales_ro TO ROLE sales_rw;
```
1. Para asignar el rol sales\$1rw al usuario salesengineer, utilice el siguiente ejemplo.
```
GRANT ROLE sales_rw TO salesengineer;
```
## Paso 6: consulte los datos como el usuario con el rol heredado de solo lectura
En este paso, el usuario salesengineer intenta actualizar la tabla de eventos antes de que se le concedan los permisos de lectura.
1. Conéctese a la base de datos como usuario salesengineer.
1. El usuario salesengineer puede leer correctamente los datos de la tabla de eventos del esquema de ventas. Para seleccionar el evento con eventid 1 de la tabla de eventos del esquema de ventas, utilice el siguiente ejemplo.
```
SELECT * FROM sales.events where eventid=1;
+---------+---------+-------+--------+-----------------+---------------------+
| eventid | venueid | catid | dateid | eventname | starttime |
+---------+---------+-------+--------+-----------------+---------------------+
| 1 | 305 | 8 | 1851 | Gotterdammerung | 2008-01-25 14:30:00 |
+---------+---------+-------+--------+-----------------+---------------------+
```
1. Para intentar seleccionarlos todos en la tabla de eventos del esquema de marketing, use el siguiente ejemplo. El usuario salesengineer no tiene permisos para las tablas del esquema de marketing, por lo que esta consulta generará un error de permiso denegado. Para seleccionar datos de la tabla de eventos del esquema de marketing, debe conceder al rol sales\$1rw permisos SELECT en la tabla de eventos del esquema de marketing.
```
SELECT * FROM marketing.events;
ERROR: permission denied for schema marketing
```
1. Para intentar actualizar el nombre del evento para el eventid 1, ejecute el siguiente ejemplo. Este ejemplo generará un error de permiso denegado porque el usuario salesengineer solo tiene permisos de selección en la tabla de eventos del esquema de ventas. Para actualizar la tabla de eventos, debe conceder al rol sales\$1rw permisos UPDATE.
```
UPDATE sales.events
SET eventname = 'Comment event'
WHERE eventid = 1;
ERROR: permission denied for relation events
```
## Paso 7: conceda permisos de actualización e inserción al rol de lectura/escritura
En este paso, se conceden permisos de actualización e inserción al rol sales\$1rw.
1. Conéctese a la base de datos como usuario dbadmin.
1. Para conceder los permisos UPDATE, INSERT y DELETE al rol sales\$1rw, utilice el siguiente ejemplo.
```
GRANT UPDATE, INSERT, ON ALL TABLES IN SCHEMA sales TO role sales_rw;
```
## Paso 8: consulte los datos como usuario de lectura/escritura
En este paso, salesengineer actualiza correctamente la tabla después de que a su rol se le concedan los permisos de inserción y actualización. A continuación, salesengineer intenta analizar y vaciar la tabla de eventos, pero no lo consigue.
1. Conéctese a la base de datos como usuario salesengineer.
1. Para actualizar el nombre del evento para el eventid 1, ejecute el siguiente ejemplo.
```
UPDATE sales.events
SET eventname = 'Comment event'
WHERE eventid = 1;
```
1. Para ver el cambio realizado en la consulta anterior, utilice el siguiente ejemplo para seleccionar el evento con eventid 1 en la tabla de eventos del esquema de ventas.
```
SELECT * FROM sales.events WHERE eventid=1;
+---------+---------+-------+--------+---------------+---------------------+
| eventid | venueid | catid | dateid | eventname | starttime |
+---------+---------+-------+--------+---------------+---------------------+
| 1 | 305 | 8 | 1851 | Comment event | 2008-01-25 14:30:00 |
+---------+---------+-------+--------+---------------+---------------------+
```
1. Para analizar la tabla de eventos actualizada en el esquema de ventas, utilice el siguiente ejemplo. Este ejemplo generará un error de permiso denegado porque el usuario salesengineer no tiene los permisos necesarios y no es el propietario de la tabla de eventos del esquema de ventas. Para analizar la tabla de eventos, debe conceder al rol sales\$1rw permisos ANALYZE mediante el comando GRANT. Para obtener más información acerca del comando ANALYZE, consulte [ANALYZE](r_ANALYZE.md).
```
ANALYZE sales.events;
ERROR: skipping "events" --- only table or database owner can analyze
```
1. Para vaciar la tabla de eventos actualizada, utilice el siguiente ejemplo. Este ejemplo generará un error de permiso denegado porque el usuario salesengineer no tiene los permisos necesarios y no es el propietario de la tabla de eventos del esquema de ventas. Para vaciar la tabla de eventos, debe conceder permisos VACUUM al rol sales\$1rw mediante el comando GRANT. Para obtener más información acerca del comando VACUUM, consulte [VACUUM](r_VACUUM_command.md).
```
VACUUM sales.events;
ERROR: skipping "events" --- only table or database owner can vacuum it
```
## Paso 9: analice y vacíe las tablas de una base de datos como usuario administrador
En este paso, el usuario dbadmin analiza y vacía todas las tablas. El usuario tiene permisos de administrador en esta base de datos, por lo que puede ejecutar estos comandos.
1. Conéctese a la base de datos como usuario dbadmin.
1. Para analizar la tabla de eventos en el esquema de ventas, utilice el siguiente ejemplo.
```
ANALYZE sales.events;
```
1. Para vaciar la tabla de eventos en el esquema de ventas, utilice el siguiente ejemplo.
```
VACUUM sales.events;
```
1. Para analizar la tabla de eventos en el esquema de marketing, utilice el siguiente ejemplo.
```
ANALYZE marketing.events;
```
1. Para vaciar la tabla de eventos en el esquema de marketing, utilice el siguiente ejemplo.
```
VACUUM marketing.events;
```
## Paso 10: trunque las tablas como usuario de lectura/escritura
En este paso, el usuario salesengineer intenta truncar la tabla de eventos en el esquema de ventas, pero solo lo consigue cuando el usuario dbadmin le concede los permisos de truncamiento.
1. Conéctese a la base de datos como usuario salesengineer.
1. Para intentar eliminar todas las filas de la tabla de eventos del esquema de ventas, utilice el siguiente ejemplo. Este ejemplo generará un error porque el usuario salesengineer no tiene los permisos necesarios y no es el propietario de la tabla de eventos del esquema de ventas. Para truncar la tabla de eventos, debe conceder al rol sales\$1rw permisos TRUNCATE mediante el comando GRANT. Para obtener más información sobre el comando TRUNCATE, consulte [TRUNCATE](r_TRUNCATE.md).
```
TRUNCATE sales.events;
ERROR: must be owner of relation events
```
1. Conéctese a la base de datos como usuario dbadmin.
1. Para conceder privilegios de truncado de tablas al rol sales\$1rw, utilice el siguiente ejemplo.
```
GRANT TRUNCATE TABLE TO role sales_rw;
```
1. Conéctese a la base de datos como usuario salesengineer utilizando el editor de consultas v2.
1. Para leer los primeros diez eventos de la tabla de eventos del esquema de ventas, utilice el siguiente ejemplo.
```
SELECT * FROM sales.events ORDER BY eventid LIMIT 10;
+---------+---------+-------+--------+-----------------------------+---------------------+
| eventid | venueid | catid | dateid | eventname | starttime |
+---------+---------+-------+--------+-----------------------------+---------------------+
| 1 | 305 | 8 | 1851 | Comment event | 2008-01-25 14:30:00 |
| 2 | 306 | 8 | 2114 | Boris Godunov | 2008-10-15 20:00:00 |
| 3 | 302 | 8 | 1935 | Salome | 2008-04-19 14:30:00 |
| 4 | 309 | 8 | 2090 | La Cenerentola (Cinderella) | 2008-09-21 14:30:00 |
| 5 | 302 | 8 | 1982 | Il Trovatore | 2008-06-05 19:00:00 |
| 6 | 308 | 8 | 2109 | L Elisir d Amore | 2008-10-10 19:30:00 |
| 7 | 309 | 8 | 1891 | Doctor Atomic | 2008-03-06 14:00:00 |
| 8 | 302 | 8 | 1832 | The Magic Flute | 2008-01-06 20:00:00 |
| 9 | 308 | 8 | 2087 | The Fly | 2008-09-18 19:30:00 |
| 10 | 305 | 8 | 2079 | Rigoletto | 2008-09-10 15:00:00 |
+---------+---------+-------+--------+-----------------------------+---------------------+
```
1. Para truncar la tabla de eventos en el esquema de ventas, utilice el siguiente ejemplo.
```
TRUNCATE sales.events;
```
1. Para leer los datos de la tabla de eventos del esquema de ventas, utilice el siguiente ejemplo.
```
SELECT * FROM sales.events ORDER BY eventid LIMIT 10;
+---------+---------+-------+--------+-----------------------------+---------------------+
| eventid | venueid | catid | dateid | eventname | starttime |
+---------+---------+-------+--------+-----------------------------+---------------------+
```
### Creación de roles de solo lectura y de lectura/escritura para el esquema de marketing (opcional)
En este paso, se crean roles de solo lectura y de lectura/escritura para el esquema de marketing.
1. Conéctese a la base de datos como usuario dbadmin.
1. Para crear roles de solo lectura y lectura/escritura para el esquema de marketing, utilice el siguiente ejemplo.
```
CREATE ROLE marketing_ro;
CREATE ROLE marketing_rw;
GRANT USAGE ON SCHEMA marketing TO ROLE marketing_ro, ROLE marketing_rw;
GRANT SELECT ON ALL TABLES IN SCHEMA marketing TO ROLE marketing_ro;
GRANT ROLE marketing_ro TO ROLE marketing_rw;
GRANT INSERT, UPDATE, DELETE ON ALL TABLES IN SCHEMA marketing TO ROLE marketing_rw;
CREATE USER marketinganalyst PASSWORD 'Test12345';
CREATE USER marketingengineer PASSWORD 'Test12345';
GRANT ROLE marketing_ro TO marketinganalyst;
GRANT ROLE marketing_rw TO marketingengineer;
```
## Funciones del sistema para RBAC (opcional)
Amazon Redshift tiene dos funciones para proporcionar información del sistema sobre la pertenencia de los usuarios y la pertenencia de los roles a grupos o roles adicionales: role\$1is\$1member\$1of y user\$1is\$1member\$1of. Estas funciones están disponibles para los superusuarios y los usuarios normales. Los superusuarios pueden comprobar todas las pertenencias de los roles. Los usuarios normales solo pueden comprobar la pertenencia de los roles a los que se les han concedido acceso.
Para usar la función role\$1is\$1member\$1of
1. Conéctese a la base de datos como usuario salesengineer.
1. Para comprobar si el rol sales\$1rw es miembro del rol sales\$1ro, utilice el siguiente ejemplo.
```
SELECT role_is_member_of('sales_rw', 'sales_ro');
+-------------------+
| role_is_member_of |
+-------------------+
| true |
+-------------------+
```
1. Para comprobar si el rol sales\$1ro es miembro del rol sales\$1rw, utilice el siguiente ejemplo.
```
SELECT role_is_member_of('sales_ro', 'sales_rw');
+-------------------+
| role_is_member_of |
+-------------------+
| false |
+-------------------+
```
Para usar la función user\$1is\$1member\$1of
1. Conéctese a la base de datos como usuario salesengineer.
1. En el siguiente ejemplo, se intenta comprobar la pertenencia del usuario salesanalyst. Esta consulta produce un error porque salesengineer no tiene acceso a salesanalyst. Para ejecutar este comando correctamente, conéctese a la base de datos como usuario salesanalyst y utilice el ejemplo.
```
SELECT user_is_member_of('salesanalyst', 'sales_ro');
ERROR
```
1. Conéctese a la base de datos como superusuario.
1. Para comprobar la pertenencia del usuario salesanalyst cuando está conectado como superusuario, utilice el siguiente ejemplo.
```
SELECT user_is_member_of('salesanalyst', 'sales_ro');
+-------------------+
| user_is_member_of |
+-------------------+
| true |
+-------------------+
```
1. Conéctese a la base de datos como usuario dbadmin.
1. Para comprobar la pertenencia del usuario salesengineer, utilice el siguiente ejemplo.
```
SELECT user_is_member_of('salesengineer', 'sales_ro');
+-------------------+
| user_is_member_of |
+-------------------+
| true |
+-------------------+
SELECT user_is_member_of('salesengineer', 'marketing_ro');
+-------------------+
| user_is_member_of |
+-------------------+
| false |
+-------------------+
SELECT user_is_member_of('marketinganalyst', 'sales_ro');
+-------------------+
| user_is_member_of |
+-------------------+
| false |
+-------------------+
```
## Vistas del sistema para RBAC (opcional)
Para ver los roles, la asignación de roles a los usuarios, la jerarquía de roles y los privilegios de los objetos de la base de datos a través de los roles, utilice las vistas del sistema de Amazon Redshift. Estas vistas están disponibles para los superusuarios y los usuarios normales. Los superusuarios pueden comprobar todos los detalles de los roles. Los usuarios normales solo pueden comprobar los detalles de los roles a los que se les ha concedido acceso.
1. Para ver una lista de los usuarios a los que se han concedido explícitamente roles en el clúster, utilice el siguiente ejemplo.
```
SELECT * FROM svv_user_grants;
```
1. Para ver una lista de los roles a los que se han concedido explícitamente roles en el clúster, utilice el siguiente ejemplo.
```
SELECT * FROM svv_role_grants;
```
Para ver la lista completa de vistas del sistema, consulte [Vistas de metadatos SVV](svv_views.md).
## Uso de seguridad a nivel de fila con RBAC (opcional)
Para tener un control de acceso detallado de los datos sensibles, utilice la seguridad a nivel de fila (RLS). Para obtener más información sobre RLS, consulte [Seguridad de nivel básico](t_rls.md).
En esta sección, creará una política RLS que otorga al usuario `salesengineer` permisos para ver solo las filas de la tabla `cat` que tienen el valor `catdesc` de Major League Baseball. A continuación, consulte la base de datos como usuario `salesengineer`.
1. Conéctese a la base de datos como usuario `salesengineer`.
1. Para ver las cinco primeras entradas de la tabla `cat`, utilice el siguiente ejemplo.
```
SELECT *
FROM sales.cat
ORDER BY catid ASC
LIMIT 5;
+-------+----------+---------+---------------------------------+
| catid | catgroup | catname | catdesc |
+-------+----------+---------+---------------------------------+
| 1 | Sports | MLB | Major League Baseball |
| 2 | Sports | NHL | National Hockey League |
| 3 | Sports | NFL | National Football League |
| 4 | Sports | NBA | National Basketball Association |
| 5 | Sports | MLS | Major League Soccer |
+-------+----------+---------+---------------------------------+
```
1. Conéctese a la base de datos como usuario `dbadmin`.
1. Para crear una política de RLS para la columna `catdesc` de la tabla `cat`, utilice el siguiente ejemplo.
```
CREATE RLS POLICY policy_mlb_engineer
WITH (catdesc VARCHAR(50))
USING (catdesc = 'Major League Baseball');
```
1. Para asociar la política de RLS al rol de `sales_rw`, utilice el siguiente ejemplo.
```
ATTACH RLS POLICY policy_mlb_engineer ON sales.cat TO ROLE sales_rw;
```
1. Para modificar la tabla y activar RLS, utilice el siguiente ejemplo.
```
ALTER TABLE sales.cat ROW LEVEL SECURITY ON;
```
1. Conéctese a la base de datos como usuario `salesengineer`.
1. Para intentar ver las cinco primeras entradas de la tabla `cat`, utilice el siguiente ejemplo. Tenga en cuenta que las entradas solo aparecen cuando la columna `catdesc` es `Major League Baseball`.
```
SELECT *
FROM sales.cat
ORDER BY catid ASC
LIMIT 5;
+-------+----------+---------+-----------------------+
| catid | catgroup | catname | catdesc |
+-------+----------+---------+-----------------------+
| 1 | Sports | MLB | Major League Baseball |
+-------+----------+---------+-----------------------+
```
1. Conéctese a la base de datos como usuario `salesanalyst`.
1. Para intentar ver las cinco primeras entradas de la tabla `cat`, utilice el siguiente ejemplo. Tenga en cuenta que no aparece ninguna entrada porque se aplica la política predeterminada de denegación total.
```
SELECT *
FROM sales.cat
ORDER BY catid ASC
LIMIT 5;
+-------+----------+---------+-----------------------+
| catid | catgroup | catname | catdesc |
+-------+----------+---------+-----------------------+
```
1. Conéctese a la base de datos como usuario `dbadmin`.
1. Para conceder el permiso IGNORE de RLS al rol `sales_ro`, utilice el siguiente ejemplo. Aquí se conceden al usuario `salesanalyst` los permisos para ignorar las políticas de RLS, ya que es miembro del rol `sales_ro`.
```
GRANT IGNORE RLS TO ROLE sales_ro;
```
1. Conéctese a la base de datos como usuario `salesanalyst`.
1. Para ver las cinco primeras entradas de la tabla `cat`, utilice el siguiente ejemplo.
```
SELECT *
FROM sales.cat
ORDER BY catid ASC
LIMIT 5;
+-------+----------+---------+---------------------------------+
| catid | catgroup | catname | catdesc |
+-------+----------+---------+---------------------------------+
| 1 | Sports | MLB | Major League Baseball |
| 2 | Sports | NHL | National Hockey League |
| 3 | Sports | NFL | National Football League |
| 4 | Sports | NBA | National Basketball Association |
| 5 | Sports | MLS | Major League Soccer |
+-------+----------+---------+---------------------------------+
```
1. Conéctese a la base de datos como usuario `dbadmin`.
1. Para revocar el permiso IGNORE de RLS del rol `sales_ro`, utilice el siguiente ejemplo.
```
REVOKE IGNORE RLS FROM ROLE sales_ro;
```
1. Conéctese a la base de datos como usuario `salesanalyst`.
1. Para intentar ver las cinco primeras entradas de la tabla `cat`, utilice el siguiente ejemplo. Tenga en cuenta que no aparece ninguna entrada porque se aplica la política predeterminada de denegación total.
```
SELECT *
FROM sales.cat
ORDER BY catid ASC
LIMIT 5;
+-------+----------+---------+-----------------------+
| catid | catgroup | catname | catdesc |
+-------+----------+---------+-----------------------+
```
1. Conéctese a la base de datos como usuario `dbadmin`.
1. Para desconectar la política de RLS de la tabla `cat`, utilice el siguiente ejemplo.
```
DETACH RLS POLICY policy_mlb_engineer ON cat FROM ROLE sales_rw;
```
1. Conéctese a la base de datos como usuario `salesanalyst`.
1. Para intentar ver las cinco primeras entradas de la tabla `cat`, utilice el siguiente ejemplo. Tenga en cuenta que no aparece ninguna entrada porque se aplica la política predeterminada de denegación total.
```
SELECT *
FROM sales.cat
ORDER BY catid ASC
LIMIT 5;
+-------+----------+---------+---------------------------------+
| catid | catgroup | catname | catdesc |
+-------+----------+---------+---------------------------------+
| 1 | Sports | MLB | Major League Baseball |
| 2 | Sports | NHL | National Hockey League |
| 3 | Sports | NFL | National Football League |
| 4 | Sports | NBA | National Basketball Association |
| 5 | Sports | MLS | Major League Soccer |
+-------+----------+---------+---------------------------------+
```
1. Conéctese a la base de datos como usuario `dbadmin`.
1. Para eliminar la política de RLS, utilice el siguiente ejemplo.
```
DROP RLS POLICY policy_mlb_engineer;
```
1. Para eliminar RLS, utilice el siguiente ejemplo.
```
ALTER TABLE cat ROW LEVEL SECURITY OFF;
```
## Temas relacionados
Para obtener más información sobre RBAC, consulte la siguiente documentación:
+ [Jerarquía de roles](t_role_hierarchy.md)
+ [Asignación de roles](t_role_assignment.md)
+ [Permisos de objetos de bases de datos](r_roles-database-privileges.md)
+ [ALTER DEFAULT PRIVILEGES para RBAC](r_roles-alter-default-privileges.md)