Comment créer un nouveau dossier dans Ubuntu : Guide complet de gestion des répertoires

La création d’un nouveau dossier dans Ubuntu s’effectue principalement avec la commande mkdir dans le terminal. La syntaxe de base est mkdir folder_name, ce qui crée instantanément un répertoire dans votre emplacement de travail actuel. Pour les structures imbriquées, mkdir -p parent/child/grandchild crée l’intégralité du chemin en une seule opération, même si les répertoires intermédiaires n’existent pas encore.

Ce guide va bien au-delà des bases. Il couvre toutes les méthodes pratiques pour créer des répertoires sur Ubuntu — de la création simple d’un seul dossier aux structures récursives, la mise en place avec gestion des permissions, et les modèles de scripts prêts pour l’automatisation utilisés dans de vrais environnements de serveurs de production.

Pourquoi une structure de répertoires appropriée est importante sur un serveur Linux

Sur tout serveur Ubuntu, le système de fichiers est l’épine dorsale de chaque opération. Des répertoires mal organisés créent des problèmes en cascade : chemins d’application brisés, hiérarchies de permissions mal configurées, échecs des tâches de sauvegarde, et vulnérabilités de sécurité causées par des répertoires accessibles en écriture par tous placés dans des emplacements sensibles.

Une approche disciplinée de la gestion des répertoires affecte directement :

• L’héritage des permissions — les répertoires enfants héritent des permissions du parent sauf si elles sont explicitement remplacées, ce qui rend les décisions de structure initiale critiques
• La portée des sauvegardes — les outils de sauvegarde comme rsync et tar opèrent sur des arborescences de répertoires, donc un regroupement logique réduit la complexité des sauvegardes
• La configuration des services — les serveurs web (Apache, Nginx), les bases de données et les environnements d’exécution d’applications dépendent tous de chemins de répertoires prévisibles et bien définis
• L’audit et la conformité — des chemins structurés rendent la corrélation des journaux et l’analyse forensique considérablement plus rapides

Si vous gérez un environnement VPS Hosting ou un Serveur Dédié, établir une convention de répertoires cohérente dès le premier jour évite une dette technique qui s’accumule rapidement à mesure que le système grandit.

Prérequis

Avant d’exécuter l’une des commandes ci-dessous, confirmez les points suivants :

• Vous avez accès à un terminal (local ou via SSH)
• Votre compte utilisateur dispose de la permission d’écriture sur l’emplacement cible
• Pour les répertoires au niveau système (par exemple, sous /etc/ ou /var/), vous disposez des privilèges sudo
• Version Ubuntu : ces commandes s’appliquent universellement à Ubuntu 18.04, 20.04, 22.04 et 24.04 LTS

Pour vérifier votre répertoire de travail actuel à tout moment, exécutez :

pwd

Méthode 1 : Création de répertoire de base avec mkdir

La commande mkdir (make directory) est l’utilitaire POSIX standard pour créer des répertoires. Elle est disponible sur chaque distribution Linux sans installation.

Syntaxe :

mkdir directory_name

Exemple :

mkdir project_files

Cela crée un répertoire nommé project_files dans votre emplacement actuel. La commande ne produit aucune sortie en cas de succès — c’est le comportement Unix standard. Pour confirmer la création :

ls -la

Conventions de nommage à suivre en production :

• Utilisez des lettres minuscules et des underscores ou des tirets : web_assets, backup-2024
• Évitez les espaces dans les noms de répertoires — ils nécessitent un échappement (mkdir "my folder" ou mkdir my folder) et cassent de nombreux scripts shell
• Évitez les caractères spéciaux : &, *, ?, !, | ont des significations spécifiques au shell et provoquent un comportement imprévisible

Méthode 2 : Création d’un répertoire à un chemin absolu spécifique

Plutôt que de naviguer d’abord vers un emplacement cible, vous pouvez passer le chemin absolu complet directement à mkdir. C’est l’approche préférée dans les scripts et la mise en place automatisée.

Syntaxe :

mkdir /full/path/to/new_directory

Exemple :

mkdir /var/www/html/myapp

Contrainte importante : Cette commande échouera si un répertoire intermédiaire dans le chemin n’existe pas déjà. Par exemple, si /var/www/html/ n’existe pas, la commande ci-dessus retourne :

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

La solution est l’option -p, couverte dans la Méthode 3.

L’utilisation de chemins relatifs est tout aussi valide et souvent plus lisible dans les sessions interactives :

mkdir ../sibling_directory
mkdir ./subdirectory

Méthode 3 : Création de répertoires imbriqués de manière récursive avec -p

L’option -p (parents) est l’une des options les plus importantes opérationnellement dans mkdir. Elle indique à la commande de créer tous les répertoires intermédiaires manquants dans le chemin spécifié, et elle supprime l’erreur qui se produirait normalement si le répertoire cible existe déjà.

Syntaxe :

mkdir -p parent_directory/child_directory/grandchild_directory

Exemple :

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

Si /var/www/html/myapp/ n’existe pas, cette seule commande crée toute la chaîne : myapp, puis logs à l’intérieur, puis archive à l’intérieur de celui-ci.

Cas d’utilisation critique en production — racines de documents de serveur web :

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

Cette syntaxe d’expansion d’accolades (couverte en détail dans la Méthode 6) combinée avec -p est un modèle standard pour la mise en place de nouveaux environnements d’hôtes virtuels en une seule commande.

L’option -p empêche également les erreurs dans les scripts idempotents. Si vous exécutez la même commande mkdir -p deux fois, la deuxième exécution ne fait rien et se termine proprement avec le code 0. Sans -p, la deuxième exécution retournerait une erreur, cassant tout script qui utilise set -e (quitter en cas d’erreur).

Méthode 4 : Création de plusieurs répertoires simultanément

mkdir accepte plusieurs arguments, créant tous les répertoires spécifiés en une seule invocation.

Syntaxe :

mkdir dir1 dir2 dir3

Exemple :

mkdir assets uploads cache sessions

Cela crée quatre répertoires séparés dans l’emplacement actuel. Tous les répertoires sont créés au même niveau — ce n’est pas une structure imbriquée.

Combinaison avec des chemins absolus :

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

Combinaison avec -p pour plusieurs chemins imbriqués :

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

Ceci est particulièrement utile lors de la mise en place d’une nouvelle structure de répertoires d’application avant le déploiement.

Méthode 5 : Création de répertoires avec des permissions spécifiques à l’aide de -m

Par défaut, mkdir applique des permissions basées sur la valeur umask du système. Sur la plupart des systèmes Ubuntu, l’umask par défaut est 0022, ce qui signifie que les nouveaux répertoires reçoivent des permissions de 755 (propriétaire : lecture/écriture/exécution ; groupe : lecture/exécution ; autres : lecture/exécution).

Dans de nombreux scénarios de serveur, les permissions par défaut sont soit trop permissives, soit trop restrictives. L’option -m vous permet de définir des permissions exactes au moment de la création en utilisant la notation octale.

Syntaxe :

mkdir -m octal_mode directory_name

Modèles de permissions courants :

Exemple — création d’un répertoire sécurisé pour les clés SSH :

mkdir -m 700 ~/.ssh

Exemple — création d’une racine web avec les permissions correctes :

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

Combinaison de -m et -p :

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

Notez que lors de l’utilisation de -p, le mode est appliqué uniquement au répertoire final dans le chemin, et non aux répertoires intermédiaires qui sont créés. Les répertoires intermédiaires reçoivent les permissions par défaut basées sur l’umask. Si vous avez besoin d’un contrôle précis sur tous les niveaux, créez chaque niveau individuellement avec des options -m explicites, ou utilisez chmod après coup.

Méthode 6 : Expansion d’accolades pour des arborescences de répertoires complexes

L’expansion d’accolades est une fonctionnalité du shell Bash — pas une option de mkdir — qui génère plusieurs arguments à partir d’un seul modèle. Combinée avec mkdir -p, c’est la méthode la plus efficace pour créer des hiérarchies de répertoires complexes.

Expansion d’accolades de base :

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

Cela se développe en :

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

Expansion d’accolades à plusieurs niveaux :

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

Cela crée la structure suivante :

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

Ce modèle est une pratique standard lors de l’initialisation de nouveaux dépôts d’applications ou de la mise en place de répertoires d’applications sur un nouveau VPS avec cPanel ou un serveur bare-metal.

Méthode 7 : Création de répertoires via l’interface graphique Ubuntu (application Fichiers)

Pour les installations Ubuntu de bureau ou les sessions de bureau à distance, l’application GNOME Fichiers (Nautilus) fournit une méthode graphique.

Étapes :

1. Ouvrez l’application Fichiers depuis le menu Activités ou le dock
2. Naviguez vers le répertoire parent où vous souhaitez créer le nouveau dossier
3. Faites un clic droit sur une zone vide dans le répertoire
4. Sélectionnez Nouveau dossier dans le menu contextuel
5. Tapez le nom de dossier souhaité et appuyez sur Entrée

Raccourci clavier : Dans Nautilus, Ctrl+Shift+N crée instantanément un nouveau dossier sans utiliser le menu du clic droit.

Limitations de l’approche graphique :

• Impossible de définir des permissions personnalisées lors de la création — nécessite une action de suivi dans le terminal ou les propriétés du fichier
• Impossible de créer des structures imbriquées récursives en une seule opération
• Non disponible dans les environnements de serveur sans interface graphique (la grande majorité des serveurs Ubuntu de production fonctionnent sans environnement de bureau)

Pour tout travail sérieux d’administration de serveur, les méthodes en ligne de commande sont toujours préférées.

Méthode 8 : Scripting de la création de répertoires pour l’automatisation

Dans l’administration réelle de serveurs, les répertoires sont rarement créés manuellement un à la fois. Les scripts de mise en place, les pipelines de déploiement et les outils de gestion de configuration reposent tous sur la création automatisée de répertoires.

Exemple de script shell de base :

#!/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."

Bonnes pratiques de scripting :

• Utilisez toujours set -e pour interrompre en cas d’erreur
• Mettez toutes les variables entre guillemets ("$dir") pour gérer en toute sécurité les chemins avec des espaces
• Combinez mkdir -p avec chown et chmod dans le même script pour vous assurer que les permissions sont correctes immédiatement après la création
• Utilisez des tableaux pour les listes de répertoires afin de garder les scripts lisibles et maintenables

Cette approche est essentielle lors de la gestion de plusieurs hôtes virtuels, du déploiement d’applications dans différents environnements, ou de l’automatisation de la configuration de serveurs avec des outils comme Ansible ou des scripts de mise en place basés sur Bash.

Comparaison : options mkdir et leurs cas d’utilisation

Erreurs courantes et comment les corriger

Erreur : Permission denied

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

Cause : Vous tentez d’écrire dans un répertoire appartenant au système sans privilèges élevés.

Correction : Ajoutez sudo en préfixe :

sudo mkdir /etc/myapp

Erreur : No such file or directory

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

Cause : Un ou plusieurs répertoires intermédiaires dans le chemin n’existent pas.

Correction : Utilisez l’option -p :

mkdir -p /srv/app/config

Erreur : File exists

mkdir: cannot create directory 'mydir': File exists

Cause : Un répertoire ou un fichier avec ce nom existe déjà.

Correction : Utilisez -p pour supprimer cette erreur lorsque le chemin existant est un répertoire, ou choisissez un nom différent.

Échec silencieux dans les scripts : Si mkdir échoue et que votre script n’utilise pas set -e ou ne vérifie pas les codes de sortie, les opérations suivantes peuvent se poursuivre sur un chemin inexistant, causant des échecs imprévisibles. Validez toujours la création de répertoires critiques :

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

Considérations de sécurité pour la création de répertoires

Les permissions de répertoires constituent une première ligne de défense dans la sécurité des serveurs. Plusieurs vulnérabilités à fort impact découlent directement de permissions de répertoires incorrectes :

• Les répertoires accessibles en écriture par tous (777) permettent à n’importe quel utilisateur du système d’écrire, modifier ou supprimer des fichiers — un risque critique sur l’hébergement partagé ou les serveurs multi-utilisateurs
• Une propriété incorrecte sur les répertoires exposés au web peut permettre aux exploits d’applications web d’écrire des fichiers malveillants en dehors de la racine de document prévue
• Le bit sticky (chmod +t) sur les répertoires partagés (comme /tmp) empêche les utilisateurs de supprimer des fichiers appartenant à d’autres — définissez-le toujours sur les répertoires partagés accessibles en écriture
• Le bit SetGID sur les répertoires garantit que les nouveaux fichiers héritent du groupe du répertoire plutôt que du groupe principal de l’utilisateur créateur — utile pour les répertoires de projets collaboratifs

Exemple — répertoire de projet partagé sécurisé :

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

Lors de l’hébergement d’applications web, de domaines sécurisés par SSL, ou de services de messagerie, des permissions de répertoires appropriées sont indissociables de la posture de sécurité de votre configuration Certificats SSL et de votre configuration Hébergement Email.

Vérification de la création de répertoires

Après avoir créé des répertoires, vérifiez toujours le résultat avant de procéder aux opérations dépendantes.

Lister avec les permissions détaillées :

ls -la /path/to/parent/

Vérifier qu’un répertoire spécifique existe (utile dans les scripts) :

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

Afficher la structure arborescente complète (nécessite le paquet tree) :

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

Vérifier l’utilisation des inodes — sur les serveurs avec de nombreux petits fichiers, l’épuisement des inodes peut empêcher la création de répertoires même lorsque de l’espace disque est disponible :

df -i /srv/

Si l’utilisation des inodes est proche de 100%, vous ne pouvez pas créer de nouveaux répertoires ou fichiers quel que soit l’espace disque disponible. C’est un problème de production courant sur les serveurs hébergeant un grand nombre de petits fichiers, tels que les serveurs de messagerie ou les répertoires de sessions PHP.

Matrice de décision pratique : quelle méthode utiliser

Points techniques clés à retenir

• mkdir -p est la valeur par défaut la plus sûre pour toute création de répertoire scriptée ou automatisée — elle est idempotente et gère les chemins intermédiaires manquants
• N’utilisez jamais les permissions 777 sur les répertoires de production ; préférez 755 pour les chemins publics et 750 ou 700 pour les données sensibles
• L’option -m dans mkdir définit les permissions uniquement sur le répertoire final lorsqu’elle est utilisée avec -p — utilisez chmod -R ou des appels mkdir par niveau pour un contrôle complet
• L’expansion d’accolades est une fonctionnalité de Bash, pas une fonctionnalité de mkdir — elle ne fonctionnera pas dans les scripts /bin/sh sauf si le shell est Bash
• Vérifiez toujours la disponibilité des inodes (df -i) sur les systèmes de fichiers à haute densité avant la création en masse de répertoires
• Combinez la création de répertoires avec l’attribution immédiate de chown dans les scripts de mise en place pour éviter une fenêtre où les répertoires existent avec une propriété incorrecte
• Sur les environnements Panneaux de contrôle VPS, les utilisateurs du serveur web (généralement www-data ou nginx) doivent avoir la permission d’exécution sur chaque répertoire dans le chemin de la racine de document — pas seulement le répertoire final

FAQ

Quelle est la différence entre mkdir folder et mkdir -p folder ?

mkdir folder crée un seul répertoire et échoue si une partie du chemin n’existe pas ou si le répertoire existe déjà. mkdir -p folder crée tous les répertoires intermédiaires manquants et se termine silencieusement sans erreur si la cible existe déjà, ce qui le rend sûr pour les scripts et les exécutions répétées.

mkdir peut-il créer un répertoire avec des espaces dans le nom ?

Oui. Entourez le nom de guillemets : mkdir "my project folder" ou échappez les espaces : mkdir my project folder. Cependant, les espaces dans les noms de répertoires sont fortement déconseillés sur les serveurs car ils nécessitent un échappement dans chaque commande suivante et cassent de nombreux scripts shell et configurations d’applications.

Pourquoi mkdir échoue-t-il avec « Permission denied » même avec sudo ?

Cela se produit généralement lorsque le système de fichiers cible est monté en lecture seule, lorsque les politiques SELinux ou AppArmor restreignent les écritures sur ce chemin, ou lorsque le chemin est sur un système de fichiers réseau avec des restrictions côté serveur. Vérifiez les options de montage avec mount | grep /target/path et consultez les journaux AppArmor avec sudo aa-status.

Comment créer un répertoire et définir immédiatement son propriétaire et son groupe ?

mkdir lui-même ne définit pas la propriété — utilisez chown immédiatement après : mkdir -p /srv/app && chown www-data:www-data /srv/app. En un seul pipeline : install -d -m 755 -o www-data -g www-data /srv/app — la commande install crée des répertoires avec le propriétaire, le groupe et le mode en une seule étape.

Que se passe-t-il avec les permissions lors de l’utilisation de mkdir -p avec plusieurs nouveaux niveaux ?

Seul le répertoire final (le plus profond) reçoit le mode spécifié par -m. Tous les répertoires intermédiaires nouvellement créés reçoivent des permissions dérivées de l’umask actuel. Si des permissions cohérentes sur tous les niveaux sont requises, créez chaque niveau individuellement avec des options -m explicites ou appliquez chmod -R après la création du chemin complet.