Maîtrise du système de fichiers Linux : Navigation, gestion et manipulation

Introduction

Bienvenue dans l'atelier d'initiation aux opérations sur les fichiers et répertoires Linux ! Si vous débutez sur Linux, ne vous inquiétez pas : nous vous accompagnerons à chaque étape, en expliquant non seulement les actions à accomplir, mais aussi leur raison d'être. Cet atelier est conçu pour vous offrir une expérience pratique du système de fichiers Linux, un pilier fondamental pour quiconque souhaite maîtriser cet environnement.

Avant de commencer, passons en revue quelques concepts de base :

Système de fichiers Linux : Imaginez une structure en arborescence qui organise tous les fichiers de votre ordinateur. Contrairement à Windows et ses lettres de lecteurs (C:, D:, etc.), Linux possède un répertoire racine unique (/) d'où partent toutes les autres branches.
Répertoire (Directory) : C'est le terme Linux pour désigner ce que vous connaissez peut-être sous le nom de "dossier" dans d'autres systèmes. C'est un conteneur pour les fichiers et d'autres répertoires.
Fichier (File) : Sous Linux, presque tout est considéré comme un fichier ! Les documents classiques, les répertoires, et même les périphériques matériels sont traités comme des fichiers. Cette approche unifiée simplifie de nombreuses opérations.
Chemin (Path) : Il s'agit de l'adresse d'un fichier ou d'un répertoire. Nous verrons les chemins absolus (qui partent de la racine) et les chemins relatifs (qui partent de votre emplacement actuel).
Terminal : C'est votre centre de commande pour interagir avec Linux. Cela peut paraître intimidant au début, mais vous découvrirez vite que c'est un outil d'une puissance redoutable pour gérer votre système.
Recherche de fichiers : Linux propose des outils performants pour localiser des fichiers dans tout le système. Nous explorerons des commandes comme find et which pour vous aider à trouver rapidement des documents ou des programmes.

Prêt à commencer ? Débutons notre exploration du système de fichiers Linux !

Exploration de la structure des répertoires Linux

Dans cette étape, nous allons faire le tour du système de fichiers Linux. Cela vous aidera à comprendre où sont stockés les différents types de fichiers et comment le système est organisé.

Ouvrez votre terminal. Vous devriez voir une invite de commande se terminant par le signe $. C'est ici que vous taperez vos commandes. Vous vous trouvez actuellement dans votre répertoire de projet, qui est /home/labex/project. Vérifions cela :
```
pwd
```
pwd signifie "print working directory" (afficher le répertoire de travail). Cette commande vous indique exactement où vous vous situez.
Maintenant, visualisons l'ensemble de la structure des répertoires :
```
tree /
```
Impressionnant, n'est-ce pas ? La commande tree affiche l'arborescence des répertoires de manière visuelle. L'argument / lui demande de commencer à partir de la racine. Ne vous souciez pas de tout comprendre immédiatement, nous allons nous concentrer sur l'essentiel.
Explorons quelques répertoires principaux :
```
ls /home
ls /etc
ls /bin
```
- /home est l'endroit où sont stockés les répertoires personnels des utilisateurs. Chaque utilisateur y possède généralement son propre espace.
- /etc contient les fichiers de configuration du système.
- /bin contient les fichiers binaires (programmes) essentiels qui doivent être accessibles à tous les utilisateurs.
Naviguons maintenant vers le répertoire racine et listons son contenu :
```
cd /
ls -l
```
cd signifie "change directory" (changer de répertoire). Le / vous emmène à la racine. ls -l liste le contenu du répertoire avec des détails. Le -l est une option (ou "flag") qui modifie le comportement de la commande pour afficher plus d'informations.
Revenons à votre répertoire personnel :
```
cd ~
pwd
```
Le symbole ~ est un raccourci qui représente toujours votre répertoire personnel (home), peu importe où vous vous trouvez dans le système.

À l'issue de cette étape, vous devriez avoir une compréhension de base de la structure des répertoires Linux et savoir comment vous y déplacer. N'oubliez pas qu'il n'est pas nécessaire de tout mémoriser : vous pourrez toujours utiliser ces commandes pour vous repérer.

Maintenant que nous avons une vue d'ensemble, apprenons à naviguer efficacement. Nous allons explorer les concepts de chemins absolus et relatifs, cruciaux pour se déplacer dans le système de fichiers.

Tout d'abord, créons une structure de répertoires pour nous exercer :
```
mkdir -p ~/project/practice/subdirectory
```
mkdir signifie "make directory" (créer un répertoire). L'option -p permet de créer les répertoires parents s'ils n'existent pas encore. Cette commande crée un répertoire practice dans votre dossier project, et un subdirectory à l'intérieur de practice.
Naviguez vers ce nouveau sous-répertoire en utilisant un chemin relatif :
```
cd ~/project/practice/subdirectory
pwd
```
Ce chemin est relatif à votre répertoire personnel (~). On l'appelle chemin relatif car il dépend de votre point de départ.
Remontons maintenant d'un niveau dans l'arborescence :
```
cd ..
pwd
```
.. fait toujours référence au répertoire parent. C'est un raccourci très pratique pour remonter dans l'arborescence.
Utilisons un chemin absolu pour retourner dans le sous-répertoire :
```
cd /home/labex/project/practice/subdirectory
pwd
```
C'est un chemin absolu car il commence depuis la racine (/) et donne l'itinéraire complet jusqu'à la destination, quel que soit l'endroit où vous vous trouvez.

Pratiquons quelques raccourcis de navigation :

cd ~ ## Aller au répertoire personnel
pwd
cd - ## Retourner au répertoire précédent
pwd
cd ## Une autre façon d'aller au répertoire personnel
pwd

Ces raccourcis vous feront gagner beaucoup de temps de saisie !

À la fin de cette étape, vous devriez être à l'aise avec la navigation via les chemins absolus et relatifs. La pratique est la clé, alors n'hésitez pas à expérimenter !

Création et gestion de fichiers et répertoires

Maintenant que la navigation n'a plus de secret pour vous, apprenons à créer et gérer des fichiers et des répertoires. Ce sont des compétences fondamentales sous Linux.

Allez dans votre répertoire de projet :
```
cd ~/project
```
Créons plusieurs répertoires d'un coup :
```
mkdir dir1 dir2 dir3
ls
```
mkdir peut créer plusieurs dossiers en une seule commande. ls affiche le contenu actuel pour confirmer la création.
Créons maintenant un fichier vide :
```
touch file1.txt
ls -l file1.txt
```
touch est utilisé pour créer des fichiers vides ou mettre à jour la date de modification de fichiers existants. ls -l montre que la taille du fichier est de 0 octet.
Créons un fichier contenant du texte :
```
echo "Hello, Linux" > file2.txt
cat file2.txt
```
echo affiche du texte, et > redirige ce texte vers un fichier, en le créant s'il n'existe pas. cat permet de visualiser le contenu du fichier.
Ajoutons maintenant du contenu à ce fichier :
```
echo "This is a new line." >> file2.txt
cat file2.txt
```
>> ajoute du texte à la fin du fichier au lieu de l'écraser. Notez que le fichier contient désormais deux lignes.
Enfin, créons une structure imbriquée :
```
mkdir -p nested/structure/example
tree nested
```
La commande tree nous donne une belle représentation visuelle de ce que nous venons de créer.

À l'issue de cette étape, vous saurez créer des fichiers et dossiers, y ajouter du contenu et les consulter. Ces opérations constituent la base de la gestion de fichiers.

Copier, déplacer et renommer des fichiers

Apprenons maintenant à manipuler nos fichiers et répertoires : les copier, les déplacer et les renommer.

Commençons par copier un fichier :
```
cp file1.txt dir1/
ls dir1
```
cp est la commande de copie. Ici, nous copions file1.txt dans le répertoire dir1.
Copions et renommons un fichier en une seule opération :
```
cp file2.txt dir2/file2_copy.txt
ls dir2
```
Cela crée une copie de file2.txt dans dir2, mais avec un nouveau nom.
Déplaçons un fichier :
```
mv file1.txt dir3/
ls
ls dir3
```
mv sert à déplacer des fichiers. Remarquez que file1.txt a disparu du répertoire actuel pour apparaître dans dir3.
Utilisons aussi mv pour renommer un fichier :
```
mv dir3/file1.txt dir3/renamed_file.txt
ls dir3
```
Ici, on renomme file1.txt en renamed_file.txt à l'intérieur de dir3.
Enfin, copions un répertoire entier et son contenu :
```
cp -r nested dir1/
tree dir1
```
L'option -r (récursif) indique à cp de copier le répertoire ainsi que tous ses sous-répertoires et fichiers.

N'oubliez pas que pour déplacer ou copier, vous pouvez utiliser des chemins absolus ou relatifs selon ce qui est le plus pratique sur le moment.

Visualisation et édition du contenu des fichiers

Dans cette dernière étape, nous allons découvrir des méthodes avancées pour consulter le contenu des fichiers et apprendre à les modifier avec un éditeur de texte simple.

Créons un nouveau fichier de plusieurs lignes en utilisant un "here-document" :
```
cat << EOF > multiline.txt
Line 1: Hello, Linux
Line 2: This is a multiline file.
Line 3: Created using a here-document.
EOF
```
Le "here-document" est un moyen pratique de créer des fichiers avec un contenu prédéfini directement depuis le terminal. L'opérateur << est suivi d'un délimiteur (ici EOF). Le shell lit ensuite tout ce que vous tapez jusqu'à rencontrer à nouveau ce délimiteur seul sur une ligne. Tout ce bloc est envoyé dans multiline.txt.
Visualisez le contenu du fichier :
```
cat multiline.txt
```
cat est idéal pour un coup d'œil rapide sur le contenu.
Affichez le fichier avec les numéros de lignes :
```
nl multiline.txt
```
nl numérote les lignes, ce qui est très utile pour faire référence à des passages précis.
Affichez les deux premières lignes du fichier :
```
head -n 2 multiline.txt
```
La commande head affiche le début d'un fichier. L'option -n 2 limite l'affichage aux deux premières lignes. Notez que -n2 (sans espace) fonctionne également.
Affichez la dernière ligne du fichier :
```
tail -n 1 multiline.txt
```
À l'inverse, tail affiche la fin d'un fichier. Là encore, -n 1 et -n1 sont équivalents.
Maintenant, éditons le fichier avec nano :
```
nano multiline.txt
```
Nano est un éditeur de texte simple. Utilisez les flèches du clavier pour naviguer, tapez votre texte, et suivez les commandes en bas de l'écran (le symbole ^ signifie la touche Ctrl).

Ajoutez une quatrième ligne, puis sauvegardez et quittez (Ctrl+X, puis Y, puis Entrée).
Vérifiez les modifications :
```
cat multiline.txt
```
Vous devriez voir votre nouvelle ligne apparaître.

Ces commandes sont des outils puissants pour inspecter et modifier des fichiers directement depuis la ligne de commande.

Recherche de fichiers sous Linux

Savoir trouver rapidement un fichier est une compétence essentielle. Apprenons les commandes courantes pour localiser des éléments.

Utilisons d'abord find pour chercher tous les fichiers .txt dans le répertoire actuel et ses sous-répertoires :
```
find . -name "*.txt"
```
Cette commande liste tous les fichiers se terminant par .txt. Si rien ne s'affiche, c'est qu'il n'y en a pas. Créons-en un pour tester :
```
echo "This is a test file" > test.txt
find . -name "*.txt"
```
Vous devriez maintenant voir ./test.txt dans les résultats.
Cherchons maintenant un fichier spécifique dans tout le système :
```
sudo find / -name "passwd"
```
Cette commande cherche les fichiers nommés "passwd" partout. Nous utilisons sudo car la recherche à partir de la racine (/) nécessite des privilèges élevés pour accéder à certains répertoires système protégés.

Vous devriez voir des résultats comme :
```
/etc/pam.d/passwd
/etc/passwd
/usr/bin/passwd
/usr/share/doc/passwd
/usr/share/lintian/overrides/passwd
```
find est très polyvalent. On peut chercher par taille. Par exemple, trouvons les fichiers de plus de 1 Mo dans votre répertoire personnel :
```
find ~ -size +1M
```
On peut aussi chercher par date de modification. Trouvons les fichiers modifiés au cours des dernières 24 heures dans votre répertoire personnel :
```
find ~ -mtime -1
```
Enfin, utilisons which pour localiser un programme exécutable :
```
which python
```
Vous devriez obtenir un chemin comme :
```
/usr/bin/python
```
Si cela ne renvoie rien, essayez avec which python3.

Grâce à ces commandes, vous pourrez localiser n'importe quel élément. find est particulièrement puissant car ses nombreuses options peuvent être combinées pour affiner vos recherches.

Résumé

Félicitations ! Vous avez terminé l'atelier d'initiation aux opérations sur les fichiers et répertoires Linux. Récapitulons vos nouveaux acquis :

Vous avez exploré la structure des répertoires Linux et compris le rôle de dossiers clés comme /home, /etc et /bin.
Vous avez appris la différence entre chemins absolus et relatifs, et comment naviguer efficacement avec cd et les raccourcis ~ et ...
Vous avez pratiqué la création de fichiers et de dossiers avec mkdir, touch et echo.
Vous maîtrisez la manipulation de fichiers : copier, déplacer et renommer avec cp et mv.
Vous savez consulter le contenu des fichiers avec cat, head et tail, et les modifier avec l'éditeur nano.
Enfin, vous avez découvert des techniques de recherche puissantes avec find et which.

Ces compétences constituent le socle de votre travail sous Linux. En continuant votre apprentissage, vous vous appuierez sur ces bases pour réaliser des opérations plus complexes et des tâches d'administration système.

Le secret de la maîtrise est la pratique. N'ayez pas peur d'expérimenter dans votre environnement Linux : créez vos propres structures, déplacez des fichiers, modifiez-les et cherchez-les en variant les critères. Plus vous pratiquerez, plus la ligne de commande vous semblera naturelle.

Bonne continuation dans votre exploration de Linux !

Opérations sur les fichiers et les répertoires