DevOpsFacile
AccueilParcours de formationCertificationsModulesCheat SheetÀ Propos
DevOpsFacile

Une plateforme d'apprentissage complète pour maîtriser les pratiques DevOps modernes, du débutant à l'expert.

contact@devopsfacile.fr

Formation

  • Parcours de formation
  • Modules

Informations

  • À Propos
  • Conditions d'utilisation
  • Confidentialité
  • Mentions légales

© 2026 DevOps Facile. Tous droits réservés.

Fait avec pour la communauté DevOps

ModulesMaîtriser Linux : permissions, processus et paquets03 - Permissions et propriété des fichiers

Détails

  • 20 minutes
  • Intermédiaire

Objectifs

  • Lire et comprendre les permissions Linux
  • Modifier les permissions avec chmod
  • Changer la propriété avec chown
  • Appliquer les bonnes pratiques de sécurité
Module Maîtriser Linux : permissions, processus et paquets

Exercice 03 : Permissions et Propriété des Fichiers

🎯 Objectifs

À la fin de cet exercice, vous serez capable de :

  • ✅ Lire et interpréter les permissions affichées par ls -l
  • ✅ Modifier les permissions en notation numérique (755, 644...)
  • ✅ Modifier les permissions en notation symbolique (u+x, g-w...)
  • ✅ Changer le propriétaire et le groupe d'un fichier
  • ✅ Comprendre les implications de sécurité des permissions

Durée estimée : 20 minutes

Difficulté : ⭐⭐☆☆☆ (Débutant+)

Prérequis :

  • Avoir complété les exercices 01 et 02
  • Un terminal Linux avec accès sudo

📖 Contexte

Les permissions sont le système de sécurité fondamental de Linux. Elles déterminent qui peut lire, modifier ou exécuter chaque fichier. En DevOps, mal configurer les permissions peut :

  • Rendre un site web inaccessible
  • Exposer des données sensibles (clés SSH, mots de passe)
  • Empêcher un script de s'exécuter

Ce n'est pas un détail : c'est critique.


📋 Énoncé

Vous êtes administrateur d'un serveur web. Vous devez configurer correctement les permissions des fichiers du site, des scripts de déploiement et des clés d'accès pour que chaque utilisateur ait exactement les droits nécessaires - ni plus, ni moins.


🧭 Déroulement de l'exercice

Voici les grandes étapes à réaliser dans l'ordre. Chaque étape décrit ce que vous devez accomplir - à vous de trouver la commande. La solution complète est disponible si vous êtes bloqué.

Tâche 1 : Préparer l'environnement

Créez la structure suivante dans votre home : un dossier exercice-permissions/ contenant 3 sous-dossiers site-web/, scripts/, secrets/. Dans chacun, créez des fichiers représentatifs (fichiers HTML/CSS, un script shell, des fichiers de credentials).

Indice : Utilisez mkdir -p pour créer les dossiers en une fois. Le contenu exact des fichiers importe peu - l'important est qu'ils existent.

Vérification : ls -la exercice-permissions/ doit lister les 3 sous-dossiers et ls -la exercice-permissions/scripts/ doit montrer votre script.


Tâche 2 : Lire et interpréter les permissions

Affichez les permissions détaillées de tous vos fichiers. Analysez chaque colonne de la sortie de ls -l.

Indice : Le format des permissions est -rwxrwxrwx : le premier caractère est le type (- = fichier, d = répertoire), puis 3 groupes de 3 : propriétaire, groupe, autres. r=lecture, w=écriture, x=exécution.

Question à se poser : Que signifie 644 en notation octale ? Convertissez mentalement : 6=rw-, 4=r--, 4=r--. Qui peut lire ? Qui peut écrire ?

Vérification : Vous devez pouvoir lire les permissions de n'importe quel fichier et savoir qui peut faire quoi.


Tâche 3 : Configurer les permissions du site web

Les fichiers du site (site-web/) doivent être lisibles par tout le monde mais modifiables uniquement par le propriétaire. Utilisez la notation octale : 644 pour les fichiers, 755 pour les répertoires.

Indice : chmod accepte deux notations : symbolique (u+x, g-w...) et octale (755, 644...). Les 3 chiffres représentent : propriétaire, groupe, autres. Chaque chiffre est la somme de r(4)+w(2)+x(1).

Vérification : ls -l site-web/ doit afficher -rw-r--r-- pour les fichiers.


Tâche 4 : Rendre le script de déploiement exécutable

Le script scripts/deploy.sh doit pouvoir être lancé directement avec ./deploy.sh. Actuellement, le bit d'exécution est absent - ajoutez-le pour le propriétaire uniquement.

Indice : La notation symbolique est pratique ici : u+x ajoute le bit d'exécution pour le propriétaire (user) uniquement.

Vérification : Après modification, ls -l scripts/deploy.sh doit afficher -rwxr--r-- (ou similaire avec x pour le propriétaire). Tentez de lancer ./scripts/deploy.sh.


Tâche 5 : Protéger les fichiers sensibles

Les fichiers dans secrets/ contiennent des mots de passe et des clés API. Ils ne doivent être lisibles et modifiables QUE par le propriétaire - personne d'autre.

Indice : Le code octal pour "propriétaire seul peut lire et écrire, personne d'autre" est 600. Pour "propriétaire seul peut tout faire", c'est 700.

Question à se poser : Que se passe-t-il si les permissions d'une clé SSH sont trop permissives ? (Essayez de vous en souvenir ou testez.)

Vérification : ls -l secrets/ doit afficher -rw------- pour chaque fichier. Testez qu'un autre utilisateur ne peut pas les lire.


Tâche 6 : Vérifier la cohérence globale

Passez en revue toutes les permissions. Assurez-vous que chaque fichier a exactement les permissions dont il a besoin - ni plus, ni moins.

Indice : C'est le principe du moindre privilège : donner uniquement les permissions nécessaires à l'usage prévu. C'est un principe fondamental de sécurité.

Vérification : ls -lR exercice-permissions/ doit afficher une liste cohérente où chaque type de fichier a ses permissions appropriées.


� Mini-Projet : Sécuriser un environnement de déploiement

Vous allez configurer les permissions d'un environnement complet comme si vous prépariez un serveur de production.

Scénario : Vous préparez un serveur qui héberge une application web. Plusieurs types d'utilisateurs accèdent au serveur : le développeur (vous), le serveur web (www-data), et le script de déploiement automatisé.

Ce que vous devez réaliser :

  1. Créez l'arborescence suivante :
secure-deploy/
├── public/          # Servi par le serveur web
│   ├── index.html
│   └── style.css
├── private/         # Données internes
│   └── database.conf
├── scripts/
│   └── deploy.sh
└── logs/
    └── app.log
  1. Créez chaque fichier avec du contenu fictif
  2. Appliquez les permissions suivantes :
  • public/ et ses fichiers : lisibles par tout le monde (755 / 644)
  • private/database.conf : lisible uniquement par le propriétaire (600)
  • scripts/deploy.sh : exécutable par le propriétaire, lisible par le groupe (750)
  • logs/app.log : modifiable par le propriétaire, lisible par le groupe (640)
  1. Vérifiez chaque permission avec ls -l
  2. Tentez de lire private/database.conf avec un compte différent (ou vérifiez que les permissions interdisent la lecture par les "others")

Checkpoints de validation :

  • ls -l public/ affiche -rw-r--r-- pour index.html et style.css
  • ls -l private/database.conf affiche -rw-------
  • ls -l scripts/deploy.sh affiche -rwxr-x---
  • ls -l logs/app.log affiche -rw-r-----
  • ls -ld public/ affiche drwxr-xr-x
  • Le fichier private/database.conf n'est pas accessible en lecture pour les "others" (les 3 derniers bits de permission sont ---)

�📚 Étapes Détaillées

Étape 1 : Préparer l'Environnement

Instructions :

  1. Créez un espace de travail :
bash
cd ~
mkdir -p exercice-permissions/{site-web,scripts,secrets}
cd exercice-permissions
  1. Créez des fichiers de test :
bash
echo "<h1>Bienvenue</h1>" > site-web/index.html
echo "body { color: #333; }" > site-web/style.css
echo '#!/bin/bash' > scripts/deploy.sh
echo 'echo "Déploiement en cours..."' >> scripts/deploy.sh
echo "DB_PASSWORD=SuperSecret123" > secrets/db-credentials.txt
echo "API_KEY=sk-abcdef123456" > secrets/api-key.txt

Étape 2 : Lire les Permissions

Objectif : Interpréter la sortie de ls -l

Instructions :

  1. Affichez les permissions de tous les fichiers :
bash
ls -la site-web/
ls -la scripts/
ls -la secrets/
  1. Concentrez-vous sur la première colonne. Prenons un exemple :
-rw-r--r-- 1 alice alice 21 Apr 10 10:00 index.html

Décomposition :

-  rw-  r--  r--
│  │    │    └── Autres (o) : lecture seule
│  │    └── Groupe (g) : lecture seule
│  └── Propriétaire (u) : lecture + écriture
└── Type (- = fichier, d = dossier, l = lien)
  1. Convertissez mentalement en notation numérique :
rw- = 4+2+0 = 6
r-- = 4+0+0 = 4
r-- = 4+0+0 = 4
→ 644
  1. Vérifiez avec stat pour voir la notation numérique directement :
bash
stat -c "%a %n" site-web/index.html

Résultat attendu :

644 site-web/index.html

Étape 3 : Modifier les Permissions - Notation Numérique

Objectif : Utiliser chmod avec des chiffres

Instructions :

  1. Le script de déploiement doit être exécutable par le propriétaire :
bash
ls -l scripts/deploy.sh
chmod 755 scripts/deploy.sh
ls -l scripts/deploy.sh

Résultat attendu :

-rwxr-xr-x 1 alice alice ... deploy.sh

755 signifie :

  • Propriétaire : lecture + écriture + exécution (7)
  • Groupe : lecture + exécution (5)
  • Autres : lecture + exécution (5)
  1. Testez que le script est bien exécutable :
bash
./scripts/deploy.sh

Résultat attendu :

Déploiement en cours...
  1. Les fichiers secrets doivent être lisibles uniquement par le propriétaire :
bash
chmod 600 secrets/db-credentials.txt
chmod 600 secrets/api-key.txt
ls -l secrets/

Résultat attendu :

-rw------- 1 alice alice ... db-credentials.txt
-rw------- 1 alice alice ... api-key.txt

600 signifie : seul le propriétaire peut lire et écrire. Personne d'autre.

  1. Les fichiers du site web doivent être lisibles par tout le monde mais modifiables seulement par le propriétaire :
bash
chmod 644 site-web/index.html
chmod 644 site-web/style.css
ls -l site-web/

Étape 4 : Modifier les Permissions - Notation Symbolique

Objectif : Utiliser chmod avec des lettres

Instructions :

  1. Créez un nouveau script :
bash
echo '#!/bin/bash' > scripts/backup.sh
echo 'echo "Backup en cours..."' >> scripts/backup.sh
  1. Ajoutez le droit d'exécution pour le propriétaire :
bash
ls -l scripts/backup.sh
chmod u+x scripts/backup.sh
ls -l scripts/backup.sh

Résultat attendu : Le x apparaît dans les permissions du propriétaire.

  1. Retirez l'accès en lecture pour les autres :
bash
chmod o-r scripts/backup.sh
ls -l scripts/backup.sh
  1. Donnez la lecture à tout le monde :
bash
chmod a+r scripts/backup.sh
ls -l scripts/backup.sh

Aide-mémoire de la notation symbolique :

CommandeSignification
u+xAjouter exécution au propriétaire
g-wRetirer écriture au groupe
o-rwxRetirer tout aux autres
a+rAjouter lecture pour tout le monde
u=rwx,go=rxPropriétaire : tout, Groupe et Autres : lecture + exécution

Étape 5 : Modifier la Propriété

Objectif : Utiliser chown et chgrp

Instructions :

Note : chown nécessite sudo. Si vous n'avez pas sudo, lisez les étapes et comprenez les commandes.

  1. Voir le propriétaire actuel :
bash
ls -l site-web/index.html
  1. Changer le propriétaire (simulation d'un serveur web) :
bash
sudo chown root site-web/index.html
ls -l site-web/index.html

Résultat attendu : Le propriétaire est maintenant root.

  1. Changer le propriétaire ET le groupe en une fois :
bash
sudo chown root:root site-web/style.css
ls -l site-web/style.css
  1. Restaurer vos fichiers :
bash
sudo chown -R $USER:$USER site-web/
ls -l site-web/

L'option -R applique le changement récursivement à tout le contenu du dossier.


Étape 6 : Permissions sur les Répertoires

Objectif : Comprendre que les permissions fonctionnent différemment sur les dossiers

Instructions :

  1. Créez un dossier de test :
bash
mkdir test-dossier
echo "fichier secret" > test-dossier/secret.txt
  1. Retirez le droit d'exécution du dossier :
bash
chmod 644 test-dossier
ls test-dossier/

Résultat attendu : Une erreur ! Le droit x sur un dossier signifie "pouvoir entrer dedans".

ls: cannot access 'test-dossier/secret.txt': Permission denied
  1. Restaurez le droit :
bash
chmod 755 test-dossier
ls test-dossier/

Leçon clé : Sur un dossier, x = droit de traverser (entrer), r = droit de lister, w = droit de créer/supprimer des fichiers.


Étape 7 : Cas Pratiques DevOps

Objectif : Appliquer les permissions dans des scénarios réels

Instructions :

  1. Clé SSH - doit être 600 obligatoirement :
bash
echo "MA_FAUSSE_CLE_PRIVEE" > secrets/id_rsa
chmod 600 secrets/id_rsa
stat -c "%a %n" secrets/id_rsa

SSH refusera de fonctionner si votre clé privée a des permissions trop permissives. C'est un contrôle de sécurité.

  1. Script exécutable - 755 :
bash
stat -c "%a %n" scripts/deploy.sh
  1. Fichier de configuration - 644 :
bash
stat -c "%a %n" site-web/index.html
  1. Vérifiez toutes les permissions du projet :
bash
find . -type f -exec stat -c "%a %n" {} \;

Résultat attendu (résumé) :

644 ./site-web/index.html
644 ./site-web/style.css
755 ./scripts/deploy.sh
7xx ./scripts/backup.sh
600 ./secrets/db-credentials.txt
600 ./secrets/api-key.txt
600 ./secrets/id_rsa

Étape 8 : Nettoyage

bash
cd ~
rm -r exercice-permissions

✅ Vérification Finale

  1. Que signifie chmod 644 ? → rw-r--r-- (propriétaire lit/écrit, les autres lisent seulement)
  2. Que signifie le x sur un dossier ? → Permission d'entrer dans le dossier
  3. Comment rendre un script exécutable ? → chmod +x script.sh ou chmod 755 script.sh
  4. Quelle permission pour une clé SSH privée ? → 600
  5. Comment changer le propriétaire d'un dossier et de son contenu ? → sudo chown -R user:group dossier/

📖 Pour Aller Plus Loin

  • Étudiez le umask : umask détermine les permissions par défaut des nouveaux fichiers. Tapez umask pour voir le masque actuel.
  • Étudiez les permissions spéciales : SUID (chmod u+s), SGID (chmod g+s), Sticky bit (chmod +t).
  • Consultez man chmod pour la documentation complète.
Retour au module

Sur cette page

  • 🎯 Objectifs
  • 📖 Contexte
  • 📋 Énoncé
  • 🧭 Déroulement de l'exercice
  • Tâche 1 : Préparer l'environnement
  • Tâche 2 : Lire et interpréter les permissions
  • Tâche 3 : Configurer les permissions du site web
  • Tâche 4 : Rendre le script de déploiement exécutable
  • Tâche 5 : Protéger les fichiers sensibles
  • Tâche 6 : Vérifier la cohérence globale
  • � Mini-Projet : Sécuriser un environnement de déploiement
  • �📚 Étapes Détaillées
  • Étape 1 : Préparer l'Environnement
  • Étape 2 : Lire les Permissions
  • Étape 3 : Modifier les Permissions - Notation Numérique
  • Étape 4 : Modifier les Permissions - Notation Symbolique
  • Étape 5 : Modifier la Propriété
  • Étape 6 : Permissions sur les Répertoires
  • Étape 7 : Cas Pratiques DevOps
  • Étape 8 : Nettoyage
  • ✅ Vérification Finale
  • 📖 Pour Aller Plus Loin