diff --git a/scripts/share/guia.md b/scripts/share/guia.md
index 6c1ab35..88e93dc 100644
--- a/scripts/share/guia.md
+++ b/scripts/share/guia.md
@@ -1,608 +1,990 @@
-# 📘 Guía Completa: Compartir Recursos en Proxmox con LXC
-*Montaje de recursos NFS, Samba y directorios locales en contenedores privilegiados y no privilegiados*
-
----
+# 📘 Guía Completa: Compartir Recursos entre Proxmox Host y Contenedores LXC
 
 ## 📋 Índice
 
-1. [**Conceptos Fundamentales**](#1-conceptos-fundamentales)
-   - [¿Qué son los usuarios y grupos en Linux?](#qué-son-los-usuarios-y-grupos-en-linux)
-   - [¿Qué son los permisos?](#qué-son-los-permisos)
-   - [¿Qué son las ACLs?](#qué-son-las-acls)
-   - [Contenedores privilegiados vs no privilegiados](#contenedores-privilegiados-vs-no-privilegiados)
+1. [Conceptos Fundamentales](#1-conceptos-fundamentales)
+   - [Usuarios y Grupos en Linux](#usuarios-y-grupos-en-linux)
+   - [Permisos Básicos](#permisos-básicos)
+   - [El Bit Setgid](#el-bit-setgid)
+   - [Access Control Lists (ACL)](#access-control-lists-acl)
+   - [Contenedores Privilegiados vs No Privilegiados](#contenedores-privilegiados-vs-no-privilegiados)
 
-2. [**Cómo Funcionan los Permisos en Recursos Compartidos**](#2-cómo-funcionan-los-permisos-en-recursos-compartidos)
-   - [Servidores NFS (Linux, TrueNAS, Synology)](#servidores-nfs)
+2. [Cómo Funcionan los Permisos en Recursos Compartidos](#2-cómo-funcionan-los-permisos-en-recursos-compartidos)
+   - [Servidores NFS](#servidores-nfs)
    - [Servidores Samba/CIFS](#servidores-sambacifs)
-   - [Directorios locales](#directorios-locales)
+   - [Directorios Locales](#directorios-locales)
 
-3. [**Preparación del Host Proxmox**](#3-preparación-del-host-proxmox)
-   - [Crear grupo universal](#crear-grupo-universal)
-   - [Montar recurso NFS](#montar-recurso-nfs)
-   - [Montar recurso Samba](#montar-recurso-samba)
-   - [Crear directorio local](#crear-directorio-local)
+3. [Preparación del Host Proxmox](#3-preparación-del-host-proxmox)
+   - [Crear Directorio Local](#crear-directorio-local)
+   - [Montar Recurso NFS](#montar-recurso-nfs)
+   - [Montar Recurso Samba](#montar-recurso-samba)
 
-4. [**Configuración de Contenedores**](#4-configuración-de-contenedores)
-   - [Contenedores privilegiados](#contenedores-privilegiados)
-   - [Contenedores no privilegiados](#contenedores-no-privilegiados)
+4. [Configuración de Contenedores](#4-configuración-de-contenedores)
+   - [Contenedores Privilegiados](#contenedores-privilegiados)
+   - [Contenedores No Privilegiados](#contenedores-no-privilegiados)
 
-5. [**Montaje en Contenedores LXC**](#5-montaje-en-contenedores-lxc)
+5. [Montaje en Contenedores](#5-montaje-en-contenedores)
 
-6. [**Verificación y Pruebas**](#6-verificación-y-pruebas)
+6. [Verificación y Pruebas](#6-verificación-y-pruebas)
 
-7. [**Solución de Problemas**](#7-solución-de-problemas)
+7. [Solución de Problemas](#7-solución-de-problemas)
 
 ---
 
 ## 1. Conceptos Fundamentales
 
-### ¿Qué son los usuarios y grupos en Linux?
+### Usuarios y Grupos en Linux
 
-En Linux, cada archivo y proceso pertenece a un **usuario** y un **grupo**:
+#### ¿Qué es un Usuario?
+
+Un **usuario** en Linux es una identidad que puede:
+- Poseer archivos y directorios
+- Ejecutar procesos
+- Tener permisos específicos
+
+Cada usuario tiene:
+- **Nombre**: Como `root`, `www-data`, `juan`
+- **UID (User ID)**: Número único, como `0` (root), `33` (www-data), `1000` (primer usuario)
 
 ```bash
-# Ver información de un archivo
-ls -l /etc/passwd
-# Salida: -rw-r--r-- 1 root root 2847 sep  8 12:34 /etc/passwd
-#         permisos   usuario grupo tamaño fecha nombre
+# Ver información de un usuario
+id www-data
+# Salida: uid=33(www-data) gid=33(www-data) groups=33(www-data)
+
+# Listar todos los usuarios del sistema
+cat /etc/passwd | head -5
+# Salida:
+# root:x:0:0:root:/root:/bin/bash
+# daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
+# bin:x:2:2:bin:/bin:/usr/sbin/nologin
 ```
 
-**¿Por qué son importantes los grupos?**
-- Permiten dar acceso a múltiples usuarios sin cambiar permisos individuales
-- En Proxmox, son la clave para que diferentes contenedores accedan a los mismos archivos
-- Simplifican la administración: añades un usuario al grupo y automáticamente tiene acceso
+#### ¿Qué es un Grupo?
 
-### ¿Qué son los permisos?
+Un **grupo** es una colección de usuarios que comparten permisos. Permite:
+- Dar acceso a múltiples usuarios sin configurar cada uno individualmente
+- Organizar permisos de manera lógica
+- Simplificar la administración
 
-Los permisos en Linux se representan con 3 números (ejemplo: `755`):
+Cada grupo tiene:
+- **Nombre**: Como `root`, `www-data`, `sharedfiles`
+- **GID (Group ID)**: Número único, como `0` (root), `33` (www-data), `1000` (usuarios)
 
 ```bash
-# Ejemplo de permisos
-chmod 755 /mnt/shared_data
-# 7 = 4+2+1 = lectura+escritura+ejecución para el propietario
-# 5 = 4+0+1 = lectura+ejecución para el grupo
-# 5 = 4+0+1 = lectura+ejecución para otros
+# Ver todos los grupos
+cat /etc/group | head -5
+# Salida:
+# root:x:0:
+# daemon:x:1:
+# bin:x:2:
+
+# Ver grupos de un usuario
+groups www-data
+# Salida: www-data : www-data
+
+# Crear un nuevo grupo
+groupadd -g 1001 migrupo
+
+# Añadir usuario a un grupo
+usermod -aG migrupo www-data
 ```
 
-**Permisos especiales importantes:**
-- **setgid (2000)**: Los archivos nuevos heredan el grupo del directorio padre
-- **sticky bit (1000)**: Solo el propietario puede borrar sus archivos
+#### ¿Por qué son importantes los grupos?
+
+**Ejemplo práctico**: Tienes 3 contenedores que ejecutan aplicaciones web:
+- **Sin grupos**: Tendrías que dar permisos individuales a cada usuario de cada contenedor
+- **Con grupos**: Creas un grupo `webapps`, añades todos los usuarios web, y das permisos al grupo
+
+### Permisos Básicos
+
+#### Tipos de Permisos
+
+Cada archivo y directorio tiene tres tipos de permisos para tres categorías de usuarios:
+
+| Permiso | Símbolo | Valor | En Archivos | En Directorios |
+|---------|---------|-------|-------------|----------------|
+| **Lectura** | `r` | 4 | Leer contenido | Listar archivos |
+| **Escritura** | `w` | 2 | Modificar archivo | Crear/eliminar archivos |
+| **Ejecución** | `x` | 1 | Ejecutar archivo | Entrar al directorio |
+
+#### Categorías de Usuarios
+
+| Categoría | Descripción | Posición |
+|-----------|-------------|----------|
+| **Propietario** (user) | El dueño del archivo | Primera posición |
+| **Grupo** (group) | Miembros del grupo propietario | Segunda posición |
+| **Otros** (others) | Todos los demás usuarios | Tercera posición |
+
+#### Lectura de Permisos
 
 ```bash
-# Combinar permisos especiales
-chmod 2775 /mnt/shared_data
-# 2 = setgid activado
-# 775 = rwxrwxr-x (lectura/escritura/ejecución para propietario y grupo)
+ls -l /mnt/ejemplo
+# Salida: drwxrwxr-x 2 root sharedfiles 4096 sep  8 10:30 ejemplo
+#         │││││││││
+#         │└┴┴┴┴┴┴┴─ Permisos
+#         └─────────── Tipo (d=directorio, -=archivo)
+
+# Desglose de permisos: rwxrwxr-x
+# Propietario (root): rwx = 7 (lectura + escritura + ejecución)
+# Grupo (sharedfiles): rwx = 7 (lectura + escritura + ejecución)  
+# Otros: r-x = 5 (lectura + ejecución, sin escritura)
 ```
 
-### ¿Qué son las ACLs?
+#### Permisos Numéricos
 
-Las **ACLs (Access Control Lists)** son permisos extendidos que van más allá del sistema tradicional usuario/grupo/otros:
+Los permisos se pueden expresar como números de 3 dígitos:
 
 ```bash
-# Ver ACLs de un directorio
-getfacl /mnt/shared_data
+# Ejemplos comunes
+chmod 755 archivo    # rwxr-xr-x (propietario: todo, otros: lectura+ejecución)
+chmod 644 archivo    # rw-r--r-- (propietario: lectura+escritura, otros: solo lectura)
+chmod 775 directorio # rwxrwxr-x (propietario y grupo: todo, otros: lectura+ejecución)
+```
 
-# Salida típica:
-# file: /mnt/shared_data
+### El Bit Setgid
+
+El **setgid** es uno de los conceptos más importantes para directorios compartidos, pero también uno de los menos comprendidos.
+
+#### ¿Qué hace el setgid?
+
+Cuando se aplica a un directorio, el **setgid** hace que:
+- **Todos los archivos y subdirectorios creados dentro hereden automáticamente el grupo del directorio padre**
+- **No importa qué usuario o proceso cree el archivo, siempre tendrá el mismo grupo**
+
+#### Ejemplo Práctico: Sin setgid
+
+```bash
+# Crear directorio sin setgid
+mkdir /tmp/sin_setgid
+chmod 775 /tmp/sin_setgid
+chgrp sharedfiles /tmp/sin_setgid
+
+ls -ld /tmp/sin_setgid
+# Salida: drwxrwxr-x 2 root sharedfiles 4096 sep  8 10:30 /tmp/sin_setgid
+#         ↑ No hay 's' en la posición del grupo
+
+# Crear archivo como usuario www-data
+sudo -u www-data touch /tmp/sin_setgid/archivo1
+ls -l /tmp/sin_setgid/archivo1
+# Salida: -rw-r--r-- 1 www-data www-data 0 sep  8 10:35 archivo1
+# ❌ El archivo pertenece al grupo 'www-data', NO 'sharedfiles'
+
+# Crear archivo como usuario root
+touch /tmp/sin_setgid/archivo2
+ls -l /tmp/sin_setgid/archivo2
+# Salida: -rw-r--r-- 1 root root 0 sep  8 10:36 archivo2
+# ❌ El archivo pertenece al grupo 'root', NO 'sharedfiles'
+```
+
+**Problema**: Cada usuario crea archivos con su grupo primario, causando inconsistencias.
+
+#### Ejemplo Práctico: Con setgid
+
+```bash
+# Crear directorio CON setgid
+mkdir /tmp/con_setgid  
+chmod 2775 /tmp/con_setgid  # El '2' inicial activa setgid
+chgrp sharedfiles /tmp/con_setgid
+
+ls -ld /tmp/con_setgid
+# Salida: drwxrwsr-x 2 root sharedfiles 4096 sep  8 10:37 /tmp/con_setgid
+#              ↑ La 's' indica que setgid está activo
+
+# Crear archivo como usuario www-data
+sudo -u www-data touch /tmp/con_setgid/archivo1
+ls -l /tmp/con_setgid/archivo1
+# Salida: -rw-r--r-- 1 www-data sharedfiles 0 sep  8 10:38 archivo1
+# ✅ El archivo hereda el grupo 'sharedfiles' del directorio padre
+
+# Crear archivo como usuario root
+touch /tmp/con_setgid/archivo2
+ls -l /tmp/con_setgid/archivo2
+# Salida: -rw-r--r-- 1 root sharedfiles 0 sep  8 10:39 archivo2
+# ✅ El archivo también hereda el grupo 'sharedfiles'
+
+# Crear subdirectorio
+mkdir /tmp/con_setgid/subdir
+ls -ld /tmp/con_setgid/subdir
+# Salida: drwxr-sr-x 2 root sharedfiles 4096 sep  8 10:40 subdir
+# ✅ El subdirectorio hereda el grupo Y también tiene setgid activo
+```
+
+#### ¿Por qué es crucial setgid para recursos compartidos?
+
+1. **Consistencia**: Todos los archivos tienen el mismo grupo, independientemente de quién los cree
+2. **Simplicidad**: No necesitas cambiar manualmente el grupo de cada archivo nuevo
+3. **Herencia**: Los subdirectorios también heredan el setgid, manteniendo la consistencia en toda la estructura
+4. **Compatibilidad**: Funciona con NFS, Samba, y contenedores sin configuración adicional
+
+### Access Control Lists (ACL)
+
+#### Limitaciones de los Permisos Tradicionales
+
+Los permisos tradicionales de Linux solo permiten:
+- **1 propietario**
+- **1 grupo**
+- **Permisos para "otros"**
+
+**Problema**: ¿Qué pasa si necesitas que 3 grupos diferentes tengan acceso de escritura?
+
+#### ¿Qué son las ACL?
+
+Las **Access Control Lists (ACL)** extienden los permisos tradicionales permitiendo:
+- **Múltiples usuarios** con permisos específicos
+- **Múltiples grupos** con permisos específicos
+- **Permisos por defecto** que se heredan automáticamente
+
+```bash
+# Instalar herramientas ACL
+apt-get install acl
+
+# Ver ACL de un archivo/directorio
+getfacl /mnt/shared
+# Salida:
+# file: mnt/shared
 # owner: root
 # group: sharedfiles
-# flags: -s-  (setgid activo)
 # user::rwx
 # group::rwx
-# group:sharedfiles:rwx
-# mask::rwx
+# group:webapps:rwx
+# group:developers:r-x
 # other::r-x
 # default:user::rwx
 # default:group::rwx
-# default:group:sharedfiles:rwx
-# default:mask::rwx
+# default:group:webapps:rwx
 # default:other::r-x
 ```
 
-**¿Por qué son cruciales las ACLs?**
-- **Garantizan permisos**: Aunque un proceso tenga `umask 077`, las ACLs aseguran que el grupo tenga acceso
-- **Herencia automática**: Los archivos nuevos automáticamente tienen los permisos correctos
-- **Compatibilidad con NFS**: NFS solo entiende números de UID/GID, las ACLs aseguran consistencia
-
-### Contenedores privilegiados vs no privilegiados
-
-**Contenedor privilegiado:**
-- UID 0 en contenedor = UID 0 en host (root = root)
-- Acceso directo a recursos del host
-- Menos seguro pero más simple
-
-**Contenedor no privilegiado:**
-- UID 0 en contenedor = UID 100000 en host
-- UID 1000 en contenedor = UID 101000 en host
-- Más seguro pero requiere mapeo de permisos
+#### Configurar ACL
 
 ```bash
-# Ejemplo: archivo creado en contenedor no privilegiado
-# Dentro del contenedor (ID 101):
-echo "test" > /mnt/shared/archivo.txt
-ls -l /mnt/shared/archivo.txt
-# -rw-r--r-- 1 root root 5 sep 8 archivo.txt
+# Dar permisos a un grupo específico
+setfacl -m g:webapps:rwx /mnt/shared
 
-# En el host:
-ls -l /mnt/shared_data/archivo.txt  
-# -rw-r--r-- 1 100000 100000 5 sep 8 archivo.txt
-# UID 0 del contenedor se ve como UID 100000 en el host
+# Dar permisos a un usuario específico  
+setfacl -m u:juan:rw /mnt/shared
+
+# Configurar permisos por defecto (se heredan)
+setfacl -d -m g:webapps:rwx /mnt/shared
+
+# Aplicar ACL recursivamente a todo el contenido existente
+setfacl -R -m g:webapps:rwx /mnt/shared
+
+# Combinar: aplicar a existente Y configurar por defecto
+setfacl -R -m g:webapps:rwx /mnt/shared
+setfacl -d -m g:webapps:rwx /mnt/shared
 ```
 
+#### ¿Por qué son importantes las ACL para NFS y Samba?
+
+**NFS y mapeo de IDs**:
+- NFS transmite solo números (UID/GID), no nombres
+- Si el cliente tiene usuarios con IDs diferentes, los permisos se rompen
+- Las ACL aseguran que el grupo correcto siempre tenga acceso
+
+**Ejemplo práctico**:
+```bash
+# Servidor NFS: usuario 'web' tiene UID 1001
+# Cliente NFS: usuario 'web' tiene UID 1002
+
+# Sin ACL: El cliente ve archivos del UID 1001 (usuario inexistente)
+# Con ACL: El grupo 'webapps' siempre tiene acceso, independiente de UIDs
+```
+
+### Contenedores Privilegiados vs No Privilegiados
+
+#### ¿Qué son los Contenedores No Privilegiados?
+
+Los contenedores **no privilegiados** son más seguros porque:
+- El usuario `root` del contenedor NO es `root` del host
+- Los IDs de usuario/grupo están "desplazados"
+- Limitan el daño si el contenedor es comprometido
+
+#### Mapeo de IDs
+
+En un contenedor no privilegiado típico:
+
+| Contenedor | Host | Explicación |
+|------------|------|-------------|
+| UID 0 (root) | UID 100000 | Root del contenedor = usuario 100000 del host |
+| UID 1 | UID 100001 | Usuario 1 del contenedor = usuario 100001 del host |
+| UID 1000 (usuario) | UID 101000 | Usuario 1000 del contenedor = usuario 101000 del host |
+| GID 0 (root) | GID 100000 | Grupo root del contenedor = grupo 100000 del host |
+| GID 1000 (grupo) | GID 101000 | Grupo 1000 del contenedor = grupo 101000 del host |
+
+#### El Problema en la Práctica
+
+```bash
+# En el HOST: Crear archivo con grupo 'sharedfiles' (GID 1000)
+echo "datos" > /mnt/shared/archivo.txt
+chgrp sharedfiles /mnt/shared/archivo.txt
+ls -l /mnt/shared/archivo.txt
+# Salida: -rw-r--r-- 1 root sharedfiles 6 sep  8 archivo.txt
+
+# En el CONTENEDOR NO PRIVILEGIADO: Ver el mismo archivo
+pct exec 101 -- ls -l /mnt/shared/archivo.txt
+# Salida: -rw-r--r-- 1 nobody nogroup 6 sep  8 archivo.txt
+# ❌ El contenedor ve 'nobody:nogroup' porque no conoce el GID 1000 del host
+```
+
+#### ¿Por qué pasa esto?
+
+1. **Host**: El archivo pertenece al GID 1000 (`sharedfiles`)
+2. **Contenedor**: Busca qué grupo tiene GID 1000 en SU `/etc/group`
+3. **Resultado**: Si no existe ese GID en el contenedor, muestra `nogroup`
+4. **Consecuencia**: El usuario del contenedor no puede escribir
+
 ---
 
 ## 2. Cómo Funcionan los Permisos en Recursos Compartidos
 
 ### Servidores NFS
 
-**En el servidor NFS (Linux, TrueNAS, Synology):**
+#### ¿Cómo maneja NFS los permisos?
 
-Los servidores NFS manejan permisos de diferentes formas:
+Los servidores NFS (ya sean Linux, TrueNAS, Synology, etc.) funcionan de manera similar:
 
-#### Servidor Linux tradicional:
-```bash
-# En el servidor NFS
-/etc/exports:
-/export/data 192.168.1.0/24(rw,sync,no_subtree_check,no_root_squash)
+1. **Solo transmiten números**: NFS envía UID/GID numéricos, no nombres de usuario
+2. **No hay autenticación de usuario**: NFS confía en que el cliente ya autenticó al usuario
+3. **Los permisos se evalúan en el servidor**: El servidor NFS verifica permisos usando sus propios archivos `/etc/passwd` y `/etc/group`
 
-# El directorio en el servidor:
-ls -l /export/data
-drwxrwxr-x 2 usuario1 compartido 4096 sep 8 /export/data
-```
-
-#### TrueNAS/FreeNAS:
-- **Interfaz web**: Configuras permisos por usuario/grupo
-- **Mapeo de usuarios**: Puedes mapear usuarios del cliente a usuarios del servidor
-- **ACLs nativas**: TrueNAS usa ACLs de FreeBSD/ZFS que son más potentes
-
-#### Synology NAS:
-- **DSM (interfaz web)**: Configuras carpetas compartidas con permisos por usuario
-- **Mapeo automático**: Synology puede mapear automáticamente usuarios por nombre
-- **Squash options**: Controla cómo se mapean usuarios root y anónimos
-
-**¿Qué pasa cuando montas NFS en Proxmox?**
+#### Ejemplo con TrueNAS
 
 ```bash
-# Montar NFS desde TrueNAS
-mount -t nfs 192.168.1.100:/mnt/pool1/shared /mnt/nfs_share
+# En TrueNAS: Crear dataset con permisos
+# Dataset: /mnt/pool/shared
+# Propietario: root (UID 0)
+# Grupo: shared (GID 1001)  
+# Permisos: 775
 
-# Ver cómo se ven los permisos en Proxmox:
-ls -l /mnt/nfs_share
-# drwxrwxr-x 2 1001 1001 4096 sep 8 shared_folder
-#              ^^^^ ^^^^ 
-#              UID  GID del servidor NFS
+# En Proxmox: Montar el NFS
+mount -t nfs 192.168.1.100:/mnt/pool/shared /mnt/truenas_shared
+
+# Ver cómo se ven los permisos en Proxmox
+ls -ld /mnt/truenas_shared
+# Salida: drwxrwxr-x 2 root 1001 4096 sep  8 10:45 /mnt/truenas_shared
+#                        ↑ Aparece el GID numérico porque Proxmox no tiene grupo con GID 1001
 ```
 
-**Problema típico**: El servidor NFS tiene UID/GID diferentes a Proxmox:
-- Servidor: usuario `juan` (UID 1001), grupo `familia` (GID 1001)  
-- Proxmox: no existe UID 1001, se ve como número
-- **Solución**: Crear grupo común con GID específico y usar ACLs
+#### Solución: Crear grupo con el mismo GID
+
+```bash
+# En Proxmox: Crear grupo con el mismo GID que TrueNAS
+groupadd -g 1001 truenas_shared
+
+# Ahora se ve correctamente
+ls -ld /mnt/truenas_shared
+# Salida: drwxrwxr-x 2 root truenas_shared 4096 sep  8 10:45 /mnt/truenas_shared
+```
+
+#### Configuraciones comunes en servidores NFS
+
+**TrueNAS/FreeNAS**:
+- Maptype: Unix
+- Usuario: root o usuario específico
+- Grupo: wheel, shared, o grupo personalizado
+
+**Synology**:
+- Squash: No mapping
+- Usuario: root o admin
+- Grupo: users o grupo personalizado
+
+**Linux (Ubuntu/Debian)**:
+```bash
+# /etc/exports
+/export/shared 192.168.1.0/24(rw,sync,no_subtree_check,no_root_squash)
+```
 
 ### Servidores Samba/CIFS
 
-**En el servidor Samba:**
+#### ¿Cómo maneja Samba los permisos?
 
-Samba traduce entre permisos de Windows y Linux:
+Samba es más complejo porque debe mapear entre:
+1. **Usuarios Windows** (autenticación SMB)
+2. **Usuarios Linux** (permisos del sistema de archivos)
+
+#### Ejemplo con Synology
 
 ```bash
-# Configuración típica en smb.conf del servidor:
-[shared]
-   path = /srv/samba/shared
-   valid users = @familia
-   read only = no
-   create mask = 0664
-   directory mask = 2775
-   force group = familia
+# En Synology: Crear carpeta compartida
+# Nombre: SharedData
+# Permisos SMB: Grupo 'users' con lectura/escritura
+# Permisos Linux: 775, propietario 'admin', grupo 'users'
+
+# En Proxmox: Montar Samba
+mount -t cifs //192.168.1.200/SharedData /mnt/synology_shared \
+  -o username=admin,password=mipassword,uid=root,gid=1000,file_mode=0664,dir_mode=0775
+
+# Ver permisos
+ls -ld /mnt/synology_shared
+# Salida: drwxrwxr-x 2 root 1000 4096 sep  8 10:50 /mnt/synology_shared
+#                        ↑ Usa el GID especificado en las opciones de montaje
 ```
 
-**¿Qué pasa cuando montas Samba en Proxmox?**
+#### Opciones importantes de montaje CIFS
 
-```bash
-# Montar Samba desde Windows Server o Linux
-mount -t cifs //192.168.1.200/shared /mnt/samba_share -o username=juan,password=secreto
+- `uid=`: UID que se asigna a todos los archivos
+- `gid=`: GID que se asigna a todos los archivos  
+- `file_mode=`: Permisos para archivos (ej: 0664)
+- `dir_mode=`: Permisos para directorios (ej: 0775)
+- `forceuid/forcegid`: Fuerza el uso de uid/gid especificados
 
-# Ver permisos en Proxmox:
-ls -l /mnt/samba_share  
-# drwxrwxr-x 2 juan familia 4096 sep 8 documentos
-```
-
-**Características importantes de Samba:**
-- **Mapeo de usuarios**: Samba puede mapear usuarios Windows ↔ Linux
-- **Force group**: Todos los archivos nuevos pertenecen a un grupo específico
-- **Create/directory mask**: Controla permisos de archivos y carpetas nuevos
-- **ACL support**: Samba puede preservar ACLs de Windows en sistemas Linux
-
-### Directorios locales
+### Directorios Locales
 
 Los directorios locales son los más simples:
-- Permisos directos del sistema de archivos
-- Sin traducción de protocolos
-- Control total sobre UID/GID
-
-```bash
-# Crear directorio local optimizado para compartir
-mkdir -p /mnt/local_shared
-chown root:sharedfiles /mnt/local_shared
-chmod 2775 /mnt/local_shared
-setfacl -d -m g:sharedfiles:rwx /mnt/local_shared
-```
+- Los permisos se respetan directamente
+- No hay mapeo de red
+- Funciona con usuarios y grupos locales del sistema
 
 ---
 
 ## 3. Preparación del Host Proxmox
 
-### Crear grupo universal
+### Crear Directorio Local
 
-Primero creamos un grupo que será el punto común entre host y contenedores:
+Para crear un directorio local que se compartirá con contenedores:
 
 ```bash
-# Crear grupo con GID específico
+# 1. Crear directorio
+mkdir -p /mnt/local_shared
+
+# 2. Crear grupo común (usaremos GID 101000 para compatibilidad universal)
 groupadd -g 101000 sharedfiles
 
-# Verificar que se creó correctamente
-getent group sharedfiles
-# sharedfiles:x:101000:
+# 3. Configurar propietario y permisos con setgid
+chown root:sharedfiles /mnt/local_shared
+chmod 2775 /mnt/local_shared
 
-# ¿Por qué GID 101000?
-# - Es el mapeo base para contenedores no privilegiados
-# - UID/GID 1000 en contenedor no privilegiado = 101000 en host
-# - Facilita la compatibilidad entre ambos tipos de contenedores
+# 4. Aplicar ACL para garantizar permisos
+setfacl -R -m g:sharedfiles:rwx /mnt/local_shared
+setfacl -d -m g:sharedfiles:rwx /mnt/local_shared
+
+# 5. Verificar configuración
+ls -ld /mnt/local_shared
+# Salida esperada: drwxrwsr-x+ 2 root sharedfiles 4096 sep  8 11:00 /mnt/local_shared
+#                       ↑ 's' indica setgid activo
+#                          ↑ '+' indica ACL aplicadas
+
+getfacl /mnt/local_shared
+# Salida esperada:
+# file: mnt/local_shared
+# owner: root
+# group: sharedfiles
+# user::rwx
+# group::rwx
+# other::r-x
+# default:user::rwx
+# default:group::rwx
+# default:other::r-x
 ```
 
-### Montar recurso NFS
+### Montar Recurso NFS
+
+#### Montaje Temporal
 
-#### Montaje temporal (para pruebas):
 ```bash
-# Crear punto de montaje
-mkdir -p /mnt/nfs_share
+# 1. Crear punto de montaje
+mkdir -p /mnt/nfs_shared
 
-# Montar NFS (ejemplo desde TrueNAS)
-mount -t nfs 192.168.1.100:/mnt/pool1/shared /mnt/nfs_share
+# 2. Montar NFS
+mount -t nfs 192.168.1.100:/export/shared /mnt/nfs_shared
 
-# Verificar montaje
-df -h | grep nfs_share
-# 192.168.1.100:/mnt/pool1/shared  1.0T  500G  500G  50% /mnt/nfs_share
+# 3. Verificar montaje
+df -h | grep nfs
+mount | grep nfs
 
-# Ver permisos originales
-ls -l /mnt/nfs_share
-# total 4
-# drwxr-xr-x 2 1001 1001 4096 sep  8 12:34 documentos
-# -rw-r--r-- 1 1002 1002  156 sep  8 12:35 readme.txt
+# 4. Ver permisos originales
+ls -ld /mnt/nfs_shared
+# Ejemplo: drwxrwxr-x 2 root 1001 4096 sep  8 11:05 /mnt/nfs_shared
 ```
 
-#### Configurar permisos para compartir con LXC:
+#### Crear Grupo Compatible
+
 ```bash
-# Cambiar grupo del punto de montaje
-chgrp sharedfiles /mnt/nfs_share
-chmod g+w /mnt/nfs_share
+# Si el directorio NFS tiene un GID específico (ej: 1001), crear grupo local
+groupadd -g 1001 nfs_shared
 
-# Aplicar ACLs para garantizar acceso del grupo
-setfacl -R -m g:sharedfiles:rwx /mnt/nfs_share
-setfacl -d -m g:sharedfiles:rwx /mnt/nfs_share
-
-# Verificar ACLs aplicadas
-getfacl /mnt/nfs_share
+# Verificar que ahora se ve el nombre del grupo
+ls -ld /mnt/nfs_shared
+# Salida: drwxrwxr-x 2 root nfs_shared 4096 sep  8 11:05 /mnt/nfs_shared
 ```
 
-#### Hacer montaje persistente:
+#### Aplicar Configuración Universal
+
+```bash
+# Para compatibilidad con contenedores, aplicar nuestro esquema estándar
+# IMPORTANTE: Solo si tienes permisos de escritura en el NFS
+
+# Crear nuestro grupo estándar
+groupadd -g 101000 sharedfiles
+
+# Cambiar grupo del directorio NFS (si es posible)
+chgrp sharedfiles /mnt/nfs_shared
+
+# Aplicar setgid y ACL
+chmod 2775 /mnt/nfs_shared
+setfacl -R -m g:sharedfiles:rwx /mnt/nfs_shared
+setfacl -d -m g:sharedfiles:rwx /mnt/nfs_shared
+```
+
+#### Montaje Persistente
+
 ```bash
 # Editar /etc/fstab
 nano /etc/fstab
 
 # Añadir línea:
-192.168.1.100:/mnt/pool1/shared /mnt/nfs_share nfs rw,hard,nofail,rsize=131072,wsize=131072,timeo=600,retrans=2,_netdev 0 0
+192.168.1.100:/export/shared /mnt/nfs_shared nfs rw,hard,nofail,rsize=131072,wsize=131072,timeo=600,retrans=2,_netdev 0 0
 
 # Explicación de opciones:
-# rw: lectura y escritura
+# rw: lectura/escritura
 # hard: reintentar indefinidamente si el servidor no responde
 # nofail: no fallar el arranque si no se puede montar
-# rsize/wsize: tamaño de bloques para optimizar transferencia
+# rsize/wsize: tamaño de buffer para lectura/escritura (mejor rendimiento)
 # timeo: timeout en décimas de segundo (60 segundos)
-# retrans: número de retransmisiones antes de timeout
+# retrans: número de reintentos antes de reportar error
 # _netdev: esperar a que la red esté disponible
 # 0 0: no hacer dump ni fsck (siempre para recursos de red)
 
 # Probar montaje
 mount -a
+
+# Verificar
+df -h | grep nfs
 ```
 
-### Montar recurso Samba
+### Montar Recurso Samba
+
+#### Crear Archivo de Credenciales
 
-#### Crear archivo de credenciales:
 ```bash
-# Crear archivo seguro para credenciales
+# Crear archivo de credenciales seguro
 nano /etc/cifs-credentials
 
 # Contenido:
 username=tu_usuario
-password=tu_contraseña
+password=tu_password
 domain=tu_dominio
 
 # Proteger archivo
 chmod 600 /etc/cifs-credentials
+chown root:root /etc/cifs-credentials
 ```
 
-#### Montaje temporal:
+#### Montaje Temporal
+
 ```bash
-# Crear punto de montaje
-mkdir -p /mnt/samba_share
+# 1. Crear punto de montaje
+mkdir -p /mnt/samba_shared
 
-# Montar Samba
-mount -t cifs //192.168.1.200/shared /mnt/samba_share -o credentials=/etc/cifs-credentials,iocharset=utf8,vers=3.0
+# 2. Montar Samba con opciones específicas
+mount -t cifs //192.168.1.200/SharedData /mnt/samba_shared \
+  -o credentials=/etc/cifs-credentials,uid=root,gid=101000,file_mode=0664,dir_mode=2775,iocharset=utf8,vers=3.0
 
-# Verificar montaje
-df -h | grep samba_share
+# Explicación de opciones:
+# credentials: archivo con usuario/password
+# uid=root: todos los archivos aparecen como propietario root
+# gid=101000: todos los archivos aparecen con grupo sharedfiles
+# file_mode=0664: permisos para archivos (rw-rw-r--)
+# dir_mode=2775: permisos para directorios (rwxrwsr-x) con setgid
+# iocharset=utf8: codificación de caracteres
+# vers=3.0: versión del protocolo SMB
+
+# 3. Verificar montaje
+df -h | grep cifs
+ls -ld /mnt/samba_shared
 ```
 
-#### Configurar permisos:
+#### Configurar Grupo y Permisos
+
 ```bash
-# Aplicar mismo tratamiento que NFS
-chgrp sharedfiles /mnt/samba_share
-chmod g+w /mnt/samba_share
-setfacl -R -m g:sharedfiles:rwx /mnt/samba_share
-setfacl -d -m g:sharedfiles:rwx /mnt/samba_share
+# Crear grupo si no existe
+groupadd -g 101000 sharedfiles
+
+# Verificar que los permisos son correctos
+ls -ld /mnt/samba_shared
+# Salida esperada: drwxrwsr-x 2 root sharedfiles 4096 sep  8 11:10 /mnt/samba_shared
+
+# Aplicar ACL adicionales si es necesario
+setfacl -R -m g:sharedfiles:rwx /mnt/samba_shared
+setfacl -d -m g:sharedfiles:rwx /mnt/samba_shared
 ```
 
-#### Hacer montaje persistente:
-```bash
-# Añadir a /etc/fstab:
-//192.168.1.200/shared /mnt/samba_share cifs credentials=/etc/cifs-credentials,iocharset=utf8,vers=3.0,_netdev,nofail 0 0
+#### Montaje Persistente
 
-# Probar
+```bash
+# Editar /etc/fstab
+nano /etc/fstab
+
+# Añadir línea:
+//192.168.1.200/SharedData /mnt/samba_shared cifs credentials=/etc/cifs-credentials,uid=root,gid=101000,file_mode=0664,dir_mode=2775,iocharset=utf8,vers=3.0,_netdev,nofail 0 0
+
+# Probar montaje
 mount -a
-```
 
-### Crear directorio local
-
-```bash
-# Crear directorio local para compartir
-mkdir -p /mnt/local_shared
-
-# Configurar propietario y permisos
-chown root:sharedfiles /mnt/local_shared
-chmod 2775 /mnt/local_shared
-
-# Aplicar ACLs
-setfacl -d -m g:sharedfiles:rwx /mnt/local_shared
-
-# Verificar configuración
-ls -ld /mnt/local_shared
-# drwxrwsr-x+ 2 root sharedfiles 4096 sep  8 12:45 /mnt/local_shared
-#         ^^^
-#         's' indica setgid activo
-#            '+' indica ACLs presentes
+# Verificar
+df -h | grep cifs
 ```
 
 ---
 
 ## 4. Configuración de Contenedores
 
-### Contenedores privilegiados
+### Contenedores Privilegiados
 
-En contenedores privilegiados, los UIDs son idénticos al host, pero aún necesitamos configurar el grupo:
+Los contenedores privilegiados comparten los mismos UIDs/GIDs que el host, por lo que la configuración es más directa.
+
+#### ¿Necesitan configuración especial?
+
+**Respuesta corta**: Generalmente NO, pero hay casos donde SÍ es recomendable.
+
+#### Cuándo NO necesitan configuración
+
+Si el contenedor privilegiado:
+- Solo usa el usuario `root`
+- No ejecuta servicios con usuarios específicos (como `www-data`)
+- Los archivos siempre se crean como `root:root`
 
 ```bash
-# Entrar al contenedor privilegiado (ejemplo ID 100)
+# Ejemplo: Contenedor que solo usa root
+pct exec 100 -- bash
+whoami  # root
+id      # uid=0(root) gid=0(root) groups=0(root)
+
+# Crear archivo en directorio compartido
+echo "test" > /mnt/shared/archivo.txt
+ls -l /mnt/shared/archivo.txt
+# Salida: -rw-r--r-- 1 root root 5 sep  8 11:15 archivo.txt
+# ❌ El archivo pertenece al grupo 'root', no 'sharedfiles'
+```
+
+#### Cuándo SÍ necesitan configuración
+
+Si el contenedor privilegiado:
+- Ejecuta servicios web (`www-data`, `nginx`, `apache`)
+- Tiene aplicaciones que crean archivos con usuarios específicos
+- Necesita compatibilidad con otros contenedores o servicios
+
+```bash
+# Ejemplo: Contenedor con Nextcloud
 pct exec 100 -- bash
 
-# Crear grupo con mismo GID que el host
+# Ver usuarios del sistema
+cat /etc/passwd | grep -E "(www-data|nginx|apache)"
+# Salida: www-data:x:33:33:www-data:/var/www:/usr/sbin/nologin
+
+# Sin configuración: Nextcloud crea archivos como www-data:www-data
+sudo -u www-data touch /mnt/shared/nextcloud_file.txt
+ls -l /mnt/shared/nextcloud_file.txt
+# Salida: -rw-r--r-- 1 www-data www-data 0 sep  8 11:20 nextcloud_file.txt
+# ❌ Grupo 'www-data' no es compatible con otros contenedores
+```
+
+#### Configuración Recomendada para Contenedores Privilegiados
+
+```bash
+# 1. Entrar al contenedor
+pct exec 100 -- bash
+
+# 2. Crear grupo con el mismo GID que el host
 groupadd -g 101000 sharedfiles
 
-# ¿Por qué necesitamos crear el grupo si es privilegiado?
-# Aunque los UIDs coinciden, los NOMBRES de grupo deben existir
-# El kernel mapea por números, pero las aplicaciones usan nombres
-
-# Verificar que el grupo se creó
-getent group sharedfiles
-# sharedfiles:x:101000:
-
-# Añadir usuarios relevantes al grupo
-# Ver qué usuarios existen en el contenedor:
-awk -F: '$3>=1000 && $1!="nobody" {print $1 " (UID: " $3 ")"}' /etc/passwd
-
-# Ejemplo de salida:
-# root (UID: 0)
-# www-data (UID: 33)
-# ncp (UID: 1000)
-
-# Añadir usuarios que necesiten acceso:
+# 3. Añadir usuarios relevantes al grupo
 usermod -aG sharedfiles root
 usermod -aG sharedfiles www-data
-usermod -aG sharedfiles ncp 2>/dev/null || true
 
-# Verificar membresía
+# Si tienes otros usuarios específicos de aplicaciones:
+usermod -aG sharedfiles nextcloud 2>/dev/null || true
+usermod -aG sharedfiles nginx 2>/dev/null || true
+
+# 4. Verificar membresía
 groups root
-# root : root sharedfiles
+# Salida: root : root sharedfiles
 
 groups www-data  
-# www-data : www-data sharedfiles
+# Salida: www-data : www-data sharedfiles
 
-# Salir del contenedor
+# 5. Salir del contenedor
 exit
 ```
 
-**¿Por qué añadir usuarios al grupo en contenedor privilegiado?**
-- Aunque el UID es el mismo, el proceso debe ejecutarse con el GID correcto
-- Las aplicaciones (Apache, Nginx, Nextcloud) ejecutan con usuarios específicos
-- Al añadirlos al grupo, pueden escribir en directorios compartidos
+#### ¿Por qué es importante esta configuración?
 
-### Contenedores no privilegiados
+1. **Consistencia**: Los archivos creados por diferentes usuarios mantienen el grupo `sharedfiles`
+2. **Compatibilidad**: Funciona con contenedores no privilegiados y otros servicios
+3. **Flexibilidad**: Permite que múltiples usuarios/servicios accedan a los mismos archivos
 
-Los contenedores no privilegiados requieren mapeo de UIDs:
+### Contenedores No Privilegiados
+
+Los contenedores no privilegiados SIEMPRE necesitan configuración especial debido al mapeo de UIDs/GIDs.
+
+#### Configuración Obligatoria
 
 ```bash
-# Entrar al contenedor no privilegiado (ejemplo ID 101)
+# 1. Entrar al contenedor
 pct exec 101 -- bash
 
-# Crear grupo con GID que mapee a 101000 en el host
+# 2. Crear grupo con GID mapeado
+# GID 1000 en contenedor = GID 101000 en host
 groupadd -g 1000 sharedfiles
 
-# ¿Por qué GID 1000 y no 101000?
-# Dentro del contenedor: GID 1000
-# En el host se ve como: GID 101000 (1000 + 100000)
-# Esto coincide con nuestro grupo del host
+# 3. Listar usuarios disponibles en el contenedor
+awk -F: '$3>=1000 && $1!="nobody" {print $1 " (UID: " $3 ")"}' /etc/passwd
+# Salida típica:
+# root (UID: 0)
+# www-data (UID: 33)  
+# ncp (UID: 1000)
 
-# Verificar mapeo
-id
-# uid=0(root) gid=0(root) groups=0(root)
+# También incluir usuarios del sistema si es necesario
+awk -F: '$3<1000 && $3>0 && $1!="nobody" {print $1 " (UID: " $3 ")"}' /etc/passwd
 
-# Añadir usuarios al grupo
+# 4. Añadir usuarios al grupo
 usermod -aG sharedfiles root
 usermod -aG sharedfiles www-data
+
+# Si tienes usuarios específicos de aplicaciones:
 usermod -aG sharedfiles ncp 2>/dev/null || true
+usermod -aG sharedfiles nextcloud 2>/dev/null || true
 
-# Verificar que el mapeo funciona
+# 5. Verificar configuración
 id www-data
-# uid=33(www-data) gid=33(www-data) groups=33(www-data),1000(sharedfiles)
+# Salida esperada: uid=33(www-data) gid=33(www-data) groups=33(www-data),1000(sharedfiles)
 
-# Salir del contenedor
+# 6. Salir del contenedor
 exit
-
-# Verificar desde el host cómo se ve el grupo
-pct exec 101 -- getent group sharedfiles
-# sharedfiles:x:1000:root,www-data,ncp
 ```
 
-**¿Cómo añadir más usuarios?**
+#### Cómo Añadir Más Usuarios
+
+Si instalas nuevas aplicaciones que crean usuarios adicionales:
 
 ```bash
-# Dentro del contenedor, listar todos los usuarios del sistema:
-awk -F: '{print $1 " (UID: " $3 ", GID: " $4 ")"}' /etc/passwd
+# Entrar al contenedor
+pct exec 101 -- bash
 
-# Añadir usuarios específicos:
+# Buscar nuevos usuarios (UID >= 100)
+awk -F: '$3>=100 && $3<65534 {print $1 " (UID: " $3 ", GID: " $4 ")"}' /etc/passwd
+
+# Añadir al grupo sharedfiles
 usermod -aG sharedfiles nombre_usuario
 
-# Añadir todos los usuarios con UID >= 1000 automáticamente:
-for user in $(awk -F: '$3>=1000 && $1!="nobody" {print $1}' /etc/passwd); do
-    usermod -aG sharedfiles "$user" 2>/dev/null || true
-    echo "Usuario $user añadido al grupo sharedfiles"
+# Verificar
+groups nombre_usuario
+```
+
+#### Añadir TODOS los usuarios automáticamente
+
+```bash
+# Script para añadir todos los usuarios relevantes
+pct exec 101 -- bash -c '
+# Obtener todos los usuarios con UID >= 100 y < 65534 (excluyendo nobody)
+for user in $(awk -F: "$3>=100 && $3<65534 && $1!=\"nobody\" {print $1}" /etc/passwd); do
+    echo "Añadiendo usuario: $user"
+    usermod -aG sharedfiles "$user" 2>/dev/null || echo "Error añadiendo $user"
 done
+
+# Verificar usuarios añadidos
+echo "Usuarios en grupo sharedfiles:"
+getent group sharedfiles
+'
 ```
 
 ---
 
-## 5. Montaje en Contenedores LXC
+## 5. Montaje en Contenedores
 
-### Configurar montajes
+### Configuración del Montaje
+
+Para ambos tipos de contenedores, el montaje se configura igual, pero con consideraciones importantes:
 
 ```bash
 # Para contenedor privilegiado (ID 100)
-pct set 100 -mp0 /mnt/nfs_share,mp=/mnt/shared,shared=1,backup=0,acl=1
+pct set 100 -mp0 /mnt/shared_data,mp=/mnt/shared,backup=0,acl=1,shared=1
 
 # Para contenedor no privilegiado (ID 101)  
-pct set 101 -mp0 /mnt/nfs_share,mp=/mnt/shared,shared=1,backup=0,acl=1
+pct set 101 -mp0 /mnt/shared_data,mp=/mnt/shared,backup=0,acl=1,shared=1
 
-# Explicación de parámetros:
-# /mnt/nfs_share: ruta en el host
-# mp=/mnt/shared: ruta dentro del contenedor
-# shared=1: permite migración en clusters sin copiar datos
-# backup=0: excluye del backup de vzdump (evita copiar datos externos)
-# acl=1: habilita soporte para ACLs dentro del contenedor
-```
-
-### Reiniciar contenedores
-
-```bash
-# Reiniciar para activar montajes
+# Reiniciar contenedores para activar montajes
 pct reboot 100
 pct reboot 101
 
-# Esperar a que arranquen completamente
+# Esperar a que arranquen
 sleep 15
+```
 
-# Verificar que están funcionando
-pct status 100
-pct status 101
+#### Explicación de Parámetros
+
+- **`/mnt/shared_data`**: Ruta en el HOST (donde está montado el recurso)
+- **`mp=/mnt/shared`**: Ruta en el CONTENEDOR (donde aparecerá el directorio)
+- **`backup=0`**: Excluir del backup de vzdump (recomendado para recursos de red)
+- **`acl=1`**: Habilitar soporte para ACL dentro del contenedor
+- **`shared=1`**: **CRUCIAL para clusters** - permite migración sin copiar datos
+
+#### ¿Por qué shared=1 es importante?
+
+Sin `shared=1`:
+- Proxmox intenta copiar todo el contenido durante migraciones
+- Falla si el directorio contiene muchos datos
+- No funciona con recursos de red
+
+Con `shared=1`:
+- Proxmox asume que el directorio está disponible en todos los nodos
+- Solo migra la configuración, no los datos
+- Funciona perfectamente con NFS, Samba, y almacenamiento compartido
+
+### Verificación del Montaje
+
+```bash
+# Verificar que el montaje está activo
+pct exec 100 -- df -h | grep shared
+pct exec 101 -- df -h | grep shared
+
+# Verificar permisos dentro de los contenedores
+pct exec 100 -- ls -ld /mnt/shared
+pct exec 101 -- ls -ld /mnt/shared
+
+# Verificar ACL dentro de los contenedores
+pct exec 100 -- getfacl /mnt/shared
+pct exec 101 -- getfacl /mnt/shared
 ```
 
 ---
 
 ## 6. Verificación y Pruebas
 
-### Prueba en contenedor privilegiado
+### Prueba Básica de Escritura
+
+#### Desde el Host
 
 ```bash
-# Entrar al contenedor privilegiado
-pct exec 100 -- bash
+# Crear archivo de prueba desde el host
+echo "Archivo creado desde HOST" > /mnt/shared_data/test_host.txt
 
-# Verificar montaje
-df -h | grep shared
-# /dev/fuse  1.0T  500G  500G  50% /mnt/shared
-
-# Verificar permisos
-ls -ld /mnt/shared
-# drwxrwsr-x+ 2 root sharedfiles 4096 sep  8 /mnt/shared
-
-# Crear archivo de prueba
-echo "Prueba desde contenedor privilegiado $(date)" > /mnt/shared/test_privileged.txt
-
-# Verificar propietario
-ls -l /mnt/shared/test_privileged.txt
-# -rw-rw-r--+ 1 root sharedfiles 45 sep  8 test_privileged.txt
-
-# Cambiar a usuario www-data y probar
-su - www-data -s /bin/bash
-echo "Prueba www-data privilegiado $(date)" > /mnt/shared/test_www_privileged.txt
-ls -l /mnt/shared/test_www_privileged.txt
-# -rw-rw-r--+ 1 www-data sharedfiles 42 sep  8 test_www_privileged.txt
-
-exit # salir de www-data
-exit # salir del contenedor
+# Verificar propietario y permisos
+ls -l /mnt/shared_data/test_host.txt
+# Salida esperada: -rw-rw-r--+ 1 root sharedfiles 26 sep  8 12:00 test_host.txt
 ```
 
-### Prueba en contenedor no privilegiado
+#### Desde Contenedor Privilegiado
 
 ```bash
-# Entrar al contenedor no privilegiado
-pct exec 101 -- bash
+# Crear archivo como root
+pct exec 100 -- bash -c 'echo "Archivo desde contenedor privilegiado (root)" > /mnt/shared/test_priv_root.txt'
 
-# Verificar montaje
-df -h | grep shared
-
-# Crear archivo de prueba
-echo "Prueba desde contenedor no privilegiado $(date)" > /mnt/shared/test_unprivileged.txt
-
-# Verificar dentro del contenedor
-ls -l /mnt/shared/test_unprivileged.txt
-# -rw-rw-r--+ 1 root sharedfiles 48 sep  8 test_unprivileged.txt
-
-# Probar con www-data
-su - www-data -s /bin/bash
-echo "Prueba www-data no privilegiado $(date)" > /mnt/shared/test_www_unprivileged.txt
-exit
-
-exit # salir del contenedor
-```
-
-### Verificar desde el host
-
-```bash
-# Ver todos los archivos creados
-ls -l /mnt/nfs_share/
+# Crear archivo como www-data
+pct exec 100 -- sudo -u www-data bash -c 'echo "Archivo desde contenedor privilegiado (www-data)" > /mnt/shared/test_priv_www.txt'
 
+# Verificar en el host
+ls -l /mnt/shared_data/test_priv_*
 # Salida esperada:
-# -rw-rw-r--+ 1 root      sharedfiles    45 sep  8 test_privileged.txt
-# -rw-rw-r--+ 1 www-data  sharedfiles    42 sep  8 test_www_privileged.txt  
-# -rw-rw-r--+ 1 100000    101000         48 sep  8 test_unprivileged.txt
-# -rw-rw-r--+ 1 100033    101000         45 sep  8 test_www_unprivileged.txt
-
-# Verificar que todos pertenecen al grupo correcto
-stat /mnt/nfs_share/test_*.txt | grep -E "(File:|Uid:|Gid:)"
+# -rw-rw-r--+ 1 root sharedfiles 42 sep  8 12:01 test_priv_root.txt
+# -rw-rw-r--+ 1 www-data sharedfiles 48 sep  8 12:01 test_priv_www.txt
 ```
 
-### Prueba de escritura cruzada
+#### Desde Contenedor No Privilegiado
 
 ```bash
-# Desde contenedor privilegiado, modificar archivo del no privilegiado
-pct exec 100 -- bash -c 'echo "Modificado por privilegiado" >> /mnt/shared/test_unprivileged.txt'
+# Crear archivo como root del contenedor
+pct exec 101 -- bash -c 'echo "Archivo desde contenedor no privilegiado (root)" > /mnt/shared/test_unpriv_root.txt'
 
-# Desde contenedor no privilegiado, modificar archivo del privilegiado  
-pct exec 101 -- bash -c 'echo "Modificado por no privilegiado" >> /mnt/shared/test_privileged.txt'
+# Crear archivo como www-data del contenedor
+pct exec 101 -- sudo -u www-data bash -c 'echo "Archivo desde contenedor no privilegiado (www-data)" > /mnt/shared/test_unpriv_www.txt'
 
-# Verificar que ambas operaciones funcionaron
-cat /mnt/nfs_share/test_unprivileged.txt
-cat /mnt/nfs_share/test_privileged.txt
+# Verificar en el host
+ls -l /mnt/shared_data/test_unpriv_*
+# Salida esperada:
+# -rw-rw-r--+ 1 100000 sharedfiles 46 sep  8 12:02 test_unpriv_root.txt
+# -rw-rw-r--+ 1 100033 sharedfiles 52 sep  8 12:02 test_unpriv_www.txt
+#              ↑ UIDs mapeados (+100000)
+```
+
+### Prueba de Acceso Cruzado
+
+```bash
+# Desde contenedor privilegiado, leer archivo del no privilegiado
+pct exec 100 -- cat /mnt/shared/test_unpriv_root.txt
+# Salida: Archivo desde contenedor no privilegiado (root)
+
+# Desde contenedor no privilegiado, leer archivo del privilegiado
+pct exec 101 -- cat /mnt/shared/test_priv_root.txt
+# Salida: Archivo desde contenedor privilegiado (root)
+
+# Modificar archivo desde diferentes contenedores
+pct exec 100 -- bash -c 'echo "Modificado desde privilegiado" >> /mnt/shared/test_unpriv_root.txt'
+pct exec 101 -- bash -c 'echo "Modificado desde no privilegiado" >> /mnt/shared/test_priv_root.txt'
+
+# Verificar contenido
+cat /mnt/shared_data/test_unpriv_root.txt
+cat /mnt/shared_data/test_priv_root.txt
+```
+
+### Prueba de Herencia de Permisos
+
+```bash
+# Crear subdirectorio desde contenedor
+pct exec 100 -- mkdir /mnt/shared/subdir_test
+
+# Verificar que hereda setgid y grupo
+ls -ld /mnt/shared_data/subdir_test
+# Salida esperada: drwxrwsr-x+ 2 root sharedfiles 4096 sep  8 12:05 subdir_test
+#                       ↑ 's' indica setgid heredado
+
+# Crear archivo en subdirectorio
+pct exec 101 -- touch /mnt/shared/subdir_test/archivo_en_subdir.txt
+
+# Verificar herencia
+ls -l /mnt/shared_data/subdir_test/archivo_en_subdir.txt
+# Salida esperada: -rw-rw-r--+ 1 100000 sharedfiles 0 sep  8 12:06 archivo_en_subdir.txt
+```
+
+### Script de Verificación Completa
+
+```bash
+#!/bin/bash
+# Script de verificación completa
+
+echo "=== VERIFICACIÓN DE CONFIGURACIÓN COMPARTIDA ==="
+echo
+
+# Verificar host
+echo "1. Verificando configuración del host:"
+echo "   Directorio: $(ls -ld /mnt/shared_data)"
+echo "   ACL: $(getfacl /mnt/shared_data | grep -E '(group:sharedfiles|default:group:sharedfiles)')"
+echo
+
+# Verificar contenedores
+for ct in 100 101; do
+    if pct status $ct | grep -q running; then
+        echo "2. Verificando contenedor $ct:"
+        echo "   Montaje: $(pct exec $ct -- df -h | grep shared || echo 'No montado')"
+        echo "   Grupo: $(pct exec $ct -- getent group sharedfiles || echo 'Grupo no existe')"
+        echo "   Usuarios en grupo: $(pct exec $ct -- getent group sharedfiles | cut -d: -f4)"
+        echo
+    fi
+done
+
+# Prueba de escritura
+echo "3. Prueba de escritura:"
+test_file="/mnt/shared_data/verification_test.txt"
+echo "Test desde host" > "$test_file"
+
+for ct in 100 101; do
+    if pct status $ct | grep -q running; then
+        pct exec $ct -- bash -c "echo 'Test desde contenedor $ct' >> /mnt/shared/verification_test.txt" 2>/dev/null
+        if [ $? -eq 0 ]; then
+            echo "   ✅ Contenedor $ct puede escribir"
+        else
+            echo "   ❌ Contenedor $ct NO puede escribir"
+        fi
+    fi
+done
+
+echo
+echo "4. Contenido final del archivo de prueba:"
+cat "$test_file" 2>/dev/null || echo "   ❌ No se puede leer el archivo"
+echo
+echo "5. Permisos del archivo de prueba:"
+ls -l "$test_file" 2>/dev/null || echo "   ❌ Archivo no existe"
 ```
 
 ---
@@ -611,189 +993,249 @@ cat /mnt/nfs_share/test_privileged.txt
 
 ### Error: "Permission denied" al escribir
 
-**Síntomas:**
+#### Síntomas
 ```bash
-pct exec 101 -- bash -c 'echo "test" > /mnt/shared/test.txt'
-# bash: /mnt/shared/test.txt: Permission denied
+pct exec 101 -- touch /mnt/shared/test.txt
+# touch: cannot touch '/mnt/shared/test.txt': Permission denied
 ```
 
-**Diagnóstico:**
+#### Diagnóstico
 ```bash
-# Verificar permisos del directorio
-ls -ld /mnt/nfs_share
-# drwxr-xr-x 2 1001 1001 4096 sep  8 /mnt/nfs_share
-#         ^^^
-#         Falta escritura para grupo
+# 1. Verificar permisos en el host
+ls -ld /mnt/shared_data
+getfacl /mnt/shared_data
 
-# Verificar ACLs
-getfacl /mnt/nfs_share
-# No aparecen ACLs para el grupo sharedfiles
+# 2. Verificar grupo en el contenedor
+pct exec 101 -- getent group sharedfiles
+
+# 3. Verificar membresía del usuario
+pct exec 101 -- groups www-data
 ```
 
-**Solución:**
+#### Soluciones
 ```bash
-# Corregir permisos
-chmod g+w /mnt/nfs_share
-setfacl -R -m g:sharedfiles:rwx /mnt/nfs_share
-setfacl -d -m g:sharedfiles:rwx /mnt/nfs_share
+# Solución 1: Recrear grupo en contenedor
+pct exec 101 -- groupadd -g 1000 sharedfiles
+pct exec 101 -- usermod -aG sharedfiles www-data
+
+# Solución 2: Reaplicar ACL en host
+setfacl -R -m g:sharedfiles:rwx /mnt/shared_data
+setfacl -d -m g:sharedfiles:rwx /mnt/shared_data
+
+# Solución 3: Verificar setgid
+chmod 2775 /mnt/shared_data
 ```
 
-### Error: Archivos aparecen con propietario numérico
+### Error: Archivos aparecen como "nobody:nogroup"
 
-**Síntomas:**
+#### Síntomas
 ```bash
-ls -l /mnt/nfs_share
-# -rw-r--r-- 1 1001 1001 156 sep  8 archivo.txt
-#              ^^^^ ^^^^
-#              UIDs numéricos en lugar de nombres
+pct exec 101 -- ls -l /mnt/shared/
+# -rw-r--r-- 1 nobody nogroup 100 sep  8 12:00 archivo.txt
 ```
 
-**Explicación:**
-- El servidor NFS tiene usuarios con UIDs diferentes
-- Proxmox no tiene usuarios con esos UIDs
-- Es normal y no afecta el funcionamiento
+#### Causa
+El contenedor no tiene un grupo con el GID del archivo.
 
-**Solución (opcional):**
+#### Solución
 ```bash
-# Crear usuarios con los mismos UIDs si es necesario
-useradd -u 1001 -g sharedfiles usuario_remoto
+# 1. Ver GID numérico en el host
+ls -n /mnt/shared_data/archivo.txt
+# -rw-r--r-- 1 0 101000 100 sep  8 12:00 archivo.txt
+#              ↑ GID 101000
+
+# 2. Crear grupo en contenedor con GID mapeado
+# GID 101000 en host = GID 1000 en contenedor no privilegiado
+pct exec 101 -- groupadd -g 1000 sharedfiles
+
+# 3. Verificar que ahora se ve correctamente
+pct exec 101 -- ls -l /mnt/shared/archivo.txt
+# -rw-r--r-- 1 nobody sharedfiles 100 sep  8 12:00 archivo.txt
 ```
 
-### Error: "Transport endpoint is not connected"
+### Error: "Transport endpoint is not connected" (NFS)
 
-**Síntomas:**
+#### Síntomas
 ```bash
-ls /mnt/nfs_share
-# ls: cannot access '/mnt/nfs_share': Transport endpoint is not connected
+ls /mnt/nfs_shared
+# ls: cannot access '/mnt/nfs_shared': Transport endpoint is not connected
 ```
 
-**Diagnóstico:**
+#### Diagnóstico
 ```bash
-# Verificar montaje
-mount | grep nfs_share
-# No aparece o aparece como "stale"
+# Verificar estado del montaje
+mount | grep nfs
+df -h | grep nfs
 
-# Verificar conectividad al servidor
+# Verificar conectividad
 ping 192.168.1.100
 showmount -e 192.168.1.100
 ```
 
-**Solución:**
+#### Soluciones
 ```bash
-# Desmontar forzosamente
-umount -f /mnt/nfs_share
+# Solución 1: Remontar
+umount /mnt/nfs_shared
+mount -t nfs 192.168.1.100:/export/shared /mnt/nfs_shared
 
-# Volver a montar
-mount -a
+# Solución 2: Usar opciones más robustas
+mount -t nfs 192.168.1.100:/export/shared /mnt/nfs_shared \
+  -o hard,intr,rsize=32768,wsize=32768,timeo=600,retrans=2
 
-# Si persiste, verificar configuración del servidor NFS
+# Solución 3: Verificar servicios NFS
+systemctl status nfs-common
+systemctl restart nfs-common
 ```
 
-### Error: Contenedor no puede acceder al montaje
+### Error: Contenedor no puede acceder después de migración
 
-**Síntomas:**
+#### Síntomas
+Después de migrar un contenedor a otro nodo, no puede acceder al directorio compartido.
+
+#### Causa
+El directorio compartido no está montado en el nodo destino, o falta `shared=1`.
+
+#### Solución
 ```bash
-pct exec 101 -- ls /mnt/shared
-# ls: cannot access '/mnt/shared': No such file or directory
+# 1. Verificar configuración del contenedor
+cat /etc/pve/lxc/101.conf | grep mp0
+# Debe incluir: shared=1
+
+# 2. Si falta shared=1, añadirlo
+pct set 101 -mp0 /mnt/shared_data,mp=/mnt/shared,backup=0,acl=1,shared=1
+
+# 3. Verificar que el directorio existe en el nodo destino
+ls -ld /mnt/shared_data
+
+# 4. Si no existe, montar el recurso en el nodo destino
+# (repetir pasos de montaje NFS/Samba según corresponda)
 ```
 
-**Diagnóstico:**
-```bash
-# Verificar configuración del contenedor
-pct config 101 | grep mp0
-# mp0: /mnt/nfs_share,mp=/mnt/shared,backup=0,acl=1
+### Error: "Operation not supported" con ACL
 
-# Verificar que el directorio existe en el host
-ls -ld /mnt/nfs_share
+#### Síntomas
+```bash
+setfacl -m g:sharedfiles:rwx /mnt/shared_data
+# setfacl: /mnt/shared_data: Operation not supported
 ```
 
-**Solución:**
-```bash
-# Reiniciar contenedor
-pct reboot 101
+#### Causa
+El sistema de archivos no soporta ACL.
 
-# Si persiste, verificar que el montaje del host funciona
-ls /mnt/nfs_share
+#### Diagnóstico
+```bash
+# Verificar tipo de sistema de archivos
+df -T /mnt/shared_data
+
+# Verificar opciones de montaje
+mount | grep shared_data
 ```
 
-### Error: ACLs no funcionan
-
-**Síntomas:**
+#### Soluciones
 ```bash
-getfacl /mnt/nfs_share
-# getfacl: Removing leading '/' from absolute path names
-# # file: mnt/nfs_share
-# # owner: root
-# # group: sharedfiles
-# user::rwx
-# group::rwx
-# other::r-x
-# (No aparecen ACLs por defecto)
+# Para ext4: Remontar con soporte ACL
+mount -o remount,acl /mnt/shared_data
+
+# Para NFS: Añadir opción acl
+umount /mnt/shared_data
+mount -t nfs 192.168.1.100:/export/shared /mnt/shared_data -o acl
+
+# Para sistemas de archivos que no soportan ACL:
+# Usar solo permisos tradicionales con setgid
+chmod 2775 /mnt/shared_data
 ```
 
-**Diagnóstico:**
+### Archivos creados con permisos incorrectos
+
+#### Síntomas
+Los archivos se crean con permisos 644 en lugar de 664.
+
+#### Causa
+La umask del proceso no permite escritura de grupo.
+
+#### Solución
 ```bash
-# Verificar si el sistema de archivos soporta ACLs
-mount | grep nfs_share
-# Si es NFS, verificar versión y opciones de montaje
+# Verificar umask actual
+pct exec 101 -- umask
+# Si es 022, cambiar a 002
 
-# Verificar herramientas ACL
-which setfacl getfacl
-```
+# Cambiar umask temporalmente
+pct exec 101 -- umask 002
 
-**Solución:**
-```bash
-# Instalar herramientas ACL si faltan
-apt update && apt install acl -y
+# Cambiar umask permanentemente
+pct exec 101 -- bash -c 'echo "umask 002" >> /etc/profile'
 
-# Remontar con soporte ACL si es necesario
-mount -o remount,acl /mnt/nfs_share
-
-# Aplicar ACLs nuevamente
-setfacl -d -m g:sharedfiles:rwx /mnt/nfs_share
+# Alternativa: Usar ACL por defecto (más robusta)
+setfacl -d -m g:sharedfiles:rwx /mnt/shared_data
+setfacl -d -m o::r-x /mnt/shared_data
 ```
 
 ---
 
-## 🎯 Resumen Final
+## 📋 Resumen de Comandos Clave
 
-### Flujo completo exitoso:
-
-1. **Host**: Crear grupo `sharedfiles` (GID 101000)
-2. **Host**: Montar recurso (NFS/Samba/local) con permisos y ACLs correctos
-3. **Contenedores**: Crear grupo `sharedfiles` y añadir usuarios
-4. **Host**: Configurar montaje en contenedores con `shared=1,backup=0,acl=1`
-5. **Verificar**: Crear archivos desde ambos contenedores y verificar permisos
-
-### Comandos clave para recordar:
+### Configuración del Host
 
 ```bash
-# Crear grupo universal
+# Crear directorio local
+mkdir -p /mnt/shared_data
 groupadd -g 101000 sharedfiles
+chown root:sharedfiles /mnt/shared_data
+chmod 2775 /mnt/shared_data
+setfacl -R -m g:sharedfiles:rwx /mnt/shared_data
+setfacl -d -m g:sharedfiles:rwx /mnt/shared_data
 
-# Configurar directorio con herencia
-chmod 2775 /mnt/directorio
-chgrp sharedfiles /mnt/directorio
+# Montar NFS persistente
+echo "192.168.1.100:/export/shared /mnt/nfs_shared nfs rw,hard,nofail,_netdev 0 0" >> /etc/fstab
 
-# Aplicar ACLs por defecto
-setfacl -d -m g:sharedfiles:rwx /mnt/directorio
-
-# Montar en contenedor
-pct set ID -mp0 /host/path,mp=/container/path,shared=1,backup=0,acl=1
-
-# Verificar funcionamiento
-pct exec ID -- su - usuario -c 'echo "test" > /container/path/test.txt'
+# Montar Samba persistente  
+echo "//192.168.1.200/share /mnt/samba_shared cifs credentials=/etc/cifs-creds,uid=root,gid=101000,file_mode=0664,dir_mode=2775,_netdev,nofail 0 0" >> /etc/fstab
 ```
 
-### ¿Por qué funciona esta configuración?
+### Configuración de Contenedores
 
-- **Grupo común**: Punto de encuentro entre host y contenedores
-- **GID 101000**: Compatible con mapeo de contenedores no privilegiados  
-- **setgid (2775)**: Herencia automática del grupo en archivos nuevos
-- **ACLs por defecto**: Garantizan permisos independientemente de umask
-- **shared=1**: Permite migración en clusters
-- **backup=0**: Evita copiar datos externos en backups
+```bash
+# Contenedor privilegiado
+pct exec 100 -- groupadd -g 101000 sharedfiles
+pct exec 100 -- usermod -aG sharedfiles root
+pct exec 100 -- usermod -aG sharedfiles www-data
 
-Esta configuración asegura que tanto contenedores privilegiados como no privilegiados puedan leer y escribir en recursos compartidos, manteniendo permisos consistentes y compatibilidad con clusters de Proxmox.
+# Contenedor no privilegiado
+pct exec 101 -- groupadd -g 1000 sharedfiles
+pct exec 101 -- usermod -aG sharedfiles root
+pct exec 101 -- usermod -aG sharedfiles www-data
+
+# Montaje
+pct set 100 -mp0 /mnt/shared_data,mp=/mnt/shared,backup=0,acl=1,shared=1
+pct set 101 -mp0 /mnt/shared_data,mp=/mnt/shared,backup=0,acl=1,shared=1
+```
+
+### Verificación
+
+```bash
+# Verificar configuración
+ls -ld /mnt/shared_data
+getfacl /mnt/shared_data
+pct exec 101 -- groups www-data
+
+# Prueba de escritura
+echo "test" > /mnt/shared_data/test.txt
+pct exec 100 -- touch /mnt/shared/test_priv.txt
+pct exec 101 -- touch /mnt/shared/test_unpriv.txt
+```
+
+---
+
+## 🎯 Conclusión
+
+Esta guía te ha mostrado cómo configurar correctamente recursos compartidos entre Proxmox y contenedores LXC, tanto privilegiados como no privilegiados. Los conceptos clave son:
+
+1. **Grupo común** (`sharedfiles`) con GID consistente
+2. **Setgid** (2775) para herencia automática de grupo
+3. **ACL** para garantizar permisos robustos
+4. **Mapeo correcto** de UIDs/GIDs en contenedores no privilegiados
+5. **Configuración adecuada** de montajes con `shared=1`, `backup=0`, `acl=1`
+
+Con esta configuración, tendrás un sistema robusto que funciona con NFS, Samba, directorios locales, y es compatible con clusters y migraciones de Proxmox.
 ```