--- title: "Cómo gestionar usuarios, grupos y permisos en Linux" description: "Crea usuarios y grupos, da acceso sudo con visudo, domina chmod, chown, setgid y umask y monta un directorio compartido con ACL en Ubuntu 24.04 o Rocky 9." category: "Configuración del Servidor" language: es source: https://cubepath.com/es/docs/configuración-del-servidor/como-configurar-usuarios-y-permisos-en-linux updated: 2026-09-25 --- # Cómo gestionar usuarios, grupos y permisos en Linux Linux controla quién puede hacer qué mediante usuarios, grupos y permisos sobre cada archivo. Entender este modelo es imprescindible para dar acceso a otras personas o a aplicaciones sin entregarles la cuenta de root. En esta guía crearás usuarios y grupos, les darás permisos de administración de forma controlada con `sudo`, aprenderás a leer y cambiar permisos con `chmod` y `chown`, y montarás un directorio compartido para un equipo usando el bit setgid y ACL. Los comandos son para Ubuntu 24.04; las diferencias con Rocky Linux 9 se indican en cada paso. ## Requisitos previos - Un servidor con Ubuntu 24.04 LTS (o Debian 12 / Rocky Linux 9), por ejemplo un VPS de CubePath. - Un usuario con privilegios `sudo`. Si aún trabajas como root, sigue antes la guía de configuración inicial de seguridad. ## Conceptos básicos Cada usuario tiene un identificador numérico (UID) y pertenece a un grupo primario y, opcionalmente, a grupos suplementarios. Los usuarios normales empiezan en el UID 1000; por debajo están root (UID 0) y las cuentas de sistema que usan servicios como `www-data`. Estos datos se guardan en archivos de texto que no deberías editar a mano: | Archivo | Contenido | |---|---| | `/etc/passwd` | Usuarios, UID, grupo primario, directorio personal y shell | | `/etc/shadow` | Hashes de contraseñas y caducidad (solo legible por root) | | `/etc/group` | Grupos y sus miembros suplementarios | | `/etc/sudoers` y `/etc/sudoers.d/` | Quién puede usar `sudo` y para qué | Cada archivo tiene un propietario, un grupo y tres juegos de permisos: para el propietario (u), el grupo (g) y el resto (o). Cada juego combina lectura (r = 4), escritura (w = 2) y ejecución (x = 1). ## Paso 1: Crear y gestionar usuarios En Ubuntu y Debian, `adduser` es la herramienta interactiva recomendada: crea el directorio personal, copia los archivos de `/etc/skel` y pide la contraseña. Crea un usuario llamado `ana`: ```bash sudo adduser ana ``` En Rocky Linux, `adduser` es un alias de `useradd`, que no es interactivo. El equivalente es: ```bash sudo useradd -m -s /bin/bash ana sudo passwd ana ``` Comprueba el usuario creado: ```bash id ana ``` ```output uid=1001(ana) gid=1001(ana) groups=1001(ana),100(users) ``` Para una cuenta que solo ejecuta un servicio y nunca inicia sesión, crea un usuario de sistema sin shell interactiva: ```bash sudo useradd --system --no-create-home --shell /usr/sbin/nologin miapp ``` Otras operaciones habituales: ```bash sudo usermod -s /bin/bash ana # cambiar la shell sudo usermod -L ana # bloquear la contraseña sudo usermod -U ana # desbloquearla sudo chage -E 2026-12-31 ana # la cuenta caduca en esa fecha sudo chage -l ana # ver la caducidad ``` `usermod -L` solo bloquea la contraseña: el usuario podría seguir entrando con una clave SSH. Para bloquear la cuenta por completo, usa además `sudo usermod -s /usr/sbin/nologin ana` o haz que caduque con `chage -E 0`. Para eliminar un usuario y su directorio personal: ```bash sudo deluser --remove-home ana # Ubuntu/Debian sudo userdel -r ana # Rocky Linux ``` Antes de borrar, localiza los archivos que tenga fuera de su directorio personal con `sudo find / -xdev -user ana`. ## Paso 2: Crear grupos y añadir miembros Los grupos permiten dar permisos a varias personas a la vez. Crea un grupo `desarrollo` y añade a `ana`: ```bash sudo groupadd desarrollo sudo usermod -aG desarrollo ana ``` La opción `-a` es fundamental: sin ella, `-G` sustituye todos los grupos suplementarios del usuario por los que indicas. En Ubuntu también puedes usar `sudo gpasswd -a ana desarrollo`, que hace lo mismo. Comprueba los miembros del grupo: ```bash getent group desarrollo ``` ```output desarrollo:x:1002:ana ``` Los cambios de grupo se aplican en el siguiente inicio de sesión. Si `ana` tiene una sesión abierta, debe salir y volver a entrar para que `id` muestre el grupo nuevo. Para quitar a un usuario de un grupo o borrar el grupo: ```bash sudo gpasswd -d ana desarrollo sudo groupdel desarrollo ``` ## Paso 3: Dar acceso de administrador con sudo La forma más simple de convertir a un usuario en administrador es añadirlo al grupo con permisos de `sudo`, que se llama `sudo` en Ubuntu y Debian y `wheel` en Rocky Linux: ```bash sudo usermod -aG sudo ana # Ubuntu/Debian sudo usermod -aG wheel ana # Rocky Linux ``` Cuando alguien solo necesita ejecutar unos pocos comandos, es mejor darle exactamente esos. Crea las reglas en un archivo propio dentro de `/etc/sudoers.d/` y edítalo siempre con `visudo`, que comprueba la sintaxis antes de guardar: un error en sudoers puede dejarte sin `sudo` en todo el sistema. ```bash sudo visudo -f /etc/sudoers.d/desarrollo ``` Este ejemplo permite a los miembros de `desarrollo` reiniciar y consultar el servicio `nginx`, y nada más: ```text %desarrollo ALL=(root) /usr/bin/systemctl restart nginx, /usr/bin/systemctl status nginx ``` El `%` indica un grupo. Usa siempre rutas absolutas para los comandos. Comprueba qué puede hacer un usuario: ```bash sudo -l -U ana ``` ```output User ana may run the following commands on your_hostname: (root) /usr/bin/systemctl restart nginx, /usr/bin/systemctl status nginx ``` > Advertencia: no permitas comandos que abren una shell o un editor (`vim`, `less`, `bash`, `find`, `systemctl edit`), ni scripts en los que el usuario pueda escribir. Cualquiera de ellos da acceso completo como root. ## Paso 4: Leer y cambiar permisos con chmod Crea un archivo de prueba y observa sus permisos con `ls -l`: ```bash touch informe.txt ls -l informe.txt ``` ```output -rw-rw-r-- 1 your_user your_user 0 sep 24 10:30 informe.txt ``` El primer carácter indica el tipo (`-` archivo, `d` directorio, `l` enlace). Después vienen los permisos del propietario (`rw-`), del grupo (`rw-`) y del resto (`r--`), y a continuación el propietario y el grupo. En directorios, los permisos significan otra cosa: `r` permite listar el contenido, `w` crear y borrar archivos dentro, y `x` entrar en el directorio y acceder a sus archivos. `chmod` acepta el modo numérico, que fija todos los permisos a la vez, y el simbólico, que añade o quita permisos concretos: ```bash chmod 640 informe.txt # rw- r-- --- chmod u+x script.sh # añade ejecución al propietario chmod g-w,o= informe.txt # quita escritura al grupo y todo al resto ``` Valores numéricos habituales: | Modo | Permisos | Uso típico | |---|---|---| | `600` | `rw-------` | Claves privadas, archivos con contraseñas | | `640` | `rw-r-----` | Configuración que lee un grupo | | `644` | `rw-r--r--` | Archivos públicos de una web | | `700` | `rwx------` | Directorio privado, `~/.ssh` | | `755` | `rwxr-xr-x` | Directorios y scripts ejecutables | Para cambiar permisos de forma recursiva, no uses `chmod -R 755` sobre todo un árbol, porque dará permiso de ejecución a todos los archivos. Trata archivos y directorios por separado: ```bash sudo find /var/www/ejemplo -type d -exec chmod 755 {} + sudo find /var/www/ejemplo -type f -exec chmod 644 {} + ``` > Advertencia: `chmod 777` nunca es la solución a un "Permission denied". Permite a cualquier usuario o proceso del sistema modificar el archivo. Averigua qué usuario necesita el acceso y ajusta el propietario o el grupo. ## Paso 5: Cambiar propietario y grupo con chown `chown` cambia el propietario y el grupo de un archivo. Solo root puede cambiar el propietario: ```bash sudo chown ana informe.txt # solo propietario sudo chown ana:desarrollo informe.txt # propietario y grupo sudo chown :desarrollo informe.txt # solo grupo sudo chown -R www-data:www-data /var/www/ejemplo ``` Comprueba el resultado con `ls -l`. Un caso muy frecuente: una aplicación web no puede escribir en su carpeta de subidas porque pertenece a tu usuario. Dale la propiedad al usuario del servidor web (`www-data` en Ubuntu, `nginx` o `apache` en Rocky Linux) solo en esa carpeta, no en todo el sitio. ## Paso 6: Crear un directorio compartido con setgid Un problema típico al compartir una carpeta entre varios usuarios es que cada archivo nuevo pertenece al grupo primario de quien lo crea, así que los demás no pueden modificarlo. El bit **setgid** en un directorio hace que todo lo que se cree dentro herede el grupo del directorio. Crea el directorio del proyecto, asígnalo al grupo `desarrollo` y aplica `2770` (el `2` es el setgid; el resto, acceso completo para propietario y grupo y nada para los demás): ```bash sudo mkdir -p /srv/proyecto sudo chown root:desarrollo /srv/proyecto sudo chmod 2770 /srv/proyecto ``` ```bash ls -ld /srv/proyecto ``` ```output drwxrws--- 2 root desarrollo 4096 sep 24 10:40 /srv/proyecto ``` La `s` en la posición de ejecución del grupo indica el setgid. Prueba a crear un archivo como `ana`: ```bash sudo -u ana touch /srv/proyecto/prueba.txt ls -l /srv/proyecto ``` ```output -rw-r--r-- 1 ana desarrollo 0 sep 24 10:41 prueba.txt ``` El archivo pertenece al grupo `desarrollo` aunque el grupo primario de `ana` sea `ana`. Aquí el grupo solo tiene lectura porque `sudo` aplica una umask de `0022`; cuando `ana` trabaje en su propia sesión, con la umask `0002` de Ubuntu, sus archivos serán editables por todo el equipo (lo verás en el paso 7). Otros dos bits especiales que conviene reconocer: - **Sticky bit** (`chmod +t`, `1777` en `/tmp`): en un directorio compartido, cada usuario solo puede borrar sus propios archivos. - **setuid** (`4755`): el programa se ejecuta con los permisos de su propietario, como `/usr/bin/passwd`. No lo apliques a tus propios scripts. ## Paso 7: Ajustar los permisos por defecto con umask La `umask` resta permisos a los archivos y directorios nuevos. Con el valor habitual `0002` en Ubuntu, los archivos se crean con `664` y los directorios con `775`; con `0022`, con `644` y `755`. Consulta el valor de tu sesión: ```bash umask ``` ```output 0002 ``` En el directorio compartido del paso anterior, un archivo creado con `umask 0022` no sería editable por el grupo. Para cambiarla en tu sesión usa `umask 0002`; para hacerlo permanente, añade esa línea a tu `~/.bashrc`. Para un servicio, usa la directiva `UMask=` en su unidad de systemd. ## Paso 8: Permisos más finos con ACL Los permisos clásicos solo admiten un propietario y un grupo. Cuando necesitas dar acceso a un usuario concreto sin cambiar grupos, usa listas de control de acceso (ACL). Instala las herramientas (en Rocky Linux el paquete también se llama `acl`): ```bash sudo apt install acl ``` Da a `luis` acceso de solo lectura al proyecto, y haz que se aplique también a los archivos que se creen en el futuro con una ACL por defecto (`-d`): ```bash sudo setfacl -R -m u:luis:rX /srv/proyecto sudo setfacl -d -m u:luis:rX /srv/proyecto ``` La `X` mayúscula da ejecución solo a directorios (y a archivos que ya eran ejecutables), así que `luis` puede entrar en las carpetas sin poder ejecutar archivos. Consulta las ACL: ```bash getfacl /srv/proyecto ``` ```output # file: srv/proyecto # owner: root # group: desarrollo # flags: -s- user::rwx user:luis:r-x group::rwx mask::rwx other::--- default:user::rwx default:user:luis:r-x default:group::rwx default:mask::rwx default:other::--- ``` `ls -l` muestra un `+` al final de los permisos de los archivos con ACL. Para quitar el acceso de `luis`, usa `sudo setfacl -R -x u:luis /srv/proyecto` y lo mismo con `-d`. ## Solución de problemas **`Permission denied` al acceder a un archivo con permisos correctos.** Para llegar a un archivo hace falta permiso `x` en **todos** los directorios de la ruta. `namei` lo muestra de un vistazo: ```bash namei -l /srv/proyecto/prueba.txt ``` **El usuario no tiene el grupo nuevo.** Los grupos se cargan al iniciar sesión. Pide que cierre y abra la sesión, o comprueba el estado real con `id ana`. **`ana is not in the sudoers file`.** Falta el grupo `sudo` (o `wheel` en Rocky) o hay un error en tu archivo de `/etc/sudoers.d/`. Valida toda la configuración con `sudo visudo -c`. **Un script no se ejecuta.** Necesita permiso de ejecución (`chmod +x script.sh`) y una línea shebang válida, como `#!/usr/bin/env bash`. Si está en una partición montada con `noexec`, ejecútalo con `bash script.sh`. ## Conclusión Ya sabes crear usuarios y grupos, delegar tareas administrativas con reglas de `sudo` acotadas, ajustar permisos y propietarios sin recurrir a `777`, y montar un directorio compartido con setgid y ACL. Como siguientes pasos, revisa la guía de configuración inicial de seguridad para limitar el acceso SSH a usuarios concretos y la de gestión de claves SSH para dar acceso a nuevos miembros del equipo sin compartir contraseñas.