Comment supprimer les fichiers mis en cache avec Git

Introduction

Git est un puissant système de contrôle de version qui aide les développeurs à gérer l'historique des fichiers de leurs projets. Il arrive parfois que des fichiers soient mis en cache dans le dépôt et que nous ne voulions plus que Git les suive, tout en souhaitant les conserver dans notre répertoire local. La commande git rm --cached nous permet de supprimer des fichiers du système de suivi de Git tout en les préservant dans notre répertoire de travail. Ce tutoriel vous apprendra à utiliser efficacement cette commande pour nettoyer votre dépôt et optimiser votre flux de travail.

Création d'un dépôt Git d'exemple

Pour comprendre comment supprimer des fichiers mis en cache de Git, configurons d'abord un dépôt d'exemple avec quelques fichiers. Cela nous aidera à voir comment la mise en cache de Git fonctionne en pratique.

Comprendre la mise en cache de Git

Lorsque vous ajoutez des fichiers à Git en utilisant la commande git add, Git stocke ces fichiers dans son index (également appelé la zone de staging). Ces fichiers sont maintenant "mis en cache" (cached) ou préparés (staged), en attente d'être commités dans le dépôt. Parfois, vous souhaiterez désindexer ces fichiers ou les supprimer du suivi de Git sans les supprimer de votre système de fichiers local.

Configuration de notre dépôt

Créons un simple dépôt Git pour travailler avec :

1. Ouvrez une fenêtre de terminal dans l'environnement de la machine virtuelle LabEx.
2. Naviguez vers le répertoire du projet :

cd ~/project

3. Créez un nouveau répertoire pour notre dépôt de test :

mkdir git-cache-demo
cd git-cache-demo

4. Initialisez un nouveau dépôt Git :

git init

Vous devriez voir une sortie similaire à celle-ci :

Initialized empty Git repository in /home/labex/project/git-cache-demo/.git/

5. Configurez vos informations utilisateur Git (obligatoire pour les commits) :

git config user.name "LabEx User"
git config user.email "labex@example.com"

Nous avons maintenant un nouveau dépôt Git prêt à ajouter des fichiers. Dans l'étape suivante, nous allons créer des fichiers et les ajouter au système de suivi de Git, ce qui nous permettra de nous entraîner à les supprimer du cache plus tard.

Ajout de fichiers au dépôt

Maintenant que nous avons configuré notre dépôt Git, créons quelques fichiers et ajoutons-les au système de suivi de Git. Cela nous aidera à comprendre ce que signifie pour un fichier d'être "mis en cache" (cached) dans Git.

Création et ajout de fichiers

1. Tout d'abord, créons quelques types de fichiers différents dans notre dépôt :

## Create a text file
echo "This is a sample text file" > sample.txt

## Create a config file
echo "debug=true" > config.ini

## Create a log file (which we typically don't want to track)
echo "2023-01-01: System started" > app.log

2. Vérifiez l'état de notre dépôt :

git status

Vous devriez voir une sortie similaire à celle-ci :

On branch master

No commits yet

Untracked files:
  (use "git add <file>..." to include in what will be committed)
	app.log
	config.ini
	sample.txt

nothing added to commit but untracked files present (use "git add" to track)

Cela montre que nous avons trois fichiers que Git reconnaît, mais ils ne sont pas encore suivis.

3. Ajoutons tous les fichiers à la zone de staging (cache) de Git :

git add .

4. Vérifiez à nouveau l'état :

git status

Maintenant, vous devriez voir :

On branch master

No commits yet

Changes to be committed:
  (use "git rm --cached <file>..." to unstage)
	new file:   app.log
	new file:   config.ini
	new file:   sample.txt

Remarquez que Git nous dit maintenant que nous pouvons utiliser git rm --cached <file> pour désindexer les fichiers. Les fichiers sont maintenant mis en cache dans la zone de staging de Git, en attente d'être commités.

5. Committons ces fichiers pour les intégrer à l'historique de notre dépôt :

git commit -m "Initial commit with sample files"

Vous avez maintenant ajouté avec succès des fichiers au système de suivi de Git. Dans l'étape suivante, nous allons apprendre à supprimer des fichiers spécifiques du cache de Git tout en les conservant dans notre répertoire local.

Suppression d'un seul fichier du cache de Git

Maintenant que nous avons des fichiers suivis par Git, apprenons à supprimer un fichier spécifique du suivi de Git tout en le conservant dans notre répertoire local. C'est un besoin courant lorsque vous commettez accidentellement des fichiers qui devraient être exclus, tels que des fichiers journaux, des fichiers temporaires ou des fichiers contenant des informations sensibles.

Pourquoi supprimer des fichiers du cache de Git

Il existe plusieurs raisons pour lesquelles vous pourriez vouloir supprimer un fichier du cache de Git :

1. Vous avez accidentellement ajouté un fichier contenant des informations sensibles.
2. Vous souhaitez exclure de gros fichiers binaires comme les journaux ou les fichiers compilés.
3. Vous configurez un fichier .gitignore et devez supprimer des fichiers déjà suivis.

Suppression de app.log du suivi de Git

Imaginons que nous ayons réalisé que le fichier app.log ne devrait pas être suivi par Git :

1. Tout d'abord, vérifions que Git suit actuellement le fichier :

git ls-files

Vous devriez voir les trois fichiers listés :

app.log
config.ini
sample.txt

2. Maintenant, supprimons app.log du système de suivi de Git tout en le conservant dans notre répertoire local :

git rm --cached app.log

Vous verrez un message de confirmation :

rm 'app.log'

3. Vérifiez à nouveau l'état :

git status

Vous verrez que app.log est maintenant listé comme un fichier non suivi :

On branch master
Changes to be committed:
  (use "git restore --staged <file>..." to unstage)
	deleted:    app.log

Untracked files:
  (use "git add <file>..." to include in what will be committed)
	app.log

Cela signifie que Git cessera de suivre le fichier lors du prochain commit, mais le fichier existe toujours dans votre répertoire local.

4. Vérifions que le fichier existe toujours dans notre répertoire de travail :

ls -la

Vous devriez voir que app.log est toujours là.

5. Commitez ce changement pour finaliser la suppression du fichier du suivi de Git :

git commit -m "Remove app.log from Git tracking"

6. Vérifiez que Git ne suit plus le fichier :

git ls-files

Maintenant, vous devriez seulement voir :

config.ini
sample.txt

Mais le fichier app.log existe toujours dans votre répertoire local :

cat app.log

Sortie :

2023-01-01: System started

Félicitations ! Vous avez réussi à supprimer un fichier du cache de Git tout en le conservant dans votre répertoire local. Dans l'étape suivante, nous allons apprendre à gérer plusieurs fichiers et à améliorer notre flux de travail avec .gitignore.

Travailler avec plusieurs fichiers et répertoires

Maintenant que nous savons comment supprimer un seul fichier du cache de Git, explorons des scénarios plus complexes comme la suppression de plusieurs fichiers ou de répertoires entiers.

Création de plus de fichiers pour la pratique

Créons d'abord quelques fichiers supplémentaires et une structure de répertoires pour nous entraîner :

1. Créez un répertoire et quelques fichiers supplémentaires :

## Create a directory for temporary files
mkdir temp

## Create some files in the temp directory
echo "This is a temporary file" > temp/temp1.txt
echo "Another temporary file" > temp/temp2.txt

## Create another log file in the main directory
echo "2023-01-02: System updated" > system.log

2. Ajoutez ces nouveaux fichiers au suivi de Git :

git add .

3. Commitez les changements :

git commit -m "Add temporary files and system log"

4. Vérifiez que Git suit tous les fichiers :

git ls-files

Vous devriez voir :

app.log
config.ini
sample.txt
system.log
temp/temp1.txt
temp/temp2.txt

Suppression de plusieurs fichiers du cache de Git

Disons maintenant que nous voulons supprimer tous les fichiers journaux et l'intégralité du répertoire temp du suivi de Git.

1. Supprimez le fichier journal du suivi de Git :

git rm --cached system.log

2. Supprimez tous les fichiers du répertoire temp de manière récursive :

git rm --cached -r temp/

L'option -r est importante ici car elle indique à Git de supprimer de manière récursive tous les fichiers du répertoire de son cache.

3. Vérifiez l'état :

git status

Vous verrez que le fichier journal et tous les fichiers du répertoire temp sont préparés pour être supprimés du système de suivi de Git :

On branch master
Changes to be committed:
(use "git restore --staged <file>..." to unstage)
	deleted:    system.log
	deleted:    temp/temp1.txt
	deleted:    temp/temp2.txt

Untracked files:
(use "git add <file>..." to include in what will be committed)
	system.log
	temp/

4. Commitez ces changements :

git commit -m "Remove logs and temp directory from Git tracking"

5. Vérifiez que Git ne suit plus ces fichiers :

git ls-files

Maintenant, vous devriez seulement voir :

app.log
config.ini
sample.txt

Cependant, tous les fichiers existent toujours dans votre répertoire local :

ls -la
ls -la temp/

Utilisation de .gitignore pour empêcher le suivi des fichiers indésirables

Maintenant que nous avons supprimé les fichiers du suivi de Git, configurons un fichier .gitignore pour les empêcher d'être accidentellement ajoutés à nouveau :

1. Créez un fichier .gitignore :

nano .gitignore

2. Ajoutez les motifs suivants au fichier :

## Ignore log files
*.log

## Ignore temp directory
temp/

3. Enregistrez et quittez (appuyez sur Ctrl+X, puis Y, puis Entrée)

4. Ajoutez et commitez le fichier .gitignore :

git add .gitignore
git commit -m "Add .gitignore file"

Maintenant, même si vous essayez d'ajouter tous les fichiers à Git, il respectera votre fichier .gitignore et ne suivra pas les motifs spécifiés :

git add .
git status

Vous devriez voir que les fichiers journaux et le répertoire temp ne sont pas ajoutés au suivi de Git.

Vous avez maintenant appris comment supprimer plusieurs fichiers et répertoires du cache de Git et comment empêcher des fichiers spécifiques d'être suivis à l'avenir en utilisant un fichier .gitignore.

Techniques avancées et meilleures pratiques

Maintenant que vous comprenez les bases de la suppression de fichiers du cache de Git, explorons quelques techniques avancées et les meilleures pratiques pour améliorer votre flux de travail.

Suppression et ignore des fichiers en une seule étape

Si vous avez des fichiers qui sont déjà suivis par Git et que vous souhaitez à la fois les supprimer du suivi et les ajouter à votre fichier .gitignore, vous pouvez utiliser cette approche efficace :

1. Créons un nouveau type de fichier que nous voulons ignorer :

## Create a build directory with some compiled files
mkdir build
echo "Compiled binary data" > build/app.bin
echo "Configuration for build" > build/build.conf

2. Ajoutez ces fichiers à Git :

git add build/
git commit -m "Add build files temporarily"

3. Supprimons-les maintenant du suivi de Git et mettons à jour notre fichier .gitignore en un seul flux de travail :

## First, edit the .gitignore file to add the build directory
echo "## Ignore build directory" >> .gitignore
echo "build/" >> .gitignore

## Now remove the tracked files from Git's cache
git rm --cached -r build/

## Commit both changes together
git add .gitignore
git commit -m "Remove build directory from tracking and add to .gitignore"

4. Vérifiez que les fichiers ne sont plus suivis mais existent toujours localement :

git ls-files
ls -la build/

Gestion des informations sensibles

Si vous avez accidentellement commis un fichier contenant des informations sensibles telles que des mots de passe ou des clés API, le supprimer du cache de Git n'est que la première étape. Git conserve un historique de tous les commits, de sorte que les informations sensibles existent toujours dans l'historique de votre dépôt.

Pour les informations sensibles, vous devrez :

1. Supprimer le fichier du cache de Git comme nous l'avons appris.
2. Modifier tous les mots de passe ou clés compromis.
3. Envisager d'utiliser des outils comme git filter-branch ou BFG Repo-Cleaner pour supprimer les données sensibles de l'historique.

Cela dépasse le cadre de ce tutoriel, mais il est important d'être conscient de cette limitation.

Meilleures pratiques pour la gestion du cache Git

Voici quelques bonnes pratiques à suivre :

1. Créez un bon fichier .gitignore dès le début de votre projet : Cela empêche le suivi accidentel de fichiers indésirables.

2. Utilisez des fichiers .gitignore globaux pour les motifs courants : Vous pouvez configurer un fichier .gitignore global qui s'applique à tous vos dépôts :

git config --global core.excludesfile ~/.gitignore_global

3. Soyez prudent avec git add . : Cette commande ajoute tous les fichiers non suivis. Utilisez des commandes plus spécifiques comme git add <file> lorsque cela est possible.

4. Passez en revue les modifications avant de commiter : Utilisez toujours git status et git diff --cached pour examiner ce que vous êtes sur le point de commiter.

5. Utilisez des alias pour les opérations courantes : Par exemple, vous pouvez configurer un alias pour supprimer les fichiers mis en cache :

git config --global alias.uncache 'rm --cached'

Ensuite, vous pouvez utiliser :

git uncache <file>

Avec ces techniques et ces bonnes pratiques, vous avez maintenant une compréhension globale de la façon de gérer efficacement le cache de Git pour maintenir un dépôt propre et efficace.

Résumé

Dans ce tutoriel, vous avez appris à utiliser efficacement la commande git rm --cached pour supprimer des fichiers du système de suivi de Git tout en les conservant dans votre répertoire local. Voici ce que vous avez accompli :

1. Mis en place un dépôt Git et appris le concept de la mise en cache de Git.
2. Ajouté des fichiers au système de suivi de Git.
3. Supprimé des fichiers individuels du cache de Git en utilisant git rm --cached.
4. Géré plusieurs fichiers et répertoires avec l'option récursive (-r).
5. Utilisé .gitignore pour empêcher le suivi de fichiers indésirables.
6. Exploré des techniques avancées et les meilleures pratiques pour la gestion du cache de Git.

Ces compétences vous aideront à maintenir un dépôt Git propre et efficace, à empêcher le suivi de fichiers indésirables et à protéger les informations sensibles. En gérant correctement les fichiers que Git suit, vous pouvez vous concentrer sur le code et les fichiers de configuration importants tout en ignorant les fichiers temporaires, les journaux et les artefacts de construction.

Rappelez-vous que la suppression de fichiers du cache de Git ne les supprime pas de votre système de fichiers local - elle indique simplement à Git d'arrêter de les suivre. Il s'agit d'un outil puissant pour gérer le contenu de votre dépôt et garantir que seuls les fichiers nécessaires sont inclus dans l'historique de votre projet.