Administración de Usuarios y Grupos en RHEL: Guía Completa

Introducción

En este laboratorio, adquirirás habilidades esenciales en la gestión de usuarios y grupos locales dentro de un entorno Red Hat Enterprise Linux (RHEL). Comenzarás por comprender los conceptos fundamentales de usuarios y grupos, incluyendo cómo identificar la información de usuarios y grupos, así como la propiedad de archivos.

Posteriormente, aprenderás a obtener acceso de superusuario, crear y modificar cuentas de usuario locales, gestionar cuentas de grupo locales y configurar políticas de contraseñas de usuario. Esta experiencia práctica te equipará con el conocimiento para controlar eficazmente el acceso y los permisos en tu sistema Linux.

Comprender los Conceptos de Usuarios y Grupos

En este paso, aprenderás sobre los conceptos fundamentales de usuarios y grupos en Red Hat Enterprise Linux (RHEL) y cómo usar varios comandos para inspeccionar la información de usuarios y grupos. Comprender estos conceptos es crucial para gestionar los permisos y el control de acceso en un sistema Linux.

Cada archivo y proceso en un sistema Linux está asociado con un usuario y un grupo. Esta asociación determina quién puede leer, escribir o ejecutar archivos, y quién puede gestionar procesos.

Primero, exploremos cómo identificar al usuario actual y a otros usuarios en el sistema usando el comando id.

Usa el comando id para mostrar información sobre el usuario actualmente conectado. Este comando muestra el ID de usuario (UID), el ID de grupo principal (GID) y todos los grupos a los que pertenece el usuario.
```
id
```
Deberías ver una salida similar a esta, indicando la información de tu usuario labex:
```
uid=1000(labex) gid=1000(labex) groups=1000(labex),10(wheel) context=unconfined_u:unconfined_r:unconfined_t:s0-s0:c0.c1023
```
Para ver información básica sobre otro usuario, como el usuario root, pasa el nombre de usuario al comando id como argumento.
```
id root
```
La salida mostrará el UID (0), GID (0) y grupos del usuario root:
```
uid=0(root) gid=0(root) groups=0(root) context=unconfined_u:unconfined_r:unconfined_t:s0-s0:c0.c1023
```

A continuación, aprenderás a identificar el propietario de archivos y directorios usando el comando ls.

Usa el comando ls -l para ver el propietario de un archivo. Primero, crea un archivo ficticio en tu directorio ~/project.
```
touch ~/project/mytextfile.txt
ls -l ~/project/mytextfile.txt
```
La salida mostrará labex como el usuario y el propietario del grupo de mytextfile.txt:
```
-rw-r--r-- 1 labex labex 0 Feb  5 11:10 /home/labex/project/mytextfile.txt
```
Usa el comando ls -ld para ver el propietario de un directorio, en lugar del contenido de ese directorio. En la siguiente salida, la tercera columna muestra el nombre de usuario y la cuarta columna muestra el nombre del grupo.
```
ls -ld ~/project
```
Verás labex como el propietario de tu directorio ~/project:
```
drwxr-xr-x 2 labex labex 6 Feb  5 11:10 /home/labex/project
```

Ahora, examinemos cómo ver la información del proceso y el usuario asociado con cada proceso usando el comando ps.

Usa el comando ps -au para ver los procesos. La opción a muestra todos los procesos con un terminal, y la opción u muestra el usuario que está asociado con un proceso. En la siguiente salida, la primera columna muestra el nombre de usuario.

ps -au

Verás varios procesos, con labex y root como usuarios comunes:

USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root         1  0.0  0.0  10608  3808 ?        Ss   00:00   0:00 /sbin/init
root        42  0.0  0.0  10608  3808 ?        Ss   00:00   0:00 /sbin/init
labex      123  0.0  0.1 224152  5756 pts/0    Ss   00:00   0:00 -bash
labex      150  0.0  0.0 225556  3652 pts/0    R+   00:00   0:00 ps -au

Finalmente, explorarás los archivos /etc/passwd y /etc/group, que almacenan información de usuarios y grupos, respectivamente. Estos archivos son críticos para comprender cómo se definen las cuentas de usuario y grupo en un sistema Linux.

Cada línea en el archivo /etc/passwd contiene información sobre un usuario. El archivo se divide en siete campos separados por dos puntos. Usa cat para ver su contenido.
```
cat /etc/passwd
```
Localiza la entrada para labex y root. Para labex, debería verse similar a esto:
```
labex:x:1000:1000:LabEx User:/home/labex:/bin/bash
```
Desglosemos cada campo:
- labex: El nombre de usuario para este usuario.
- x: La contraseña encriptada del usuario se almacenaba históricamente aquí; esto ahora es un marcador de posición, ya que las contraseñas se almacenan en /etc/shadow por seguridad.
- 1000: El número UID para esta cuenta de usuario.
- 1000: El número GID para el grupo principal de esta cuenta de usuario.
- LabEx User: Un breve comentario, descripción o el nombre real de este usuario.
- /home/labex: El directorio de inicio del usuario y el directorio de trabajo inicial cuando se inicia el shell de inicio de sesión.
- /bin/bash: El programa de shell predeterminado para este usuario que se ejecuta al iniciar sesión.
Cada línea en el archivo /etc/group contiene información sobre un grupo. Cada entrada de grupo se divide en cuatro campos separados por dos puntos. Usa cat para ver su contenido.
```
cat /etc/group
```
Verás entradas para varios grupos del sistema y grupos privados de usuarios. Por ejemplo, la entrada del grupo labex podría verse así:
```
labex:x:1000:
```
Desglosemos cada campo:
- labex: Nombre de este grupo.
- x: Campo de contraseña de grupo obsoleto; esto ahora es un marcador de posición.
- 1000: El número GID para este grupo.
- (vacío): Una lista de usuarios que son miembros de este grupo como un grupo secundario. Si este campo está vacío, significa que no hay usuarios adicionales listados explícitamente como miembros secundarios de este grupo (aunque el usuario principal labex es implícitamente un miembro).
Grupos Primarios y Grupos Secundarios: Cada usuario tiene exactamente un grupo principal. Para los usuarios locales, este grupo se enumera por GID en el archivo /etc/passwd. El grupo principal es propietario de los archivos que crea el usuario. Al crear un usuario normal, a menudo se crea un grupo con el mismo nombre que el usuario, para ser el grupo principal del usuario. El usuario es típicamente el único miembro de este Grupo Privado de Usuario. Este diseño simplifica la gestión de permisos de archivos.

Los usuarios también pueden tener grupos secundarios. La pertenencia a grupos secundarios se almacena en el archivo /etc/group. A los usuarios se les concede acceso a los archivos en función de si alguno de sus grupos tiene acceso, independientemente de si los grupos son primarios o secundarios. Por ejemplo, si el usuario labex tiene un grupo principal labex y wheel como grupo secundario, entonces ese usuario puede leer archivos que cualquiera de esos dos grupos pueda leer.

El comando id puede mostrar todas las membresías de grupo para un usuario. Recuerda la salida de id para labex:
```
uid=1000(labex) gid=1000(labex) groups=1000(labex),10(wheel) context=unconfined_u:unconfined_r:unconfined_t:s0-s0:c0.c1023
```
Aquí, gid=1000(labex) indica que labex es el grupo principal. groups=1000(labex),10(wheel) enumera todas las membresías de grupo, mostrando labex como el grupo principal y wheel como un grupo secundario.

Obtener Acceso de Superusuario

En este paso, aprenderás a obtener acceso de superusuario (privilegios de root) en un sistema RHEL. El acceso de superusuario es esencial para realizar tareas administrativas como instalar software, gestionar usuarios y configurar la configuración del sistema. Explorarás los comandos su y sudo, que son las herramientas principales para la escalada de privilegios.

El comando su (substitute user) te permite cambiar a otra cuenta de usuario. Cuando se usa sin un nombre de usuario, por defecto es el usuario root.

Usa el comando su - para cambiar al usuario root. La opción de guion (-) asegura que obtengas un shell de inicio de sesión, lo que significa que se cargarán las variables de entorno y la ruta del usuario root. Se te pedirá la contraseña de root, que es redhat.
```
su -
```
Después de ingresar la contraseña redhat, tu prompt cambiará a [root@host ~]#, indicando que ahora eres el usuario root.
```
Password:
[root@host ~]#
```
Para verificar que eres root, puedes ejecutar el comando whoami:
```
whoami
```
La salida debería ser:
```
root
```
Para salir del shell de root y volver a tu usuario labex, escribe exit.
```
exit
```
Tu prompt volverá a [labex@host ~]$.

El comando sudo (superuser do) permite a un usuario autorizado ejecutar un comando como superusuario u otro usuario, según lo especificado por el archivo sudoers. El usuario labex está configurado para tener privilegios sudo sin requerir una contraseña, lo cual es común en muchos entornos de nube y laboratorio.

Usa el comando sudo -i para cambiar a la cuenta root. Este comando generalmente se prefiere a su - porque proporciona una forma más segura de ejecutar comandos con privilegios elevados. Cuando usas sudo -i, sigues usando tu propia cuenta de usuario pero con privilegios de root, y los comandos se registran en tu cuenta, lo que facilita el seguimiento de lo que se hizo.
```
sudo -i
```
Tu prompt cambiará a [root@host ~]#, indicando que ahora eres el usuario root.
```
[root@host ~]#
```
De nuevo, puedes verificar con whoami:
```
whoami
```
La salida debería ser:
```
root
```
Para salir del shell de root y volver a tu usuario labex, escribe exit.
```
exit
```
Tu prompt volverá a [labex@host ~]$.
También puedes usar sudo para ejecutar un solo comando con privilegios de root sin cambiar al shell de root. Por ejemplo, para ver el contenido de /etc/shadow (que solo es legible por root), puedes usar sudo cat /etc/shadow.
```
sudo cat /etc/shadow | head -n 3
```
Esto mostrará las tres primeras líneas del archivo /etc/shadow, demostrando que el comando cat se ejecutó con privilegios de root.
```
root:*:19780:0:99999:7:::
bin:*:19780:0:99999:7:::
daemon:*:19780:0:99999:7:::
```
El archivo /etc/sudoers es el archivo de configuración principal para el comando sudo. Define qué usuarios o grupos pueden ejecutar qué comandos con privilegios elevados. Para evitar problemas si varios administradores intentan editar el archivo al mismo tiempo, debes editarlo solo con el comando especial visudo. El editor visudo también valida el archivo, para asegurar que no haya errores de sintaxis.

Una entrada común en /etc/sudoers permite a los miembros del grupo wheel ejecutar cualquier comando como root. El usuario labex es miembro del grupo wheel, que es la razón por la que sudo funciona sin una contraseña.
```
sudo grep wheel /etc/sudoers
```
Deberías ver una línea similar a esta, que otorga acceso sudo al grupo wheel:
```
%wheel        ALL=(ALL:ALL)       ALL
```
Esta línea significa:
- %wheel: La regla se aplica a los miembros del grupo wheel. El símbolo % denota un grupo.
- ALL=(ALL:ALL): En cualquier host (primer ALL), los usuarios del grupo wheel pueden ejecutar comandos como cualquier usuario (segundo ALL) y cualquier grupo (tercer ALL).
- ALL: Los usuarios del grupo wheel pueden ejecutar cualquier comando.

Esto concluye tu exploración de la obtención de acceso de superusuario. Ahora entiendes la diferencia entre su - y sudo -i y cómo ejecutar comandos con privilegios elevados.

Crear y Modificar Cuentas de Usuario Locales

En este paso, aprenderás a crear, modificar y eliminar cuentas de usuario locales en un sistema RHEL. La gestión de cuentas de usuario es una tarea administrativa fundamental, que garantiza que cada usuario tenga el acceso y los permisos apropiados. Usarás comandos como useradd, usermod, userdel y passwd.

Primero, creemos una nueva cuenta de usuario.

Usa el comando useradd para crear un nuevo usuario. Por defecto, useradd crea un nuevo usuario con un UID mayor o igual a 1000, crea un directorio de inicio (/home/nombredeusuario) y establece el shell predeterminado en /bin/bash. Necesitas privilegios sudo para ejecutar este comando. Creemos un usuario llamado testuser01.
```
sudo useradd testuser01
```
Después de crear el usuario, puedes verificar su existencia en /etc/passwd y comprobar su directorio de inicio.
```
grep testuser01 /etc/passwd
ls -ld /home/testuser01
```
Deberías ver una salida similar a esta:
```
testuser01:x:1001:1001::/home/testuser01:/bin/bash
drwx------. 2 testuser01 testuser01 6 Mar  4 15:22 /home/testuser01
```
Por defecto, los usuarios recién creados no tienen una contraseña establecida, lo que significa que no pueden iniciar sesión. Necesitas establecer una contraseña para testuser01 usando el comando passwd.
```
sudo passwd testuser01
```
Se te pedirá que ingreses una nueva contraseña. Para este laboratorio, usa labexrhel9 como la contraseña para testuser01. Podrías ver una advertencia "BAD PASSWORD", pero puedes continuar.
```
New password:
Retype new password:
passwd: all authentication tokens updated successfully.
```
Ahora, intenta cambiar a testuser01 usando su -.
```
su - testuser01
```
Ingresa la contraseña labexrhel9 cuando se te solicite. Tu prompt debería cambiar a [testuser01@host ~]$.
```
Password:
[testuser01@host ~]$
```
Para volver a tu usuario labex, escribe exit.
```
exit
```

A continuación, modifiquemos una cuenta de usuario existente usando el comando usermod. El comando usermod te permite cambiar varias propiedades de un usuario, como su directorio de inicio, shell o membresías de grupo.

Cambiemos el campo de comentario (nombre completo) para testuser01 a "Test User One".
```
sudo usermod -c "Test User One" testuser01
```
Verifica el cambio comprobando el archivo /etc/passwd de nuevo.
```
grep testuser01 /etc/passwd
```
La salida ahora debería reflejar el comentario actualizado:
```
testuser01:x:1001:1001:Test User One:/home/testuser01:/bin/bash
```
También puedes bloquear o desbloquear una cuenta de usuario. Bloquear una cuenta impide que el usuario inicie sesión, mientras que desbloquearla vuelve a habilitar el inicio de sesión.

Para bloquear la cuenta testuser01:
```
sudo usermod -L testuser01
```
Ahora, intenta cambiar a testuser01 de nuevo.
```
su - testuser01
```
Se te pedirá la contraseña, pero incluso con la contraseña correcta, el inicio de sesión fallará:
```
Password:
su: Authentication failure
```
Para desbloquear la cuenta testuser01:
```
sudo usermod -U testuser01
```
Intenta cambiar a testuser01 de nuevo, y debería tener éxito. Recuerda exit para volver a labex.
```
su - testuser01
## Enter password 'labexrhel9'
exit
```

Finalmente, eliminemos la cuenta de usuario que creaste.

Usa el comando userdel para eliminar un usuario. Por defecto, userdel elimina la entrada del usuario de /etc/passwd pero deja su directorio de inicio intacto. Esto puede llevar a archivos huérfanos.
```
sudo userdel testuser01
```
Verifica que el usuario se elimine de /etc/passwd, pero el directorio de inicio aún existe.
```
grep testuser01 /etc/passwd
ls -ld /home/testuser01
```
El comando grep no debería devolver ninguna salida, lo que indica que el usuario se ha ido. El comando ls -ld mostrará que el directorio de inicio aún existe, pero su propiedad aparecerá como UIDs/GIDs numéricos ya que el usuario ya no existe.
```
drwx------ 2 1001 1001 83 Mar  4 15:22 /home/testuser01
```
Nota: En algunas versiones o configuraciones de RHEL, userdel podría eliminar el directorio de inicio por defecto si está vacío o si el usuario era el único propietario. Sin embargo, es más seguro usar explícitamente la opción -r para asegurar que el directorio de inicio se elimine.
Para eliminar el usuario y su directorio de inicio, usa la opción -r con userdel. Creemos un nuevo usuario testuser02 para demostrar esto correctamente.
```
sudo useradd testuser02
sudo passwd testuser02 ## Se te pedirá que ingreses 'labexrhel9'
```
Ahora, elimina testuser02 y su directorio de inicio:
```
sudo userdel -r testuser02
```
Verifica que tanto la entrada del usuario como el directorio de inicio se eliminen.
```
grep testuser02 /etc/passwd
ls -ld /home/testuser02
```
Ambos comandos deberían indicar que testuser02 y su directorio de inicio ya no existen.
```
ls: cannot access '/home/testuser02': No such file or directory
```

Esto concluye tu práctica con la creación, modificación y eliminación de cuentas de usuario locales.

Gestionar Cuentas de Grupo Locales

En este paso, aprenderás a gestionar cuentas de grupo locales en un sistema RHEL. Los grupos son fundamentales para gestionar los permisos de manera eficiente, permitiéndote otorgar acceso a múltiples usuarios simultáneamente. Usarás comandos como groupadd, groupmod y groupdel, y también volverás a visitar usermod para gestionar las membresías de usuario-grupo.

Primero, creemos un nuevo grupo.

Usa el comando groupadd para crear un nuevo grupo. Por defecto, groupadd asigna el siguiente GID disponible del rango especificado en /etc/login.defs. Necesitas privilegios sudo para ejecutar este comando. Creemos un grupo llamado developers.
```
sudo groupadd developers
```
Puedes verificar la creación del grupo comprobando el archivo /etc/group.
```
grep developers /etc/group
```
Deberías ver una entrada similar a esta:
```
developers:x:1002:
```
También puedes especificar un GID particular para el grupo usando la opción -g. Creemos otro grupo llamado testers con un GID específico, por ejemplo, 2000.
```
sudo groupadd -g 2000 testers
```
Verifica el GID del grupo testers.
```
grep testers /etc/group
```
La salida debería confirmar el GID especificado:
```
testers:x:2000:
```

A continuación, modifiquemos un grupo existente usando el comando groupmod.

Puedes cambiar el nombre de un grupo usando la opción -n. Renombremos testers a qa_team.
```
sudo groupmod -n qa_team testers
```
Verifica el cambio de nombre en /etc/group.
```
grep qa_team /etc/group
```
La salida debería mostrar el nuevo nombre con el GID original:
```
qa_team:x:2000:
```
También puedes cambiar el GID de un grupo usando la opción -g. Cambiemos el GID de qa_team a 2001.
```
sudo groupmod -g 2001 qa_team
```
Verifica el cambio de GID.
```
grep qa_team /etc/group
```
La salida debería reflejar el nuevo GID:
```
qa_team:x:2001:
```

Ahora, gestionemos las membresías de usuarios dentro de estos grupos. Usarás el comando usermod para esto. Primero, crea un par de usuarios de prueba.

Crea userA y userB y establece sus contraseñas en labexrhel9.
```
sudo useradd userA
sudo passwd userA
```
Escribe labexrhel9 como la contraseña para userA.
```
sudo useradd userB
sudo passwd userB
```
Escribe labexrhel9 como la contraseña para userB.
Agrega userA al grupo developers como un grupo secundario. Usa las opciones -a (append) y -G (groups) con usermod.
```
sudo usermod -aG developers userA
```
Verifica las membresías de grupo de userA usando el comando id.
```
id userA
```
Deberías ver developers listado en la sección groups:
```
uid=1003(userA) gid=1003(userA) groups=1003(userA),1002(developers)
```
Agrega userB a los grupos developers y qa_team como grupos secundarios.
```
sudo usermod -aG developers,qa_team userB
```
Verifica las membresías de grupo de userB.
```
id userB
```
Deberías ver tanto developers como qa_team listados:
```
uid=1004(userB) gid=1004(userB) groups=1004(userB),1002(developers),2001(qa_team)
```
También puedes cambiar el grupo principal de un usuario usando la opción -g con usermod. Cambiemos el grupo principal de userA a developers.
```
sudo usermod -g developers userA
```
Verifica el grupo principal de userA.
```
id userA
```
El campo gid ahora debería mostrar developers:
```
uid=1003(userA) gid=1002(developers) groups=1002(developers)
```
Nota: Cuando cambias el grupo principal de un usuario, se eliminan de la lista de membresía de su antiguo grupo principal en /etc/group si ese grupo también era un grupo secundario. En este caso, el grupo principal original de userA (userA) ya no aparece como un grupo secundario.

Finalmente, eliminemos los grupos y usuarios de prueba que creaste.

Usa el comando groupdel para eliminar un grupo. No puedes eliminar un grupo si es el grupo principal de algún usuario. Primero, cambia el grupo principal de userA de nuevo a su valor predeterminado (u otro grupo existente) antes de eliminar developers.
```
sudo usermod -g userA userA ## Cambia el grupo principal de userA de nuevo a userA
sudo groupdel developers
```
Verifica que developers se elimine de /etc/group.
```
grep developers /etc/group
```
Este comando no debería devolver ninguna salida.
Elimina el grupo qa_team.
```
sudo groupdel qa_team
```
Verifica su eliminación.
```
grep qa_team /etc/group
```
Este comando tampoco debería devolver ninguna salida.

Limpia los usuarios de prueba.

sudo userdel -r userA
sudo userdel -r userB

Esto concluye tu práctica con la gestión de cuentas de grupo locales y las membresías de usuario-grupo.

Configurar Políticas de Contraseña de Usuario

En este paso, aprenderás a configurar políticas de contraseña de usuario en un sistema RHEL. Las políticas de contraseña son cruciales para mejorar la seguridad al aplicar reglas sobre la complejidad de la contraseña, la caducidad y el bloqueo de la cuenta. Explorarás el archivo /etc/shadow y el comando chage.

Primero, entendamos el archivo /etc/shadow, que almacena información de contraseñas cifradas y parámetros de envejecimiento de contraseñas para las cuentas de usuario. Este archivo es altamente sensible y solo es legible por el usuario root.

Cada usuario tiene una entrada en el archivo /etc/shadow. Creemos un nuevo usuario policyuser y establezcamos su contraseña en labexrhel9 con fines de demostración.
```
sudo useradd policyuser
sudo passwd policyuser
```
Escribe labexrhel9 como la contraseña para policyuser.
Ahora, visualiza la entrada de policyuser en /etc/shadow.
```
sudo grep policyuser /etc/shadow
```
Verás una salida similar a esta:
```
policyuser:$6$randomsalt$encryptedhash:19780:0:99999:7:::
```
Desglosemos cada campo, separado por dos puntos:
- policyuser: Nombre de la cuenta de usuario.
- $6$randomsalt$encryptedhash: La contraseña cifrada del usuario.
  - $6: El algoritmo de hashing en uso para esta contraseña (SHA-512, el predeterminado de RHEL 9).
  - randomsalt: La sal utilizada para cifrar la contraseña; originalmente elegida al azar.
  - encryptedhash: El hash cifrado de la contraseña del usuario.
- 19780: Los días desde la época (1970-01-01 UTC) en que la contraseña se cambió por última vez. Este número variará según la fecha actual.
- 0: Los días mínimos desde el último cambio de contraseña antes de que el usuario pueda volver a cambiarla.
- 99999: Los días máximos sin un cambio de contraseña antes de que la contraseña caduque. Un campo vacío significa que la contraseña nunca caduca.
- 7: El número de días de antelación para avisar al usuario de que su contraseña caducará.
- (vacío): El número de días sin actividad, a partir del día en que la contraseña caducó, antes de que la cuenta se bloquee automáticamente.
- (vacío): El día en que la cuenta caduca en días desde la época. Un campo vacío significa que la cuenta nunca caduca.
- El último campo suele estar vacío y reservado para uso futuro.

A continuación, usarás el comando chage para modificar estos parámetros de envejecimiento de contraseñas. El comando chage te permite cambiar la información de caducidad de la contraseña del usuario.

Establezcamos una política de contraseña para policyuser con las siguientes reglas:
- Días mínimos entre cambios de contraseña: 7 días (-m 7)
- Días máximos entre cambios de contraseña: 90 días (-M 90)
- Período de advertencia antes de que la contraseña caduque: 14 días (-W 14)
- Período de inactividad después de que la contraseña caduque antes de que la cuenta se bloquee: 30 días (-I 30)
```
sudo chage -m 7 -M 90 -W 14 -I 30 policyuser
```

Para verificar estos cambios, puedes usar chage -l (list) para mostrar la información actual de envejecimiento de la contraseña para policyuser.

sudo chage -l policyuser

Deberías ver una salida que refleje la nueva política:

Last password change     : Mar 04, 2024
Password expires     : Jun 02, 2024
Password inactive     : Jul 02, 2024
Account expires      : never
Minimum number of days between password change  : 7
Maximum number of days between password change  : 90
Number of days of warning before password expires : 14

Nota: Las fechas variarán según cuándo realices el laboratorio.

También puedes establecer una fecha de caducidad absoluta de la cuenta usando la opción -E. Establezcamos que la cuenta de policyuser caduque en 30 días a partir de hoy. Primero, obtén la fecha de hoy y calcula la fecha dentro de 30 días.
```
EXPIRY_DATE=$(date -d "+30 days" +%Y-%m-%d)
echo "Account will expire on: $EXPIRY_DATE"
sudo chage -E $EXPIRY_DATE policyuser
```
Verifica la fecha de caducidad de la cuenta.
```
sudo chage -l policyuser | grep "Account expires"
```
La salida debería mostrar la fecha de caducidad calculada:
```
Account expires      : Apr 03, 2024
```
Nota: La fecha será aproximadamente 30 días a partir de la fecha actual de tu laboratorio.
Para eliminar la fecha de caducidad de la cuenta, puedes usar chage -E -1 policyuser.
```
sudo chage -E -1 policyuser
sudo chage -l policyuser | grep "Account expires"
```
La salida debería volver a never:
```
Account expires      : never
```

Finalmente, limpia la cuenta policyuser.

sudo userdel -r policyuser

Esto concluye tu práctica con la configuración de políticas de contraseña de usuario. Ahora entiendes cómo inspeccionar y modificar los parámetros de envejecimiento de contraseñas usando el archivo /etc/shadow y el comando chage.

Resumen

En este laboratorio, aprendiste conceptos fundamentales de la gestión de usuarios y grupos en Red Hat Enterprise Linux (RHEL). Comenzaste por comprender cómo los usuarios y grupos se asocian con archivos y procesos, y cómo inspeccionar la información de usuarios y grupos utilizando el comando id tanto para el usuario actual como para otros usuarios del sistema como root. También practicaste la identificación de la propiedad de archivos y directorios utilizando los comandos ls -l y ls -ld, respectivamente, lo cual es crucial para comprender los permisos y el control de acceso.

El laboratorio te guio además a través de la obtención de acceso de superusuario, la creación y modificación de cuentas de usuario locales, la gestión de cuentas de grupo locales y la configuración de políticas de contraseña de usuario. Estos pasos proporcionaron experiencia práctica en tareas esenciales de administración del sistema, lo que te permite gestionar eficazmente el acceso de usuarios y la seguridad en un sistema Linux.

Gestionar Usuarios y Grupos en Red Hat Enterprise Linux