# Module 1

## Fundamentos de Linux y Gestión de Usuarios

### 🎯 Learning Objectives

After completing this module, you will be able to:

- Navegar el sistema de archivos de Linux utilizando comandos esenciales de terminal
- Crear y administrar cuentas de usuario con diferentes niveles de privilegios
- Configurar grupos de usuarios y asignar membresías apropiadas
- Implementar permisos de archivos y directorios usando chmod y chown
- Utilizar sudo para ejecutar comandos con privilegios elevados de forma segura

Click Next → to begin.

## Introducción a Linux y su Arquitectura

## ¿Qué es Linux?

Linux es un sistema operativo de código abierto basado en UNIX que se ha convertido en el estándar para servidores empresariales, sistemas embebidos y plataformas cloud. A diferencia de sistemas propietarios como Windows, Linux ofrece transparencia total de su funcionamiento interno y libertad para modificarlo según necesidades específicas.

## Arquitectura del Sistema Operativo Linux

La arquitectura de Linux está organizada en capas claramente definidas:

- Kernel: El núcleo del sistema que gestiona hardware, memoria, procesos y recursos del sistema
- Shell: La interfaz de línea de comandos que interpreta instrucciones del usuario (bash, zsh, etc.)
- Utilidades del Sistema: Conjunto de programas fundamentales para gestionar archivos, procesos y configuraciones
- Aplicaciones de Usuario: Software instalado por usuarios y administradores

## Distribuciones Populares de Linux

Existen diferentes "sabores" o distribuciones de Linux, cada una diseñada para casos de uso específicos:

- Ubuntu/Debian: Ideales para principiantes y servidores empresariales
- Red Hat Enterprise Linux (RHEL)/CentOS/Rocky Linux: Enfocadas en entornos corporativos certificados
- Fedora: Plataforma de innovación con tecnologías de vanguardia
- Amazon Linux: Optimizada para servicios AWS

Cada distribución comparte el mismo kernel de Linux, pero difiere en el gestor de paquetes, configuraciones predeterminadas y herramientas administrativas incluidas.

Diagrama de capas de la arquitectura Linux mostrando kernel, shell, utilidades del sistema y aplicaciones de usuario

#### 💡 Key Takeaways

- Linux es un sistema operativo de código abierto basado en UNIX
- La arquitectura se divide en kernel, shell, utilidades y aplicaciones
- Diferentes distribuciones se especializan en casos de uso específicos
- El kernel gestiona recursos de hardware y procesos del sistema

## El Sistema de Archivos de Linux (FHS)

## Estructura Jerárquica del Sistema de Archivos

Linux organiza todos los archivos, dispositivos y recursos en una estructura de árbol único que comienza en la raíz representada por `/`. Este estándar, conocido como Filesystem Hierarchy Standard (FHS), garantiza consistencia entre diferentes distribuciones.

## Directorios Fundamentales

### Directorios del Sistema

- `/` (raíz): Punto de inicio de toda la jerarquía
- `/bin`: Comandos binarios esenciales disponibles para todos los usuarios
- `/sbin`: Comandos del sistema reservados para administración
- `/etc`: Archivos de configuración del sistema
- `/boot`: Archivos necesarios para arrancar el sistema
- `/lib`: Bibliotecas compartidas esenciales para el sistema

### Directorios de Datos

- `/home`: Directorios personales de usuarios regulares
- `/root`: Directorio personal del usuario root (administrador)
- `/var`: Datos variables como logs, bases de datos temporales
- `/tmp`: Archivos temporales eliminados al reiniciar

### Directorios de Dispositivos y Procesos

- `/dev`: Archivos de dispositivo que representan hardware
- `/proc`: Sistema de archivos virtual con información de procesos
- `/sys`: Información sobre dispositivos y drivers del kernel

## Conceptos Clave

En Linux, todo es un archivo: dispositivos, directorios, procesos e incluso configuraciones se representan como archivos. Esta abstracción unificada simplifica la administración del sistema mediante comandos estándar.

Árbol del sistema de archivos Linux mostrando la estructura jerárquica desde raíz (/) con directorios principales etiquetados

#### 💡 Key Takeaways

- FHS define una estructura estándar de directorios para todas las distribuciones Linux
- La raíz (/) es el punto de inicio de todo el sistema de archivos
- Los directorios se organizan por función: sistema, configuración, datos de usuario
- En Linux, todo se representa como un archivo para facilitar la gestión uniforme

## Navegación y Comandos Básicos de Terminal

## Comandos Esenciales de Navegación

La administración efectiva de Linux requiere dominar la línea de comandos. Estos comandos fundamentales permiten moverse por el sistema de archivos y gestionar contenido.

### Comandos de Ubicación y Movimiento

`pwd` (print working directory)

    $ pwd
    /home/usuario

Muestra la ruta completa del directorio actual donde te encuentras.

`ls` (list)

    $ ls -la
    total 32
    drwxr-xr-x 4 usuario grupo 4096 ene 15 10:30 .
    drwxr-xr-x 3 root    root  4096 ene 10 08:00 ..
    -rw-r--r-- 1 usuario grupo  220 ene 10 08:00 .bash_logout
    drwxr-xr-x 2 usuario grupo 4096 ene 12 14:20 documentos

Lista el contenido de directorios. Opciones útiles:

- `-l`: formato largo con permisos y detalles
- `-a`: incluye archivos ocultos (que inician con `.`)
- `-h`: tamaños legibles por humanos (KB, MB, GB)

`cd` (change directory)

    $ cd /etc/nginx        # Ruta absoluta desde raíz
    $ cd ../apache2        # Ruta relativa (subir un nivel)
    $ cd ~                 # Ir al directorio home
    $ cd -                 # Regresar al directorio anterior

### Comandos de Gestión de Archivos

`mkdir` (make directory)

    $ mkdir proyectos
    $ mkdir -p proyectos/web/frontend  # Crear estructura completa

`rm` (remove)

    $ rm archivo.txt              # Eliminar archivo
    $ rm -r directorio/           # Eliminar directorio recursivamente
    $ rm -rf directorio/          # Forzar eliminación sin confirmación

`cp` (copy) y `mv` (move)

    $ cp origen.txt destino.txt
    $ mv archivo.txt /tmp/        # Mover o renombrar

## Rutas Absolutas vs. Relativas

- Ruta absoluta: Comienza desde raíz `/home/usuario/documentos`
- Ruta relativa: Relativa a ubicación actual `../compartido/datos`

Ilustración de navegación por terminal mostrando comandos comunes y su efecto en la estructura de directorios

#### 💡 Key Takeaways

- pwd muestra el directorio actual, ls lista contenido, cd cambia ubicación
- Las opciones modifican el comportamiento de comandos (ls -la, rm -rf)
- mkdir crea directorios, rm elimina archivos y directorios
- Las rutas absolutas inician con /, las relativas son desde ubicación actual

## Gestión de Usuarios en Linux

## Cuentas de Usuario en Linux

Cada persona o servicio que accede al sistema necesita una cuenta de usuario. Linux distingue entre usuarios regulares (identificados por UID ≥ 1000) y el superusuario root (UID 0) que tiene control absoluto del sistema.

## Archivos de Configuración de Usuarios

- `/etc/passwd`: Información básica de cuentas (nombre, UID, directorio home, shell)
- `/etc/shadow`: Contraseñas cifradas y políticas de expiración (solo legible por root)
- `/etc/group`: Definición de grupos del sistema

## Comandos de Gestión de Usuarios

### Crear Usuarios con useradd

    # Crear usuario básico
    $ sudo useradd -m -s /bin/bash admin_jose

    # Opciones importantes:
    # -m: crear directorio home (/home/admin_jose)
    # -s: especificar shell de inicio de sesión
    # -c: comentario o nombre completo
    # -e: fecha de expiración de cuenta

### Establecer Contraseñas con passwd

    $ sudo passwd admin_jose
    Nueva contraseña:
    Vuelva a escribir la nueva contraseña:
    passwd: contraseña actualizada correctamente

### Modificar Usuarios con usermod

    # Cambiar shell de usuario
    $ sudo usermod -s /bin/zsh admin_jose

    # Cambiar directorio home
    $ sudo usermod -d /opt/admin_jose -m admin_jose

    # Agregar a grupos adicionales (sin eliminar grupos existentes)
    $ sudo usermod -aG developers,sudo admin_jose

    # Bloquear cuenta temporalmente
    $ sudo usermod -L admin_jose

    # Desbloquear cuenta
    $ sudo usermod -U admin_jose

### Eliminar Usuarios con userdel

    # Eliminar usuario manteniendo archivos home
    $ sudo userdel admin_jose

    # Eliminar usuario Y su directorio home
    $ sudo userdel -r admin_jose

## Buenas Prácticas

- Nunca usar root para tareas cotidianas; crear usuarios administrativos con privilegios sudo
- Aplicar políticas de contraseñas robustas mediante PAM
- Asignar shells no interactivas (`/sbin/nologin`) a cuentas de servicio
- Auditar regularmente cuentas inactivas con `lastlog`

Diagrama de flujo mostrando el proceso de creación y gestión de cuentas de usuario desde useradd hasta userdel

#### 💡 Key Takeaways

- useradd crea nuevas cuentas, passwd establece contraseñas
- usermod modifica propiedades de usuarios existentes
- userdel elimina cuentas; -r también elimina archivos home
- Root (UID 0) tiene control total; usuarios regulares tienen UID ≥ 1000
- La información de usuarios se almacena en /etc/passwd y /etc/shadow

## Gestión de Grupos en Linux

## ¿Por Qué Usar Grupos?

Los grupos permiten organizar usuarios y simplificar la gestión de permisos. En lugar de asignar permisos individualmente a cada usuario, se asignan al grupo y todos sus miembros heredan esos permisos automáticamente.

## Tipos de Grupos

- Grupo primario: Cada usuario tiene un grupo principal (definido en `/etc/passwd`)
- Grupos secundarios: Membresías adicionales para compartir recursos específicos

## Comandos de Gestión de Grupos

### Crear Grupos con groupadd

    # Crear grupo básico
    $ sudo groupadd developers

    # Crear grupo con GID específico
    $ sudo groupadd -g 5000 contractors

### Modificar Grupos con groupmod

    # Cambiar nombre de grupo
    $ sudo groupmod -n programadores developers

    # Cambiar GID
    $ sudo groupmod -g 6000 programadores

### Eliminar Grupos con groupdel

    $ sudo groupdel contractors

Nota: No se puede eliminar un grupo que sea el grupo primario de algún usuario activo.

## Gestión de Membresías

### Agregar Usuarios a Grupos

    # INCORRECTO - reemplaza todos los grupos secundarios
    $ sudo usermod -G developers dev_maria

    # CORRECTO - agrega sin eliminar grupos existentes
    $ sudo usermod -aG developers dev_maria

    # Agregar a múltiples grupos simultáneamente
    $ sudo usermod -aG developers,administrators,docker dev_maria

### Verificar Membresías

    # Ver grupos del usuario actual
    $ groups
    dev_maria developers sudo docker

    # Ver grupos de otro usuario
    $ groups dev_maria
    dev_maria : dev_maria developers administrators docker

    # Información detallada de usuario
    $ id dev_maria
    uid=1001(dev_maria) gid=1001(dev_maria) grupos=1001(dev_maria),1002(developers),1003(administrators),999(docker)

## Estrategia de Grupos en Organizaciones

Ejemplo de estructura típica:

- developers: Acceso a repositorios de código y herramientas de desarrollo
- administrators: Privilegios sudo y acceso a configuraciones del sistema
- dbadmins: Acceso a bases de datos y scripts de respaldo
- webteam: Permisos sobre directorios web y configuración de servidores HTTP

Diagrama conceptual mostrando usuarios organizados en grupos con permisos compartidos

#### 💡 Key Takeaways

- Los grupos simplifican la gestión de permisos compartidos entre múltiples usuarios
- groupadd crea grupos, groupmod los modifica, groupdel los elimina
- usermod -aG agrega usuarios a grupos sin eliminar membresías existentes
- groups e id muestran las membresías de grupo de usuarios
- Cada usuario tiene un grupo primario y puede tener múltiples grupos secundarios

## El Modelo de Permisos de Linux

## Fundamentos del Sistema de Permisos

Linux protege archivos y directorios mediante un sistema de permisos que controla quién puede hacer qué con cada recurso. Este modelo tiene tres componentes clave:

### Clases de Usuarios

1. Propietario (user/u): El usuario dueño del archivo
2. Grupo (group/g): Usuarios que pertenecen al grupo asignado al archivo
3. Otros (others/o): Todos los demás usuarios del sistema

### Tipos de Permisos

Para archivos regulares:

- r (read/lectura): Leer contenido del archivo
- w (write/escritura): Modificar o eliminar el archivo
- x (execute/ejecución): Ejecutar el archivo como programa

Para directorios:

- r: Listar contenido del directorio (ls)
- w: Crear, eliminar o renombrar archivos dentro
- x: Acceder al directorio (cd) y acceder a sus archivos

## Visualizar Permisos con ls -l

    $ ls -l proyecto.sh
    -rwxr-xr-- 1 admin_jose developers 2048 ene 15 10:30 proyecto.sh
    │││││││││
    │││││││└┴── Permisos para otros (r--, solo lectura)
    ││││││└──── Permisos para grupo (r-x, lectura + ejecución)
    │││└┴┴───── Permisos para propietario (rwx, todos)
    ││└───────── Número de enlaces
    │└────────── Tipo: - (archivo regular), d (directorio), l (enlace)
    └─────────── Primer carácter indica el tipo

## Notación Simbólica vs. Octal

### Notación Simbólica

Representa permisos con letras:

- `rwxr-xr--` = propietario (rwx), grupo (r-x), otros (r--)

### Notación Octal (Numérica)

Cada permiso tiene un valor:

- r (read) = 4
- w (write) = 2
- x (execute) = 1

Se suman para cada clase:

- `7` (4+2+1) = rwx
- `6` (4+2) = rw-
- `5` (4+1) = r-x
- `4` = r--
- `0` = ---

Ejemplos:

- `755` = rwxr-xr-x (común para scripts)
- `644` = rw-r--r-- (común para archivos de datos)
- `600` = rw------- (archivos privados sensibles)
- `777` = rwxrwxrwx (⚠️ inseguro, evitar en producción)

Tabla de referencia visual mostrando la conversión entre notación simbólica y octal de permisos Linux

#### 💡 Key Takeaways

- Los permisos se dividen en propietario, grupo y otros
- r (lectura), w (escritura), x (ejecución) controlan el acceso
- Los permisos de directorio controlan el acceso a su contenido
- Notación simbólica usa letras (rwx), octal usa números (755)
- ls -l muestra permisos, propietario, grupo y otros detalles

## Modificación de Permisos y Propiedad

## Cambiar Permisos con chmod

### Modo Simbólico

Sintaxis: `chmod [quien][operación][permisos] archivo`

Quién:

- `u` = user (propietario)
- `g` = group (grupo)
- `o` = others (otros)
- `a` = all (todos)

Operación:

- `+` = agregar permiso
- `-` = quitar permiso
- `=` = establecer exactamente estos permisos

    # Agregar ejecución para propietario
    $ chmod u+x script.sh

    # Quitar escritura para grupo y otros
    $ chmod go-w documento.txt

    # Establecer lectura/ejecución para todos
    $ chmod a=rx archivo.sh

    # Múltiples cambios simultáneos
    $ chmod u+x,g+w,o-r datos.txt

### Modo Octal (Numérico)

    # Permisos completos para propietario, lectura/ejecución para otros
    $ chmod 755 aplicacion.sh

    # Solo propietario puede leer/escribir
    $ chmod 600 clave_privada.pem

    # Típico para archivos web
    $ chmod 644 index.html

    # Aplicar recursivamente a directorios
    $ chmod -R 755 /var/www/html/

## Cambiar Propietario y Grupo con chown

    # Cambiar solo propietario
    $ sudo chown admin_jose proyecto.sh

    # Cambiar propietario y grupo
    $ sudo chown admin_jose:developers proyecto.sh

    # Cambiar solo grupo (también puede usarse chgrp)
    $ sudo chown :developers datos/

    # Recursivo para directorios completos
    $ sudo chown -R admin_jose:developers /proyectos/web/

## Casos de Uso Comunes

### Directorios Compartidos de Equipo

    # Crear directorio para equipo de desarrollo
    $ sudo mkdir /proyectos/desarrollo
    $ sudo chown :developers /proyectos/desarrollo
    $ sudo chmod 775 /proyectos/desarrollo
    # Ahora todos en grupo developers pueden crear archivos aquí

### Archivos de Configuración Sensibles

    # Proteger archivos de configuración con credenciales
    $ sudo chmod 600 /etc/app/database.conf
    $ sudo chown app_user:app_group /etc/app/database.conf

### Scripts Ejecutables

    # Hacer ejecutable un script de respaldo
    $ chmod 750 /usr/local/bin/backup.sh
    $ sudo chown root:administrators /usr/local/bin/backup.sh

## Precauciones de Seguridad

⚠️ Evitar permisos 777: Permite a cualquier usuario modificar o ejecutar ⚠️ Cuidado con chmod -R: Puede romper aplicaciones si se aplica incorrectamente ✓ Principio de privilegio mínimo: Otorgar solo los permisos necesarios

Diagrama de flujo de decisión para elegir permisos apropiados según tipo de archivo y contexto de seguridad

#### 💡 Key Takeaways

- chmod modifica permisos usando notación simbólica (u+x) u octal (755)
- chown cambia propietario y grupo de archivos y directorios
- La opción -R aplica cambios recursivamente a todos los contenidos
- Permisos típicos: 755 (ejecutables), 644 (archivos), 600 (privados)
- Aplicar principio de privilegio mínimo para mantener seguridad

## Sudo y Elevación de Privilegios

## ¿Qué es sudo?

sudo ("superuser do") permite a usuarios autorizados ejecutar comandos con privilegios de root sin conocer la contraseña de root. Esto mejora la seguridad y proporciona auditoría de acciones administrativas.

## Ventajas de sudo sobre root directo

- Auditoría: Todos los comandos sudo se registran en `/var/log/auth.log` o `/var/log/secure`
- Responsabilidad: Cada usuario usa su propia contraseña, identificando quién ejecutó qué
- Granularidad: Se pueden otorgar permisos específicos sin acceso root completo
- Seguridad: Reduce riesgo de ejecutar malware o errores como root

## Uso Básico de sudo

    # Ejecutar comando único con privilegios elevados
    $ sudo apt update

    # Abrir shell como root (evitar cuando sea posible)
    $ sudo -i

    # Ejecutar comando como otro usuario
    $ sudo -u dev_maria cat /home/dev_maria/proyecto.txt

    # Editar archivos del sistema de forma segura
    $ sudo nano /etc/hosts
    # O con visudo para sudoers:
    $ sudo visudo

## Configuración: Archivo /etc/sudoers

⚠️ Nunca editar con editor normal: Siempre usar `sudo visudo` que valida sintaxis antes de guardar.

### Sintaxis Básica

    # Usuario    Hosts=(Ejecutar_como) Comandos
    admin_jose   ALL=(ALL:ALL) ALL

### Ejemplos de Configuración

    # Permitir a admin_jose ejecutar cualquier comando
    admin_jose ALL=(ALL:ALL) ALL

    # Permitir grupo administrators usar todos los comandos
    %administrators ALL=(ALL:ALL) ALL

    # dev_maria puede reiniciar servicios sin contraseña
    dev_maria ALL=(ALL) NOPASSWD: /usr/bin/systemctl restart *

    # Grupo webteam puede editar configuración web específica
    %webteam ALL=(ALL) /usr/bin/nano /etc/nginx/*, /usr/bin/systemctl reload nginx

## Verificar Privilegios sudo

    # Ver qué comandos sudo puede ejecutar tu usuario
    $ sudo -l
    Usuario admin_jose puede ejecutar los siguientes comandos:
        (ALL : ALL) ALL

    # Listar privilegios de otro usuario
    $ sudo -l -U dev_maria

## Buenas Prácticas

✓ Usar sudo para tareas administrativas individuales, no mantener sesión root activa ✓ Configurar timeout de sudo (por defecto 15 minutos de caché de credenciales) ✓ Limitar comandos específicos cuando sea posible en lugar de acceso completo ✓ Auditar logs regularmente: `sudo grep sudo /var/log/auth.log` ✓ Usar grupos para gestionar privilegios de múltiples usuarios

## Seguridad

⚠️ Tener acceso `sudo ALL=(ALL:ALL) ALL` es equivalente a ser root ⚠️ NOPASSWD es conveniente pero reduce seguridad; usar solo para automatización específica ⚠️ Validar que usuarios no puedan editar archivos que otorguen más privilegios (como /etc/sudoers)

Comparación visual entre acceso root directo y uso de sudo mostrando beneficios de auditoría y seguridad

#### 💡 Key Takeaways

- sudo permite ejecutar comandos como root usando contraseña propia
- Todas las acciones sudo se registran para auditoría y responsabilidad
- El archivo /etc/sudoers controla quién puede usar sudo y qué comandos
- Siempre editar sudoers con visudo para validar sintaxis
- Usar sudo para comandos individuales es más seguro que sesión root permanente

## 🔬 Gestión de Usuarios, Grupos y Permisos en Linux

Objective: Crear y administrar cuentas de usuario, configurar grupos, implementar permisos de archivos y utilizar sudo para ejecutar comandos con privilegios elevados

⏱ Estimated time: 45 minutes💻 Platform: Ubuntu 20.04 o superior con acceso a terminal
Prerequisites:

- Sistema Ubuntu instalado o máquina virtual
- Acceso a una cuenta con privilegios sudo
- Terminal o consola disponible

### Procedures

1 Verificar el usuario actual y explorar la estructura del sistema de archivos

Primero, identifica con qué usuario estás trabajando y explora tu ubicación actual en el sistema de archivos.

Ejecuta los siguientes comandos:

    whoami
    pwd
    ls -la /home

El comando `whoami` muestra tu nombre de usuario actual, `pwd` muestra el directorio de trabajo actual, y `ls -la /home` lista todos los directorios de usuarios en el sistema.

✓ Expected Output

    ```
    $ whoami
    tu_usuario
    $ pwd
    /home/tu_usuario
    $ ls -la /home
    total 12
    drwxr-xr-x  3 root        root        4096 ene 15 10:30 .
    drwxr-xr-x 20 root        root        4096 ene 15 10:25 ..
    drwxr-xr-x  5 tu_usuario  tu_usuario  4096 ene 15 11:45 tu_usuario
    ```

🔍 Verify: Confirma que puedes ver tu nombre de usuario y que estás en tu directorio home (/home/tu_usuario)
2 Crear un nuevo usuario llamado 'developer'

Crea una cuenta de usuario nueva utilizando el comando `useradd`. Este comando requiere privilegios de administrador, por lo que usarás `sudo`.

    sudo useradd -m -s /bin/bash -c "Usuario Desarrollador" developer

Explicación de las opciones:

- `-m`: Crea el directorio home del usuario
- `-s /bin/bash`: Establece bash como shell predeterminado
- `-c "Usuario Desarrollador"`: Añade un comentario descriptivo
- `developer`: Nombre del usuario

Verifica que el usuario fue creado:

    grep developer /etc/passwd
    ls -la /home/developer

✓ Expected Output

    ```
    $ sudo useradd -m -s /bin/bash -c "Usuario Desarrollador" developer
    [sudo] contraseña para tu_usuario:
    $ grep developer /etc/passwd
    developer:x:1001:1001:Usuario Desarrollador:/home/developer:/bin/bash
    $ ls -la /home/developer
    total 20
    drwxr-xr-x 2 developer developer 4096 ene 15 12:00 .
    drwxr-xr-x 4 root      root      4096 ene 15 12:00 ..
    -rw-r--r-- 1 developer developer  220 ene 15 12:00 .bash_logout
    -rw-r--r-- 1 developer developer 3771 ene 15 12:00 .bashrc
    -rw-r--r-- 1 developer developer  807 ene 15 12:00 .profile
    ```

🔍 Verify: El archivo /etc/passwd debe contener una entrada para 'developer' y el directorio /home/developer debe existir con archivos de configuración predeterminados
3 Establecer una contraseña para el usuario 'developer'

Un usuario recién creado no puede iniciar sesión hasta que tenga una contraseña. Establece una contraseña segura:

    sudo passwd developer

Cuando se te solicite, ingresa una contraseña (por ejemplo: `Dev2024!Secure`). Deberás ingresarla dos veces para confirmarla.

Nota de seguridad: En un entorno de producción, las contraseñas deben cumplir con políticas de complejidad y nunca deben compartirse.

✓ Expected Output

    ```
    $ sudo passwd developer
    Nueva contraseña:
    Vuelva a escribir la nueva contraseña:
    passwd: contraseña actualizada correctamente
    ```

🔍 Verify: El mensaje debe confirmar que la contraseña se actualizó correctamente
4 Crear dos grupos adicionales: 'webteam' y 'dbteam'

Los grupos permiten organizar usuarios y asignar permisos colectivos. Crea dos grupos que representan equipos diferentes:

    sudo groupadd webteam
    sudo groupadd dbteam

Verifica que los grupos fueron creados:

    grep -E 'webteam|dbteam' /etc/group

El archivo `/etc/group` almacena información sobre todos los grupos del sistema.

✓ Expected Output

    ```
    $ sudo groupadd webteam
    $ sudo groupadd dbteam
    $ grep -E 'webteam|dbteam' /etc/group
    webteam:x:1002:
    dbteam:x:1003:
    ```

🔍 Verify: Ambos grupos deben aparecer en /etc/group con sus respectivos identificadores de grupo (GID)
5 Agregar el usuario 'developer' a ambos grupos como miembro secundario

Un usuario puede pertenecer a múltiples grupos. Agrega 'developer' a los grupos 'webteam' y 'dbteam':

    sudo usermod -aG webteam developer
    sudo usermod -aG dbteam developer

La opción `-aG` significa "append to Group" (agregar al grupo), manteniendo las membresías existentes.

Verifica las membresías de grupo:

    groups developer
    id developer

✓ Expected Output

    ```
    $ sudo usermod -aG webteam developer
    $ sudo usermod -aG dbteam developer
    $ groups developer
    developer : developer webteam dbteam
    $ id developer
    uid=1001(developer) gid=1001(developer) grupos=1001(developer),1002(webteam),1003(dbteam)
    ```

🔍 Verify: El comando 'groups developer' debe mostrar developer, webteam y dbteam. El comando 'id' debe confirmar las membresías con sus GID
6 Crear una estructura de directorios para proyectos compartidos

Crea directorios que serán utilizados por los equipos para almacenar archivos de proyectos:

    sudo mkdir -p /opt/proyectos/web
    sudo mkdir -p /opt/proyectos/database
    sudo mkdir -p /opt/proyectos/compartido

La opción `-p` crea directorios padre si no existen.

Verifica la estructura creada:

    ls -la /opt/proyectos/
    tree /opt/proyectos/

Nota: Si `tree` no está instalado, usa `find /opt/proyectos/ -type d`

✓ Expected Output

    ```
    $ sudo mkdir -p /opt/proyectos/web
    $ sudo mkdir -p /opt/proyectos/database
    $ sudo mkdir -p /opt/proyectos/compartido
    $ ls -la /opt/proyectos/
    total 20
    drwxr-xr-x 5 root root 4096 ene 15 12:15 .
    drwxr-xr-x 4 root root 4096 ene 15 12:15 ..
    drwxr-xr-x 2 root root 4096 ene 15 12:15 compartido
    drwxr-xr-x 2 root root 4096 ene 15 12:15 database
    drwxr-xr-x 2 root root 4096 ene 15 12:15 web
    ```

🔍 Verify: Deben existir tres subdirectorios dentro de /opt/proyectos: web, database y compartido
7 Configurar propiedad y permisos para el directorio 'web'

Asigna el directorio web al grupo webteam y configura permisos apropiados:

    sudo chown root:webteam /opt/proyectos/web
    sudo chmod 2775 /opt/proyectos/web

Explicación de los permisos `2775`:

- `2`: Bit setgid - archivos creados heredarán el grupo del directorio
- `7`: Propietario (root) tiene rwx (lectura, escritura, ejecución)
- `7`: Grupo (webteam) tiene rwx
- `5`: Otros tienen rx (lectura, ejecución) pero no escritura

Verifica los permisos:

    ls -ld /opt/proyectos/web

✓ Expected Output

    ```
    $ sudo chown root:webteam /opt/proyectos/web
    $ sudo chmod 2775 /opt/proyectos/web
    $ ls -ld /opt/proyectos/web
    drwxrwsr-x 2 root webteam 4096 ene 15 12:15 /opt/proyectos/web
    ```

🔍 Verify: El directorio debe mostrar 'drwxrwsr-x' (nota la 's' en los permisos de grupo, indicando setgid) y pertenecer a root:webteam
8 Configurar propiedad y permisos para el directorio 'database'

De manera similar, configura el directorio database para el grupo dbteam:

    sudo chown root:dbteam /opt/proyectos/database
    sudo chmod 2770 /opt/proyectos/database

En este caso, usamos `2770` en lugar de `2775`:

- `2`: Bit setgid
- `7`: Propietario tiene rwx
- `7`: Grupo (dbteam) tiene rwx
- `0`: Otros NO tienen ningún permiso (más restrictivo)

Verifica los permisos:

    ls -ld /opt/proyectos/database

✓ Expected Output

    ```
    $ sudo chown root:dbteam /opt/proyectos/database
    $ sudo chmod 2770 /opt/proyectos/database
    $ ls -ld /opt/proyectos/database
    drwxrws--- 2 root dbteam 4096 ene 15 12:15 /opt/proyectos/database
    ```

🔍 Verify: El directorio debe mostrar 'drwxrws---' (sin permisos para 'otros') y pertenecer a root:dbteam
9 Probar los permisos creando archivos como usuario 'developer'

Cambia al usuario 'developer' y prueba crear archivos en los directorios configurados:

    sudo su - developer

Una vez como developer, intenta crear archivos:

    touch /opt/proyectos/web/index.html
    touch /opt/proyectos/database/schema.sql
    echo "Proyecto Web" > /opt/proyectos/web/index.html

Verifica la propiedad de los archivos creados:

    ls -l /opt/proyectos/web/index.html
    ls -l /opt/proyectos/database/schema.sql

Cuando termines, sal de la sesión de developer:

    exit

✓ Expected Output

    ```
    $ sudo su - developer
    developer@ubuntu:~$ touch /opt/proyectos/web/index.html
    developer@ubuntu:~$ touch /opt/proyectos/database/schema.sql
    developer@ubuntu:~$ echo "Proyecto Web" > /opt/proyectos/web/index.html
    developer@ubuntu:~$ ls -l /opt/proyectos/web/index.html
    -rw-r--r-- 1 developer webteam 13 ene 15 12:20 /opt/proyectos/web/index.html
    developer@ubuntu:~$ ls -l /opt/proyectos/database/schema.sql
    -rw-r--r-- 1 developer dbteam 0 ene 15 12:20 /opt/proyectos/database/schema.sql
    developer@ubuntu:~$ exit
    ```

🔍 Verify: Los archivos deben crearse exitosamente. Nota que aunque developer es el propietario, el grupo heredado es webteam y dbteam respectivamente debido al bit setgid
10 Crear un archivo de script y configurar permisos de ejecución

Crea un script de shell simple y configura los permisos para hacerlo ejecutable:

    cat > /tmp/backup.sh << 'EOF'
    #!/bin/bash
    # Script de respaldo simple
    echo "Iniciando respaldo..."
    echo "Fecha: $(date)"
    echo "Usuario: $(whoami)"
    echo "Respaldo completado"
    EOF

Verifica los permisos actuales:

    ls -l /tmp/backup.sh

Haz el archivo ejecutable usando notación simbólica:

    chmod u+x /tmp/backup.sh

Verifica los nuevos permisos:

    ls -l /tmp/backup.sh

Ejecuta el script:

    /tmp/backup.sh

✓ Expected Output

    ```
    $ ls -l /tmp/backup.sh
    -rw-rw-r-- 1 tu_usuario tu_usuario 145 ene 15 12:25 /tmp/backup.sh
    $ chmod u+x /tmp/backup.sh
    $ ls -l /tmp/backup.sh
    -rwxrw-r-- 1 tu_usuario tu_usuario 145 ene 15 12:25 /tmp/backup.sh
    $ /tmp/backup.sh
    Iniciando respaldo...
    Fecha: lun ene 15 12:25:33 UTC 2024
    Usuario: tu_usuario
    Respaldo completado
    ```

🔍 Verify: Los permisos deben cambiar de rw-rw-r-- a rwxrw-r-- (nota la 'x' en permisos de usuario). El script debe ejecutarse exitosamente
11 Practicar cambio de permisos con notación octal

Crea un archivo de configuración y practica configurar permisos usando notación numérica:

    touch /tmp/config.conf
    chmod 644 /tmp/config.conf
    ls -l /tmp/config.conf

Explicación de 644:

- 6 (110 en binario) = rw- para propietario
- 4 (100 en binario) = r-- para grupo
- 4 (100 en binario) = r-- para otros

Ahora cambia a permisos más restrictivos:

    chmod 600 /tmp/config.conf
    ls -l /tmp/config.conf

Esto hace que solo el propietario pueda leer y escribir el archivo.

✓ Expected Output

    ```
    $ touch /tmp/config.conf
    $ chmod 644 /tmp/config.conf
    $ ls -l /tmp/config.conf
    -rw-r--r-- 1 tu_usuario tu_usuario 0 ene 15 12:30 /tmp/config.conf
    $ chmod 600 /tmp/config.conf
    $ ls -l /tmp/config.conf
    -rw------- 1 tu_usuario tu_usuario 0 ene 15 12:30 /tmp/config.conf
    ```

🔍 Verify: El archivo debe mostrar primero -rw-r--r-- y luego -rw------- después del segundo chmod
12 Configurar privilegios sudo para el usuario 'developer'

Permite que el usuario 'developer' ejecute comandos específicos con sudo. Abre el archivo sudoers de forma segura:

    sudo visudo

Agrega la siguiente línea al final del archivo (usa las flechas para navegar y presiona 'i' para insertar en vim):

    developer ALL=(ALL) /usr/bin/systemctl status, /usr/bin/journalctl

Guarda y sal:

- Presiona ESC
- Escribe `:wq`
- Presiona ENTER

Esta configuración permite a developer ejecutar solo `systemctl status` y `journalctl` con sudo, no cualquier comando.

✓ Expected Output

    ```
    $ sudo visudo
    [Se abre el editor]
    # Al guardar, si no hay errores de sintaxis:
    visudo: archivo /etc/sudoers.tmp sin modificar
    ```

🔍 Verify: El archivo debe guardarse sin errores. visudo valida la sintaxis antes de guardar para prevenir configuraciones incorrectas que podrían bloquear el acceso sudo
13 Probar los privilegios sudo del usuario 'developer'

Cambia al usuario developer y prueba ejecutar comandos con sudo:

    sudo su - developer

Como developer, intenta ejecutar un comando permitido:

    sudo systemctl status ssh

Ingresa la contraseña de developer cuando se solicite.

Ahora intenta ejecutar un comando NO permitido:

    sudo apt update

Este comando debe ser rechazado.

Sal de la sesión de developer:

    exit

✓ Expected Output

    ```
    $ sudo su - developer
    developer@ubuntu:~$ sudo systemctl status ssh
    [sudo] contraseña para developer:
    ● ssh.service - OpenBSD Secure Shell server
       Loaded: loaded (/lib/systemd/system/ssh.service; enabled)
       Active: active (running) since...
    ...
    developer@ubuntu:~$ sudo apt update
    Lo sentimos, el usuario developer no puede ejecutar '/usr/bin/apt update' como root en ubuntu.
    developer@ubuntu:~$ exit
    ```

🔍 Verify: El comando systemctl status debe ejecutarse exitosamente. El comando apt update debe ser rechazado con un mensaje indicando que developer no tiene permiso
14 Verificar y documentar la configuración final

Ejecuta los siguientes comandos para generar un resumen de toda la configuración realizada:

    echo "=== USUARIOS CREADOS ==="
    grep developer /etc/passwd

    echo ""
    echo "=== GRUPOS CREADOS ==="
    grep -E 'webteam|dbteam' /etc/group

    echo ""
    echo "=== MEMBRESÍAS DE GRUPO ==="
    id developer

    echo ""
    echo "=== ESTRUCTURA DE DIRECTORIOS ==="
    ls -lR /opt/proyectos/

    echo ""
    echo "=== PRIVILEGIOS SUDO ==="
    sudo grep developer /etc/sudoers

Guarda esta salida para tu referencia futura.

✓ Expected Output

    ```
    === USUARIOS CREADOS ===
    developer:x:1001:1001:Usuario Desarrollador:/home/developer:/bin/bash

    === GRUPOS CREADOS ===
    webteam:x:1002:developer
    dbteam:x:1003:developer

    === MEMBRESÍAS DE GRUPO ===
    uid=1001(developer) gid=1001(developer) grupos=1001(developer),1002(webteam),1003(dbteam)

    === ESTRUCTURA DE DIRECTORIOS ===
    /opt/proyectos/:
    total 12
    drwxr-xr-x 2 root root    4096 ene 15 12:15 compartido
    drwxrws--- 2 root dbteam  4096 ene 15 12:20 database
    drwxrwsr-x 2 root webteam 4096 ene 15 12:20 web

    /opt/proyectos/compartido:
    total 0

    /opt/proyectos/database:
    total 0
    -rw-r--r-- 1 developer dbteam 0 ene 15 12:20 schema.sql

    /opt/proyectos/web:
    total 4
    -rw-r--r-- 1 developer webteam 13 ene 15 12:20 index.html

    === PRIVILEGIOS SUDO ===
    developer ALL=(ALL) /usr/bin/systemctl status, /usr/bin/journalctl
    ```

🔍 Verify: Verifica que toda la configuración coincida con lo realizado durante el laboratorio

### ⚠️ Troubleshooting

Error 'useradd: usuario 'developer' ya existe' al intentar crear el usuario

El usuario ya existe en el sistema. Puedes eliminarlo primero con `sudo userdel -r developer` (esto eliminará el usuario y su directorio home) y luego volver a crearlo, o simplemente continuar con el siguiente paso si ya existe.

Permiso denegado al intentar crear archivos en /opt/proyectos/web o /opt/proyectos/database como developer

Verifica que: 1) El usuario developer pertenezca a los grupos correctos ejecutando `groups developer`. 2) Los permisos del directorio sean correctos con `ls -ld /opt/proyectos/web`. 3) Hayas iniciado una sesión nueva como developer después de agregarlo a los grupos (usa `sudo su - developer`, no solo `su developer`). Los cambios de grupo requieren una nueva sesión de login.

Error 'visudo: /etc/sudoers.tmp: syntax error' al guardar el archivo sudoers

No guardes el archivo todavía. Revisa la línea que agregaste para developer. Asegúrate de que no haya espacios extra, que los comandos tengan rutas completas (/usr/bin/systemctl, no solo systemctl), y que la sintaxis sea exactamente: `developer ALL=(ALL) /usr/bin/systemctl status, /usr/bin/journalctl`. Si el error persiste, presiona 'e' para editar nuevamente en lugar de forzar el guardado.

El bit setgid (s) no aparece en los permisos del directorio después de ejecutar chmod 2775

Verifica que estés usando chmod con el número correcto. El primer dígito (2) establece el bit setgid. Ejecuta `chmod 2775 /opt/proyectos/web` nuevamente. Si aún no aparece, verifica que el sistema de archivos soporte bits especiales (algunos sistemas de archivos montados con opciones específicas pueden no soportarlos). Confirma con `ls -ld /opt/proyectos/web` que veas una 's' en lugar de 'x' en los permisos de grupo.

Al ejecutar /tmp/backup.sh aparece 'permission denied' incluso después de chmod u+x

Verifica varias cosas: 1) Que el directorio /tmp permita ejecución con `mount | grep /tmp` (algunos sistemas montan /tmp con noexec). 2) Que hayas usado la ruta completa `/tmp/backup.sh` o estés en el directorio correcto. 3) Que el archivo tenga el shebang correcto (#!/bin/bash) en la primera línea. 4) Verifica los permisos con `ls -l /tmp/backup.sh` - debe mostrar 'x' para el usuario. Si /tmp está montado con noexec, copia el script a tu directorio home y ejecútalo desde allí.

### 🏆 Implementar un Sistema de Gestión de Proyectos Multiusuario

Apply what you learned — complete this task without step-by-step guidance.

Ahora que dominas los conceptos básicos de gestión de usuarios y permisos, amplía el laboratorio con los siguientes requisitos:

## Escenario

Tu empresa necesita un sistema más completo para gestionar proyectos con tres departamentos: desarrollo (dev), operaciones (ops) y auditoría (audit).

## Requisitos

1. Crear usuarios adicionales:

   - Crea dos usuarios más: `devuser1` y `opsuser1`
   - Ambos deben tener directorios home y bash como shell
   - Establece contraseñas seguras para ambos

2. Estructura de grupos:

   - Crea grupos: `devgroup`, `opsgroup`, `auditgroup`
   - Asigna `developer` y `devuser1` al grupo `devgroup`
   - Asigna `opsuser1` al grupo `opsgroup`
   - Todos los usuarios deben pertenecer también a `auditgroup`

3. Estructura de directorios y permisos:

   - Crea `/opt/company/dev` (solo devgroup puede leer/escribir/ejecutar, auditgroup solo puede leer)
   - Crea `/opt/company/ops` (solo opsgroup puede leer/escribir/ejecutar, auditgroup solo puede leer)
   - Crea `/opt/company/shared` (todos los grupos pueden leer/escribir/ejecutar)
   - Todos los directorios deben tener setgid habilitado

4. Scripts y automatización:

   - Crea un script `/usr/local/bin/project-info.sh` que muestre:
     - Usuario actual
     - Grupos a los que pertenece
     - Fecha y hora
     - Lista de archivos en /opt/company que el usuario puede leer
   - El script debe ser ejecutable por todos los usuarios

5. Configuración de sudo:

   - Los usuarios de devgroup deben poder reiniciar solo el servicio nginx (si está instalado) o ssh
   - Los usuarios de opsgroup deben poder ejecutar cualquier comando systemctl
   - Nadie debe necesitar contraseña para ejecutar el script project-info.sh con sudo

6. Verificación y documentación:

   - Crea un archivo README.md en /opt/company que documente:
     - Qué usuarios tienen acceso a qué directorios
     - Qué comandos sudo puede ejecutar cada grupo
     - Cómo usar el script project-info.sh
   - Configura los permisos para que todos puedan leer el README pero solo root pueda modificarlo

## Pruebas

Verifica tu implementación probando:

- Cambiar a cada usuario e intentar acceder a diferentes directorios
- Crear archivos en directorios compartidos y verificar que el grupo heredado sea correcto
- Ejecutar comandos sudo según los permisos asignados
- Ejecutar el script project-info.sh desde diferentes usuarios

## Criterios de éxito

- Todos los usuarios pueden autenticarse correctamente
- Los permisos de directorio impiden accesos no autorizados
- Los permisos de sudo funcionan según lo especificado
- El script project-info.sh proporciona información precisa
- La documentación está completa y es precisa

I have completed this lab exercise

## 📝 Knowledge Check

Test your understanding of the material covered in this module. Select the best answer for each question.

#### Question 1

¿Cuál es la función principal del kernel en la arquitectura de Linux?

A) Interpretar comandos del usuario y ejecutar scripts B) Gestionar hardware, memoria, procesos y recursos del sistema C) Proporcionar una interfaz gráfica para usuarios D) Almacenar archivos de configuración del sistema

#### Question 2

¿Qué comando muestra la ruta completa del directorio actual donde te encuentras trabajando?

A) ls -l B) cd C) pwd D) whoami

#### Question 3

Un administrador necesita crear el usuario 'backup_admin' con un directorio home y shell bash. ¿Cuál es el comando correcto?

A) useradd backup_admin B) useradd -m -s /bin/bash backup_admin C) adduser -home -shell backup_admin D) createuser backup_admin /home/backup_admin

#### Question 4

¿Cuál es la forma CORRECTA de agregar el usuario 'developer1' al grupo 'docker' sin eliminar sus grupos existentes?

A) sudo usermod -G docker developer1 B) sudo usermod -aG docker developer1 C) sudo groupadd -u developer1 docker D) sudo adduser developer1 docker

#### Question 5

Un archivo tiene permisos 'rwxr-x---'. ¿Qué pueden hacer los usuarios que NO son propietarios ni pertenecen al grupo del archivo?

A) Leer, escribir y ejecutar el archivo B) Leer y ejecutar el archivo C) Solo leer el archivo D) No tienen ningún acceso al archivo

#### Question 6

¿Qué representan los permisos '755' en notación octal?

A) rwxr-xr-x B) rw-r--r-- C) rwxrwxrwx D) r-xr-xr-x

#### Question 7

Un administrador necesita cambiar el propietario de /proyectos/web a 'webmaster' y el grupo a 'webteam'. ¿Cuál comando es correcto?

A) sudo chmod webmaster:webteam /proyectos/web B) sudo chown webmaster:webteam /proyectos/web C) sudo chgrp webmaster:webteam /proyectos/web D) sudo usermod webmaster:webteam /proyectos/web

#### Question 8

¿Por qué es más seguro usar sudo en lugar de iniciar sesión directamente como root?

A) sudo es más rápido que cambiar al usuario root B) sudo registra todas las acciones administrativas y cada usuario usa su propia contraseña C) sudo proporciona más privilegios que la cuenta root D) sudo no requiere contraseña para ejecutar comandos

## 🎯 Module Summary

En este módulo hemos explorado los fundamentos de Linux: desde su arquitectura en capas hasta la gestión completa de usuarios y permisos. Aprendimos a navegar el sistema de archivos con comandos esenciales, crear y administrar cuentas de usuario y grupos, implementar el modelo de permisos mediante notaciones simbólica y octal, y utilizar sudo para ejecutar tareas administrativas de forma segura. Estos conocimientos forman la base esencial para cualquier administrador de sistemas Linux, permitiendo gestionar accesos, proteger recursos y mantener la seguridad del sistema siguiendo el principio de privilegio mínimo.

### Learning Objectives — Review

- Navegar el sistema de archivos de Linux utilizando comandos esenciales de terminal
- Crear y administrar cuentas de usuario con diferentes niveles de privilegios
- Configurar grupos de usuarios y asignar membresías apropiadas
- Implementar permisos de archivos y directorios usando chmod y chown
- Utilizar sudo para ejecutar comandos con privilegios elevados de forma segura

🎉

### Module Complete!

You have completed all sections of this module.