Cómo crear una nueva carpeta en Ubuntu: guía completa de gestión de directorios

La creación de una nueva carpeta en Ubuntu se realiza principalmente con el comando mkdir en la terminal. La sintaxis básica es mkdir folder_name, que crea instantáneamente un directorio en tu ubicación de trabajo actual. Para estructuras anidadas, mkdir -p parent/child/grandchild crea toda la ruta en una sola operación, incluso si los directorios intermedios aún no existen.

Esta guía va mucho más allá de lo básico. Cubre todos los métodos prácticos para crear directorios en Ubuntu — desde la creación simple de una sola carpeta hasta estructuras recursivas, aprovisionamiento con control de permisos y patrones de scripting listos para automatización utilizados en entornos de servidores de producción reales.

Por qué la estructura de directorios adecuada es importante en un servidor Linux

En cualquier servidor Ubuntu, el sistema de archivos es la columna vertebral de cada operación. Los directorios mal organizados crean problemas en cascada: rutas de aplicaciones rotas, jerarquías de permisos mal configuradas, trabajos de copia de seguridad fallidos y vulnerabilidades de seguridad causadas por directorios con permisos de escritura para todos ubicados en lugares sensibles.

Un enfoque disciplinado en la gestión de directorios afecta directamente a:

• Herencia de permisos — los directorios hijos heredan los permisos del padre a menos que se anulen explícitamente, lo que hace que las decisiones iniciales sobre la estructura sean críticas
• Alcance de las copias de seguridad — las herramientas de copia de seguridad como rsync y tar operan sobre árboles de directorios, por lo que la agrupación lógica reduce la complejidad de las copias de seguridad
• Configuración de servicios — los servidores web (Apache, Nginx), las bases de datos y los entornos de ejecución de aplicaciones dependen de rutas de directorio predecibles y bien definidas
• Auditoría y cumplimiento — las rutas estructuradas hacen que la correlación de registros y el análisis forense sean significativamente más rápidos

Si estás gestionando un entorno de VPS Hosting o un Servidor Dedicado, establecer una convención de directorios coherente desde el primer día evita la deuda técnica que se acumula rápidamente a medida que el sistema crece.

Requisitos previos

Antes de ejecutar cualquiera de los comandos a continuación, confirma lo siguiente:

• Tienes acceso a una terminal (local o a través de SSH)
• Tu cuenta de usuario tiene permiso de escritura en la ubicación de destino
• Para directorios a nivel de sistema (por ejemplo, bajo /etc/ o /var/), tienes privilegios sudo
• Versión de Ubuntu: estos comandos se aplican universalmente a Ubuntu 18.04, 20.04, 22.04 y 24.04 LTS

Para verificar tu directorio de trabajo actual en cualquier momento, ejecuta:

pwd

Método 1: Creación básica de directorios con mkdir

El comando mkdir (make directory) es la utilidad POSIX estándar para crear directorios. Está disponible en todas las distribuciones Linux sin necesidad de instalación.

Sintaxis:

mkdir directory_name

Ejemplo:

mkdir project_files

Esto crea un directorio llamado project_files en tu ubicación actual. El comando no produce ninguna salida en caso de éxito — este es el comportamiento estándar de Unix. Para confirmar la creación:

ls -la

Convenciones de nomenclatura a seguir en producción:

• Usa letras minúsculas y guiones bajos o guiones: web_assets, backup-2024
• Evita espacios en los nombres de directorios — requieren escape (mkdir "my folder" o mkdir my folder) y rompen muchos scripts de shell
• Evita caracteres especiales: &, *, ?, !, | tienen significados específicos del shell y causan comportamientos impredecibles

Método 2: Creación de un directorio en una ruta absoluta específica

En lugar de navegar primero a una ubicación de destino, puedes pasar la ruta absoluta completa directamente a mkdir. Este es el enfoque preferido en scripts y aprovisionamiento automatizado.

Sintaxis:

mkdir /full/path/to/new_directory

Ejemplo:

mkdir /var/www/html/myapp

Restricción importante: Este comando fallará si algún directorio intermedio en la ruta no existe ya. Por ejemplo, si /var/www/html/ no existe, el comando anterior devuelve:

mkdir: cannot create directory '/var/www/html/myapp': No such file or directory

La solución es el indicador -p, que se trata en el Método 3.

Usar rutas relativas es igualmente válido y a menudo más legible en sesiones interactivas:

mkdir ../sibling_directory
mkdir ./subdirectory

Método 3: Creación de directorios anidados de forma recursiva con -p

El indicador -p (parents) es una de las opciones más importantes operacionalmente en mkdir. Indica al comando que cree todos los directorios intermedios faltantes en la ruta especificada, y suprime el error que normalmente ocurriría si el directorio de destino ya existe.

Sintaxis:

mkdir -p parent_directory/child_directory/grandchild_directory

Ejemplo:

mkdir -p /var/www/html/myapp/logs/archive

Si /var/www/html/myapp/ no existe, este único comando crea toda la cadena: myapp, luego logs dentro de él, luego archive dentro de ese.

Caso de uso crítico en producción — raíces de documentos del servidor web:

mkdir -p /var/www/vhosts/example.com/{public_html,logs,ssl,tmp}

Esta sintaxis de expansión de llaves (tratada en detalle en el Método 6) combinada con -p es un patrón estándar para aprovisionar nuevos entornos de host virtual en un solo comando.

El indicador -p también previene errores en scripts idempotentes. Si ejecutas el mismo comando mkdir -p dos veces, la segunda ejecución no hace nada y termina limpiamente con el código 0. Sin -p, la segunda ejecución devolvería un error, rompiendo cualquier script que use set -e (salir en caso de error).

Método 4: Creación de múltiples directorios simultáneamente

mkdir acepta múltiples argumentos, creando todos los directorios especificados en una sola invocación.

Sintaxis:

mkdir dir1 dir2 dir3

Ejemplo:

mkdir assets uploads cache sessions

Esto crea cuatro directorios separados en la ubicación actual. Todos los directorios se crean al mismo nivel — esto no es una estructura anidada.

Combinando con rutas absolutas:

mkdir /srv/app/modules /srv/app/config /srv/app/data

Combinando con -p para múltiples rutas anidadas:

mkdir -p /srv/project/frontend/src /srv/project/backend/src /srv/project/docs

Esto es particularmente útil al estructurar un nuevo directorio de aplicación antes del despliegue.

Método 5: Creación de directorios con permisos específicos usando -m

Por defecto, mkdir aplica permisos basados en el valor de umask del sistema. En la mayoría de los sistemas Ubuntu, el umask predeterminado es 0022, lo que significa que los nuevos directorios reciben permisos de 755 (propietario: lectura/escritura/ejecución; grupo: lectura/ejecución; otros: lectura/ejecución).

En muchos escenarios de servidor, los permisos predeterminados son demasiado permisivos o demasiado restrictivos. El indicador -m te permite establecer permisos exactos en el momento de la creación usando notación octal.

Sintaxis:

mkdir -m octal_mode directory_name

Patrones de permisos comunes:

Ejemplo — creación de un directorio seguro para claves SSH:

mkdir -m 700 ~/.ssh

Ejemplo — creación de una raíz web con permisos correctos:

mkdir -m 755 /var/www/html/newsite

Combinando -m y -p:

mkdir -p -m 750 /srv/app/config/secrets

Ten en cuenta que al usar -p, el modo se aplica solo al directorio final en la ruta, no a los directorios intermedios que se crean. Los directorios intermedios reciben los permisos predeterminados basados en umask. Si necesitas un control preciso sobre todos los niveles, crea cada nivel individualmente con indicadores -m explícitos, o usa chmod después del hecho.

Método 6: Expansión de llaves para árboles de directorios complejos

La expansión de llaves es una característica del shell Bash — no una opción de mkdir — que genera múltiples argumentos a partir de un solo patrón. Combinada con mkdir -p, es la forma más eficiente de crear jerarquías de directorios complejas.

Expansión básica de llaves:

mkdir -p project/{src,tests,docs,build}

Esto se expande a:

mkdir -p project/src project/tests project/docs project/build

Expansión de llaves de múltiples niveles:

mkdir -p app/{frontend/{components,pages,styles},backend/{controllers,models,routes},shared/utils}

Esto crea la siguiente estructura:

app/
├── frontend/
│   ├── components/
│   ├── pages/
│   └── styles/
├── backend/
│   ├── controllers/
│   ├── models/
│   └── routes/
└── shared/
    └── utils/

Este patrón es una práctica estándar al inicializar nuevos repositorios de aplicaciones o aprovisionar directorios de aplicaciones en un VPS con cPanel nuevo o un servidor bare-metal.

Método 7: Creación de directorios a través de la GUI de Ubuntu (aplicación Archivos)

Para instalaciones de escritorio de Ubuntu o sesiones de escritorio remoto, la aplicación GNOME Archivos (Nautilus) proporciona un método gráfico.

Pasos:

1. Abre la aplicación Archivos desde el menú Actividades o el dock
2. Navega al directorio padre donde deseas la nueva carpeta
3. Haz clic derecho en un área vacía dentro del directorio
4. Selecciona Nueva carpeta en el menú contextual
5. Escribe el nombre de carpeta deseado y presiona Enter

Atajo de teclado: En Nautilus, Ctrl+Shift+N crea una nueva carpeta instantáneamente sin usar el menú de clic derecho.

Limitaciones del enfoque GUI:

• No puede establecer permisos personalizados durante la creación — requiere una acción posterior en la terminal o en las propiedades del archivo
• No puede crear estructuras anidadas recursivas en una sola operación
• No está disponible en entornos de servidor sin cabeza (la gran mayoría de los servidores Ubuntu de producción se ejecutan sin entorno de escritorio)

Para cualquier trabajo serio de administración de servidores, los métodos de línea de comandos son siempre preferidos.

Método 8: Scripting de creación de directorios para automatización

En la administración de servidores del mundo real, los directorios rara vez se crean manualmente uno a la vez. Los scripts de aprovisionamiento, las canalizaciones de despliegue y las herramientas de gestión de configuración dependen de la creación automatizada de directorios.

Ejemplo básico de script de shell:

#!/bin/bash
set -e

BASE_DIR="/var/www/vhosts"
DOMAIN="example.com"

directories=(
    "$BASE_DIR/$DOMAIN/public_html"
    "$BASE_DIR/$DOMAIN/logs"
    "$BASE_DIR/$DOMAIN/ssl"
    "$BASE_DIR/$DOMAIN/tmp"
    "$BASE_DIR/$DOMAIN/backup"
)

for dir in "${directories[@]}"; do
    mkdir -p "$dir"
    echo "Created: $dir"
done

# Set ownership to web server user
chown -R www-data:www-data "$BASE_DIR/$DOMAIN"
chmod -R 755 "$BASE_DIR/$DOMAIN"

echo "Directory structure for $DOMAIN provisioned successfully."

Prácticas clave de scripting:

• Usa siempre set -e para abortar en cualquier error
• Pon entre comillas todas las variables ("$dir") para manejar rutas con espacios de forma segura
• Combina mkdir -p con chown y chmod en el mismo script para asegurar que los permisos sean correctos inmediatamente después de la creación
• Usa arrays para listas de directorios para mantener los scripts legibles y mantenibles

Este enfoque es esencial cuando se gestionan múltiples hosts virtuales, se despliegan aplicaciones en distintos entornos o se automatiza la configuración del servidor con herramientas como Ansible o scripts de aprovisionamiento basados en Bash.

Comparación: opciones de mkdir y sus casos de uso

Errores comunes y cómo solucionarlos

Error: Permission denied

mkdir: cannot create directory '/etc/myapp': Permission denied

Causa: Estás intentando escribir en un directorio propiedad del sistema sin privilegios elevados.

Solución: Antepón sudo:

sudo mkdir /etc/myapp

Error: No such file or directory

mkdir: cannot create directory '/srv/app/config': No such file or directory

Causa: Uno o más directorios intermedios en la ruta no existen.

Solución: Usa el indicador -p:

mkdir -p /srv/app/config

Error: File exists

mkdir: cannot create directory 'mydir': File exists

Causa: Ya existe un directorio o archivo con ese nombre.

Solución: Usa -p para suprimir este error cuando la ruta existente es un directorio, o elige un nombre diferente.

Fallo silencioso en scripts: Si mkdir falla y tu script no usa set -e ni verifica los códigos de salida, las operaciones posteriores pueden continuar en una ruta inexistente, causando fallos impredecibles. Valida siempre la creación de directorios críticos:

mkdir -p /srv/app/data || { echo "Failed to create data directory"; exit 1; }

Consideraciones de seguridad para la creación de directorios

Los permisos de directorio son una primera línea de defensa en la seguridad del servidor. Varias vulnerabilidades de alto impacto provienen directamente de permisos de directorio incorrectos:

• Directorios con escritura para todos (777) permiten que cualquier usuario del sistema escriba, modifique o elimine archivos — un riesgo crítico en hosting compartido o servidores multiusuario
• Propiedad incorrecta en directorios orientados a la web puede permitir que los exploits de aplicaciones web escriban archivos maliciosos fuera de la raíz de documentos prevista
• Sticky bit (chmod +t) en directorios compartidos (como /tmp) evita que los usuarios eliminen archivos propiedad de otros — establece siempre esto en directorios compartidos con escritura
• Bit SetGID en directorios asegura que los nuevos archivos hereden el grupo del directorio en lugar del grupo primario del usuario creador — útil para directorios de proyectos colaborativos

Ejemplo — directorio de proyecto compartido seguro:

mkdir -p /srv/shared/project
chown root:developers /srv/shared/project
chmod 2775 /srv/shared/project  # SetGID + rwxrwxr-x

Al alojar aplicaciones web, dominios con SSL o servicios de correo electrónico, los permisos de directorio adecuados son inseparables de la postura de seguridad de tu configuración de Certificados SSL y tu configuración de Hosting de Correo Electrónico.

Verificación de la creación de directorios

Después de crear directorios, verifica siempre el resultado antes de continuar con las operaciones dependientes.

Listar con permisos detallados:

ls -la /path/to/parent/

Verificar que existe un directorio específico (útil en scripts):

[ -d /srv/app/config ] && echo "Directory exists" || echo "Directory missing"

Ver la estructura completa del árbol (requiere el paquete tree):

sudo apt install tree -y
tree /srv/app/

Verificar el uso de inodos — en servidores con muchos archivos pequeños, el agotamiento de inodos puede impedir la creación de directorios incluso cuando hay espacio en disco disponible:

df -i /srv/

Si el uso de inodos está cerca del 100%, no puedes crear nuevos directorios o archivos independientemente del espacio en disco disponible. Este es un problema común en producción en servidores que alojan grandes cantidades de archivos pequeños, como servidores de correo o directorios de sesiones PHP.

Matriz de decisión práctica: qué método usar

Conclusiones técnicas clave

• mkdir -p es la opción más segura por defecto para cualquier creación de directorios mediante scripts o automatización — es idempotente y maneja rutas intermedias faltantes
• Nunca uses permisos 777 en directorios de producción; prefiere 755 para rutas públicas y 750 o 700 para datos sensibles
• El indicador -m en mkdir establece permisos solo en el directorio final cuando se usa con -p — usa chmod -R o llamadas mkdir por nivel para un control total
• La expansión de llaves es una característica de Bash, no de mkdir — no funcionará en scripts /bin/sh a menos que el shell sea Bash
• Verifica siempre la disponibilidad de inodos (df -i) en sistemas de archivos de alta densidad antes de la creación masiva de directorios
• Combina la creación de directorios con la asignación inmediata de chown en scripts de aprovisionamiento para evitar una ventana en la que los directorios existan con una propiedad incorrecta
• En entornos de Paneles de Control VPS, los usuarios del servidor web (típicamente www-data o nginx) deben tener permiso de ejecución en cada directorio de la ruta de la raíz de documentos — no solo en el directorio final

Preguntas frecuentes

¿Cuál es la diferencia entre mkdir folder y mkdir -p folder?

mkdir folder crea un único directorio y falla si alguna parte de la ruta no existe o si el directorio ya existe. mkdir -p folder crea todos los directorios intermedios faltantes y termina silenciosamente sin error si el destino ya existe, lo que lo hace seguro para scripts y ejecuciones repetidas.

¿Puede mkdir crear un directorio con espacios en el nombre?

Sí. Pon el nombre entre comillas: mkdir "my project folder" o escapa los espacios: mkdir my project folder. Sin embargo, los espacios en los nombres de directorios están fuertemente desaconsejados en servidores porque requieren escape en cada comando posterior y rompen muchos scripts de shell y configuraciones de aplicaciones.

¿Por qué falla mkdir con “Permiso denegado” incluso con sudo?

Esto ocurre típicamente cuando el sistema de archivos de destino está montado en modo de solo lectura, cuando las políticas de SELinux o AppArmor restringen las escrituras en esa ruta, o cuando la ruta está en un sistema de archivos de red con restricciones del lado del servidor. Verifica las opciones de montaje con mount | grep /target/path y revisa los registros de AppArmor con sudo aa-status.

¿Cómo creo un directorio y establezco inmediatamente su propietario y grupo?

mkdir en sí mismo no establece la propiedad — usa chown inmediatamente después: mkdir -p /srv/app && chown www-data:www-data /srv/app. En una sola canalización: install -d -m 755 -o www-data -g www-data /srv/app — el comando install crea directorios con propietario, grupo y modo en un solo paso.

¿Qué sucede con los permisos al usar mkdir -p con múltiples niveles nuevos?

Solo el directorio final (más profundo) recibe el modo especificado por -m. Todos los directorios intermedios que se crean nuevamente reciben permisos derivados del umask actual. Si se requieren permisos consistentes en todos los niveles, crea cada nivel individualmente con indicadores -m explícitos o aplica chmod -R después de que se cree la ruta completa.