> ## Documentation Index
> Fetch the complete documentation index at: https://clickhouse.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Consultas habituales sobre gestión de acceso

> Este artículo explica los conceptos básicos para definir usuarios y roles de SQL, y aplicar esos privilegios y permisos a bases de datos, tablas, filas y columnas.

<Tip>
  **Autogestionado**

  Si trabaja con ClickHouse autogestionado, consulte [usuarios y roles de SQL](/docs/es/concepts/features/security/access-rights).
</Tip>

Este artículo presenta los conceptos básicos para definir usuarios y roles de SQL, y para aplicar esos privilegios y permisos a bases de datos, tablas, filas y columnas.

<div id="admin-user">
  ## Usuario Admin
</div>

Los servicios de ClickHouse Cloud tienen un usuario Admin, `default`, que se crea al crear el servicio. La contraseña se proporciona durante la creación del servicio y los usuarios de ClickHouse Cloud que tienen el rol **Admin** pueden restablecerla.

Cuando agregue usuarios SQL adicionales a su servicio de ClickHouse Cloud, necesitarán un `username` y una `password` de SQL. Si desea que tengan privilegios de nivel administrativo, asigne a los nuevos usuarios el rol `default_role`. Por ejemplo, para agregar el usuario `clickhouse_admin`:

```sql theme={null}
CREATE USER IF NOT EXISTS clickhouse_admin
IDENTIFIED WITH sha256_password BY 'P!@ssword42!';
```

```sql theme={null}
GRANT default_role TO clickhouse_admin;
```

<Note>
  Al usar la consola SQL, tus sentencias SQL no se ejecutarán con el usuario `default`. En su lugar, se ejecutarán con un usuario llamado `sql-console:${cloud_login_email}`, donde `cloud_login_email` es el correo electrónico del usuario que está ejecutando la consulta en ese momento.

  Estos usuarios de consola SQL generados automáticamente tienen el rol `default`.
</Note>

<div id="passwordless-authentication">
  ## Autenticación sin contraseña
</div>

Hay dos roles disponibles para la consola SQL: `sql_console_admin`, con permisos idénticos a `default_role`, y `sql_console_read_only`, con permisos de solo lectura.

A los usuarios Admin se les asigna el rol `sql_console_admin` de forma predeterminada, por lo que para ellos no cambia nada. Sin embargo, el rol `sql_console_read_only` permite conceder a los usuarios que no son Admin acceso de solo lectura o acceso completo a cualquier instancia. Un Admin debe configurar este acceso. Los roles pueden ajustarse mediante los comandos `GRANT` o `REVOKE` para adaptarse mejor a los requisitos específicos de cada instancia, y cualquier modificación que se haga en ellos se conservará.

<div id="granular-access-control">
  ### Control de acceso granular
</div>

Esta funcionalidad de control de acceso también puede configurarse manualmente con granularidad a nivel de usuario. Antes de asignar a los usuarios los nuevos roles `sql_console_*`, deben crearse roles de base de datos específicos por usuario para la consola SQL que coincidan con el espacio de nombres `sql-console-role:<email>`. Por ejemplo:

```sql theme={null}
CREATE ROLE OR REPLACE sql-console-role:<email>;
GRANT <some grants> TO sql-console-role:<email>;
```

Cuando se detecte un rol correspondiente, se asignará al usuario en lugar de los roles predefinidos. Esto permite configuraciones de control de acceso más complejas, como crear roles como `sql_console_sa_role` y `sql_console_pm_role` y concedérselos a usuarios específicos. Por ejemplo:

```sql theme={null}
CREATE ROLE OR REPLACE sql_console_sa_role;
GRANT <whatever level of access> TO sql_console_sa_role;
CREATE ROLE OR REPLACE sql_console_pm_role;
GRANT <whatever level of access> TO sql_console_pm_role;
CREATE ROLE OR REPLACE `sql-console-role:christoph@clickhouse.com`;
CREATE ROLE OR REPLACE `sql-console-role:jake@clickhouse.com`;
CREATE ROLE OR REPLACE `sql-console-role:zach@clickhouse.com`;
GRANT sql_console_sa_role to `sql-console-role:christoph@clickhouse.com`;
GRANT sql_console_sa_role to `sql-console-role:jake@clickhouse.com`;
GRANT sql_console_pm_role to `sql-console-role:zach@clickhouse.com`;
```

<div id="test-admin-privileges">
  ## Probar los privilegios de administrador
</div>

Cierre sesión con el usuario `default` y vuelva a iniciarla con el usuario `clickhouse_admin`.

Todo lo siguiente debería realizarse correctamente:

```sql theme={null}
SHOW GRANTS FOR clickhouse_admin;
```

```sql theme={null}
CREATE DATABASE db1
```

```sql theme={null}
CREATE TABLE db1.table1 (id UInt64, column1 String) ENGINE = MergeTree() ORDER BY id;
```

```sql theme={null}
INSERT INTO db1.table1 (id, column1) VALUES (1, 'abc');
```

```sql theme={null}
SELECT * FROM db1.table1;
```

```sql theme={null}
DROP TABLE db1.table1;
```

```sql theme={null}
DROP DATABASE db1;
```

<div id="non-admin-users">
  ## Usuarios no administradores
</div>

Los usuarios deben tener los privilegios necesarios, y no todos deben ser administradores. En el resto de este documento se presentan escenarios de ejemplo y los roles necesarios.

<div id="preparation">
  ### Preparación
</div>

Cree estas tablas y usuarios que se usarán en los ejemplos.

<div id="creating-a-sample-database-table-and-rows">
  #### Crear una base de datos, una tabla y filas de ejemplo
</div>

<Steps>
  <Step title="Crear una base de datos de prueba" id="create-a-test-database">
    ```sql theme={null}
    CREATE DATABASE db1;
    ```
  </Step>

  <Step title="Crear una tabla" id="create-a-table">
    ```sql theme={null}
    CREATE TABLE db1.table1 (
       id UInt64,
       column1 String,
       column2 String
    )
    ENGINE MergeTree
    ORDER BY id;
    ```
  </Step>

  <Step title="Poblar la tabla con filas de ejemplo" id="populate">
    ```sql theme={null}
    INSERT INTO db1.table1
       (id, column1, column2)
    VALUES
       (1, 'A', 'abc'),
       (2, 'A', 'def'),
       (3, 'B', 'abc'),
       (4, 'B', 'def');
    ```
  </Step>

  <Step title="Verificar la tabla" id="verify">
    ```sql title="Consulta" theme={null}
    SELECT *
    FROM db1.table1
    ```

    ```response title="Respuesta" theme={null}
    Query id: 475015cc-6f51-4b20-bda2-3c9c41404e49

    ┌─id─┬─column1─┬─column2─┐
    │  1 │ A       │ abc     │
    │  2 │ A       │ def     │
    │  3 │ B       │ abc     │
    │  4 │ B       │ def     │
    └────┴─────────┴─────────┘
    ```
  </Step>

  <Step title={<>Crear <code>column_user</code></>} id="create-a-user-with-restricted-access-to-columns">
    Cree un usuario estándar que se usará para demostrar cómo restringir el acceso a determinadas columnas:

    ```sql theme={null}
    CREATE USER column_user IDENTIFIED BY 'password';
    ```
  </Step>

  <Step title={<>Crear <code>row_user</code></>} id="create-a-user-with-restricted-access-to-rows-with-certain-values">
    Cree un usuario estándar que se usará para demostrar cómo restringir el acceso a filas con determinados valores:

    ```sql theme={null}
    CREATE USER row_user IDENTIFIED BY 'password';
    ```
  </Step>
</Steps>

<div id="creating-roles">
  #### Creación de roles
</div>

Con este conjunto de ejemplos:

* se crearán roles con distintos privilegios, como acceso por columnas y filas
* se otorgarán privilegios a los roles
* se asignarán usuarios a cada rol

Los roles se utilizan para definir grupos de usuarios con determinados privilegios, en lugar de administrar cada usuario por separado.

<Steps>
  <Step title={<>Crear un rol para restringir a los usuarios de este rol a que solo puedan ver <code>column1</code> en la base de datos <code>db1</code> y la tabla <code>table1</code>:</>} id="create-column-role">
    ```sql theme={null}
    CREATE ROLE column1_users;
    ```
  </Step>

  <Step title={<>Establecer privilegios para permitir ver <code>column1</code></>} id="set-column-privileges">
    ```sql theme={null}
    GRANT SELECT(id, column1) ON db1.table1 TO column1_users;
    ```
  </Step>

  <Step title={<>Añadir el usuario <code>column_user</code> al rol <code>column1_users</code></>} id="add-column-user-to-role">
    ```sql theme={null}
    GRANT column1_users TO column_user;
    ```
  </Step>

  <Step title={<>Crear un rol para restringir a los usuarios de este rol a que solo puedan ver determinadas filas; en este caso, solo las filas que contengan <code>A</code> en <code>column1</code></>} id="create-row-role">
    ```sql theme={null}
    CREATE ROLE A_rows_users;
    ```
  </Step>

  <Step title={<>Añadir <code>row_user</code> al rol <code>A_rows_users</code></>} id="add-row-user-to-role">
    ```sql theme={null}
    GRANT A_rows_users TO row_user;
    ```
  </Step>

  <Step title={<>Crear una política para permitir ver solo las filas en las que <code>column1</code> tenga el valor <code>A</code></>} id="create-row-policy">
    ```sql theme={null}
    CREATE ROW POLICY A_row_filter ON db1.table1 FOR SELECT USING column1 = 'A' TO A_rows_users;
    ```
  </Step>

  <Step title="Establecer privilegios para la base de datos y la tabla" id="set-db-table-privileges">
    ```sql theme={null}
    GRANT SELECT(id, column1, column2) ON db1.table1 TO A_rows_users;
    ```
  </Step>

  <Step title="Otorgar permisos explícitos para que otros roles sigan teniendo acceso a todas las filas" id="grant-other-roles-access">
    ```sql theme={null}
    CREATE ROW POLICY allow_other_users_filter 
    ON db1.table1 FOR SELECT USING 1 TO clickhouse_admin, column1_users;
    ```

    <Note>
      Al adjuntar una política a una tabla, el sistema aplicará esa política, y solo los usuarios y roles definidos podrán realizar operaciones sobre la tabla; a todos los demás se les denegará cualquier operación. Para evitar que la política restrictiva de filas se aplique a otros usuarios, se debe definir otra política que permita a otros usuarios y roles tener acceso normal u otros tipos de acceso.
    </Note>
  </Step>
</Steps>

<div id="verification">
  ## Verificación
</div>

<div id="testing-role-privileges-with-column-restricted-user">
  ### Comprobación de los privilegios del rol con un usuario restringido por columnas
</div>

<Steps>
  <Step title={<>Inicie sesión en el cliente de ClickHouse con el usuario <code>clickhouse_admin</code></>} id="login-admin-user">
    ```bash theme={null}
    clickhouse-client --user clickhouse_admin --password password
    ```
  </Step>

  <Step title="Verifique el acceso a la base de datos, la tabla y todas las filas con el usuario administrador." id="verify-admin-access">
    ```sql theme={null}
    SELECT *
    FROM db1.table1
    ```

    ```response theme={null}
    Query id: f5e906ea-10c6-45b0-b649-36334902d31d

    ┌─id─┬─column1─┬─column2─┐
    │  1 │ A       │ abc     │
    │  2 │ A       │ def     │
    │  3 │ B       │ abc     │
    │  4 │ B       │ def     │
    └────┴─────────┴─────────┘
    ```
  </Step>

  <Step title={<>Inicie sesión en el cliente de ClickHouse con el usuario <code>column_user</code></>} id="login-column-user">
    ```bash theme={null}
    clickhouse-client --user column_user --password password
    ```
  </Step>

  <Step title={<>Pruebe <code>SELECT</code> con todas las columnas</>} id="test-select-all-columns">
    ```sql theme={null}
    SELECT *
    FROM db1.table1
    ```

    ```response theme={null}
    Query id: 5576f4eb-7450-435c-a2d6-d6b49b7c4a23

    0 rows in set. Elapsed: 0.006 sec.

    Received exception from server (version 22.3.2):
    Code: 497. DB::Exception: Received from localhost:9000. 
    DB::Exception: column_user: Not enough privileges. 
    To execute this query it's necessary to have grant 
    SELECT(id, column1, column2) ON db1.table1. (ACCESS_DENIED)
    ```

    <Note>
      Se deniega el acceso porque se especificaron todas las columnas y el usuario solo tiene acceso a `id` y `column1`
    </Note>
  </Step>

  <Step title={<>Verifique la consulta <code>SELECT</code> usando solo las columnas especificadas y permitidas:</>} id="verify-allowed-columns">
    ```sql theme={null}
    SELECT
        id,
        column1
    FROM db1.table1
    ```

    ```response theme={null}
    Query id: cef9a083-d5ce-42ff-9678-f08dc60d4bb9

    ┌─id─┬─column1─┐
    │  1 │ A       │
    │  2 │ A       │
    │  3 │ B       │
    │  4 │ B       │
    └────┴─────────┘
    ```
  </Step>
</Steps>

<div id="testing-role-privileges-with-row-restricted-user">
  ### Probar los privilegios del rol con un usuario restringido por filas
</div>

<Steps>
  <Step title={<>Inicie sesión en el cliente de ClickHouse con <code>row_user</code></>} id="login-row-user">
    ```bash theme={null}
    clickhouse-client --user row_user --password password
    ```
  </Step>

  <Step title="Ver las filas disponibles" id="view-available-rows">
    ```sql theme={null}
    SELECT *
    FROM db1.table1
    ```

    ```response theme={null}
    Query id: a79a113c-1eca-4c3f-be6e-d034f9a220fb

    ┌─id─┬─column1─┬─column2─┐
    │  1 │ A       │ abc     │
    │  2 │ A       │ def     │
    └────┴─────────┴─────────┘
    ```

    <Note>
      Verifique que solo se devuelvan las dos filas anteriores; deben excluirse las filas con el valor `B` en `column1`.
    </Note>
  </Step>
</Steps>

<div id="modifying-users-and-roles">
  ## Modificar usuarios y roles
</div>

A los usuarios se les pueden asignar varios roles para obtener la combinación de privilegios necesaria. Al usar varios roles, el sistema los combinará para determinar los privilegios; en la práctica, los permisos de los roles serán acumulativos.

Por ejemplo, si `role1` permite solo hacer SELECT en `column1` y `role2` permite hacer SELECT en `column1` y `column2`, entonces el usuario tendrá acceso a ambas columnas.

<Steps>
  <Step title="Con la cuenta de administrador, cree un usuario nuevo para restringir tanto por fila como por columna con roles predeterminados" id="create-restricted-user">
    ```sql theme={null}
    CREATE USER row_and_column_user IDENTIFIED BY 'password' DEFAULT ROLE A_rows_users;
    ```
  </Step>

  <Step title={<>Elimine los privilegios previos del rol <code>A_rows_users</code></>} id="remove-prior-privileges">
    ```sql theme={null}
    REVOKE SELECT(id, column1, column2) ON db1.table1 FROM A_rows_users;
    ```
  </Step>

  <Step title={<>Permita que el rol <code>A_row_users</code> solo haga SELECT de <code>column1</code></>} id="allow-column1-select">
    ```sql theme={null}
    GRANT SELECT(id, column1) ON db1.table1 TO A_rows_users;
    ```
  </Step>

  <Step title={<>Inicie sesión en el cliente de ClickHouse con <code>row_and_column_user</code></>} id="login-restricted-user">
    ```bash theme={null}
    clickhouse-client --user row_and_column_user --password password;
    ```
  </Step>

  <Step title="Pruebe con todas las columnas:" id="test-all-columns-restricted">
    ```sql theme={null}
    SELECT *
    FROM db1.table1
    ```

    ```response theme={null}
    Query id: 8cdf0ff5-e711-4cbe-bd28-3c02e52e8bc4

    0 rows in set. Elapsed: 0.005 sec.

    Received exception from server (version 22.3.2):
    Code: 497. DB::Exception: Received from localhost:9000. 
    DB::Exception: row_and_column_user: Not enough privileges. 
    To execute this query it's necessary to have grant 
    SELECT(id, column1, column2) ON db1.table1. (ACCESS_DENIED)
    ```
  </Step>

  <Step title="Pruebe con las columnas permitidas:" id="test-limited-columns">
    ```sql theme={null}
    SELECT
        id,
        column1
    FROM db1.table1
    ```

    ```response theme={null}
    Query id: 5e30b490-507a-49e9-9778-8159799a6ed0

    ┌─id─┬─column1─┐
    │  1 │ A       │
    │  2 │ A       │
    └────┴─────────┘
    ```
  </Step>
</Steps>

<div id="troubleshooting">
  ## Resolución de problemas
</div>

A veces, los privilegios se superponen o se combinan de forma que producen resultados inesperados; los siguientes comandos pueden usarse para acotar el problema con una cuenta de administrador

<div id="listing-the-grants-and-roles-for-a-user">
  ### Listado de grants y roles de un usuario
</div>

```sql theme={null}
SHOW GRANTS FOR row_and_column_user
```

```response theme={null}
Query id: 6a73a3fe-2659-4aca-95c5-d012c138097b

┌─GRANTS FOR row_and_column_user───────────────────────────┐
│ GRANT A_rows_users, column1_users TO row_and_column_user │
└──────────────────────────────────────────────────────────┘
```

<div id="list-roles-in-clickhouse">
  ### Mostrar los roles en ClickHouse
</div>

```sql theme={null}
SHOW ROLES
```

```response theme={null}
Query id: 1e21440a-18d9-4e75-8f0e-66ec9b36470a

┌─name────────────┐
│ A_rows_users    │
│ column1_users   │
└─────────────────┘
```

<div id="display-the-policies">
  ### Mostrar las políticas
</div>

```sql theme={null}
SHOW ROW POLICIES
```

```response theme={null}
Query id: f2c636e9-f955-4d79-8e80-af40ea227ebc

┌─name───────────────────────────────────┐
│ A_row_filter ON db1.table1             │
│ allow_other_users_filter ON db1.table1 │
└────────────────────────────────────────┘
```

<div id="view-how-a-policy-was-defined-and-current-privileges">
  ### Ver cómo se definió una política y cuáles son los privilegios actuales
</div>

```sql theme={null}
SHOW CREATE ROW POLICY A_row_filter ON db1.table1
```

```response theme={null}
Query id: 0d3b5846-95c7-4e62-9cdd-91d82b14b80b

┌─CREATE ROW POLICY A_row_filter ON db1.table1────────────────────────────────────────────────┐
│ CREATE ROW POLICY A_row_filter ON db1.table1 FOR SELECT USING column1 = 'A' TO A_rows_users │
└─────────────────────────────────────────────────────────────────────────────────────────────┘
```

<div id="example-commands-to-manage-roles-policies-and-users">
  ## Comandos de ejemplo para gestionar roles, políticas y usuarios
</div>

Los siguientes comandos se pueden usar para:

* eliminar privilegios
* eliminar políticas
* desvincular usuarios de roles
* eliminar usuarios y roles
  <br />

<Tip>
  Ejecuta estos comandos con un usuario administrador o con el usuario `default`
</Tip>

<div id="remove-privilege-from-a-role">
  ### Eliminar un privilegio de un rol
</div>

```sql theme={null}
REVOKE SELECT(column1, id) ON db1.table1 FROM A_rows_users;
```

<div id="delete-a-policy">
  ### Eliminar una política
</div>

```sql theme={null}
DROP ROW POLICY A_row_filter ON db1.table1;
```

<div id="unassign-a-user-from-a-role">
  ### Quitar un usuario de un rol
</div>

```sql theme={null}
REVOKE A_rows_users FROM row_user;
```

<div id="delete-a-role">
  ### Eliminar un rol
</div>

```sql theme={null}
DROP ROLE A_rows_users;
```

<div id="delete-a-user">
  ### Eliminar un usuario
</div>

```sql theme={null}
DROP USER row_user;
```

<div id="summary">
  ## Resumen
</div>

En este artículo se explicaron los conceptos básicos para crear usuarios y roles de SQL, y se indicaron los pasos para establecer y modificar los privilegios de usuarios y roles. Para obtener información más detallada sobre cada uno de ellos, consulte nuestras guías de usuario y la documentación de referencia.