Wie man gecachte Dateien mit Git entfernt

Einführung

Git ist ein leistungsstarkes Versionskontrollsystem, das Entwicklern hilft, die Dateihistorie ihrer Projekte zu verwalten. Manchmal werden Dateien im Repository zwischengespeichert, die wir nicht mehr von Git verfolgen lassen wollen, aber wir möchten sie in unserem lokalen Verzeichnis behalten. Der Befehl git rm --cached ermöglicht es uns, Dateien aus dem Tracking-System von Git zu entfernen und sie gleichzeitig in unserem Arbeitsverzeichnis zu erhalten. Dieses Tutorial zeigt Ihnen, wie Sie diesen Befehl effektiv einsetzen können, um Ihr Repository zu bereinigen und Ihren Workflow zu optimieren.

Erstellen eines Beispiel-Git-Repositorys

Um zu verstehen, wie man zwischengespeicherte Dateien aus Git entfernt, richten wir zunächst ein Beispiel-Repository mit einigen Dateien ein. Dies hilft uns zu sehen, wie das Caching in Git in der Praxis funktioniert.

Git-Caching verstehen

Wenn Sie Dateien mit dem Befehl git add zu Git hinzufügen, speichert Git diese Dateien in seinem Index (auch als Staging-Area bezeichnet). Diese Dateien sind nun "zwischengespeichert" oder gestaged und warten darauf, in das Repository committet zu werden. Manchmal möchten Sie diese Dateien aus dem Staging entfernen oder sie aus dem Tracking von Git entfernen, ohne sie von Ihrem lokalen Dateisystem zu löschen.

Einrichten unseres Repositorys

Lassen Sie uns ein einfaches Git-Repository erstellen, mit dem wir arbeiten können:

1. Öffnen Sie ein Terminalfenster in der LabEx VM-Umgebung
2. Navigieren Sie zum Projektverzeichnis:

cd ~/project

3. Erstellen Sie ein neues Verzeichnis für unser Test-Repository:

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

4. Initialisieren Sie ein neues Git-Repository:

git init

Sie sollten eine Ausgabe ähnlich dieser sehen:

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

5. Konfigurieren Sie Ihre Git-Benutzerinformationen (erforderlich für Commits):

git config user.name "LabEx User"
git config user.email "[email protected]"

Jetzt haben wir ein frisches Git-Repository, das bereit ist, Dateien hinzuzufügen. Im nächsten Schritt erstellen wir einige Dateien und fügen sie dem Tracking-System von Git hinzu, wodurch wir später üben können, sie aus dem Cache zu entfernen.

Hinzufügen von Dateien zum Repository

Nachdem wir unser Git-Repository eingerichtet haben, erstellen wir nun einige Dateien und fügen sie dem Tracking-System von Git hinzu. Dies hilft uns zu verstehen, was es bedeutet, wenn eine Datei in Git "zwischengespeichert" ist.

Erstellen und Hinzufügen von Dateien

1. Erstellen wir zunächst ein paar verschiedene Arten von Dateien in unserem Repository:

## 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. Überprüfen Sie den Status unseres Repositorys:

git status

Sie sollten eine Ausgabe ähnlich dieser sehen:

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)

Dies zeigt, dass wir drei Dateien haben, die Git erkennt, aber sie werden noch nicht getrackt.

3. Fügen wir alle Dateien zur Staging-Area (Cache) von Git hinzu:

git add .

4. Überprüfen Sie den Status erneut:

git status

Jetzt sollten Sie sehen:

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

Beachten Sie, dass Git uns jetzt mitteilt, dass wir git rm --cached <file> verwenden können, um die Dateien aus dem Staging zu entfernen. Die Dateien sind jetzt in der Staging-Area von Git zwischengespeichert und warten darauf, committet zu werden.

5. Committen wir diese Dateien, um sie zu einem Teil der Historie unseres Repositorys zu machen:

git commit -m "Initial commit with sample files"

Sie haben jetzt erfolgreich Dateien zum Tracking-System von Git hinzugefügt. Im nächsten Schritt erfahren wir, wie man bestimmte Dateien aus dem Cache von Git entfernt und sie gleichzeitig in unserem lokalen Verzeichnis behält.

Entfernen einer einzelnen Datei aus dem Git-Cache

Nachdem wir nun Dateien haben, die von Git getrackt werden, lernen wir, wie man eine bestimmte Datei aus dem Tracking von Git entfernt und sie gleichzeitig in unserem lokalen Verzeichnis behält. Dies ist ein häufiges Bedürfnis, wenn Sie versehentlich Dateien committen, die ausgeschlossen werden sollten, wie z. B. Protokolldateien, temporäre Dateien oder Dateien mit sensiblen Informationen.

Warum Dateien aus dem Git-Cache entfernen?

Es gibt mehrere Gründe, warum Sie eine Datei aus dem Git-Cache entfernen möchten:

1. Sie haben versehentlich eine Datei mit sensiblen Informationen hinzugefügt.
2. Sie möchten große Binärdateien wie Protokolle oder kompilierte Dateien ausschließen.
3. Sie richten eine .gitignore-Datei ein und müssen bereits getrackte Dateien entfernen.

Entfernen von app.log aus dem Git-Tracking

Stellen wir uns vor, wir haben erkannt, dass die Datei app.log nicht von Git getrackt werden sollte:

1. Überprüfen wir zunächst, ob Git die Datei derzeit trackt:

git ls-files

Sie sollten alle drei Dateien aufgelistet sehen:

app.log
config.ini
sample.txt

2. Entfernen wir nun app.log aus dem Tracking-System von Git und behalten es gleichzeitig in unserem lokalen Verzeichnis:

git rm --cached app.log

Sie sehen eine Bestätigungsmeldung:

rm 'app.log'

3. Überprüfen Sie den Status erneut:

git status

Sie sehen, dass app.log jetzt als nicht getrackte Datei aufgeführt wird:

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

Das bedeutet, dass Git das Tracking der Datei im nächsten Commit beendet, aber die Datei weiterhin in Ihrem lokalen Verzeichnis existiert.

4. Überprüfen wir, ob die Datei weiterhin in unserem Arbeitsverzeichnis existiert:

ls -la

Sie sollten sehen, dass app.log immer noch vorhanden ist.

5. Committen Sie diese Änderung, um das Entfernen der Datei aus dem Git-Tracking abzuschließen:

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

6. Überprüfen Sie, ob Git die Datei nicht mehr trackt:

git ls-files

Jetzt sollten Sie nur noch sehen:

config.ini
sample.txt

Aber die Datei app.log existiert immer noch in Ihrem lokalen Verzeichnis:

cat app.log

Ausgabe:

2023-01-01: System started

Herzlichen Glückwunsch! Sie haben erfolgreich eine Datei aus dem Git-Cache entfernt und sie gleichzeitig in Ihrem lokalen Verzeichnis behalten. Im nächsten Schritt erfahren wir, wie man mit mehreren Dateien umgeht und unseren Workflow mit .gitignore verbessert.

Arbeiten mit mehreren Dateien und Verzeichnissen

Nachdem wir nun wissen, wie man eine einzelne Datei aus dem Git-Cache entfernt, wollen wir komplexere Szenarien untersuchen, wie z. B. das Entfernen mehrerer Dateien oder ganzer Verzeichnisse.

Erstellen weiterer Dateien zum Üben

Erstellen wir zunächst ein paar weitere Dateien und eine Verzeichnisstruktur, um damit zu üben:

1. Erstellen Sie ein Verzeichnis und einige zusätzliche Dateien:

## 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. Fügen Sie diese neuen Dateien zum Tracking von Git hinzu:

git add .

3. Committen Sie die Änderungen:

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

4. Überprüfen Sie, ob Git alle Dateien trackt:

git ls-files

Sie sollten sehen:

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

Entfernen mehrerer Dateien aus dem Git-Cache

Nehmen wir nun an, wir möchten alle Protokolldateien und das gesamte temp-Verzeichnis aus dem Tracking von Git entfernen.

1. Entfernen Sie die Protokolldatei aus dem Tracking von Git:

git rm --cached system.log

2. Entfernen Sie rekursiv alle Dateien im temp-Verzeichnis:

git rm --cached -r temp/

Das Flag -r ist hier wichtig, da es Git anweist, alle Dateien im Verzeichnis rekursiv aus seinem Cache zu entfernen.

3. Überprüfen Sie den Status:

git status

Sie sehen, dass sowohl die Protokolldatei als auch alle Dateien im temp-Verzeichnis für das Löschen aus dem Tracking-System von Git vorgemerkt sind:

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. Committen Sie diese Änderungen:

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

5. Überprüfen Sie, ob Git diese Dateien nicht mehr trackt:

git ls-files

Jetzt sollten Sie nur noch sehen:

app.log
config.ini
sample.txt

Allerdings existieren alle Dateien weiterhin in Ihrem lokalen Verzeichnis:

ls -la
ls -la temp/

Verwenden von .gitignore, um das Tracking unerwünschter Dateien zu verhindern

Nachdem wir die Dateien aus dem Tracking von Git entfernt haben, richten wir nun eine .gitignore-Datei ein, um zu verhindern, dass sie versehentlich wieder hinzugefügt werden:

1. Erstellen Sie eine .gitignore-Datei:

nano .gitignore

2. Fügen Sie die folgenden Muster zur Datei hinzu:

## Ignore log files
*.log

## Ignore temp directory
temp/

3. Speichern und beenden (drücken Sie Strg+X, dann Y, dann Eingabe)

4. Fügen Sie die .gitignore-Datei hinzu und committen Sie sie:

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

Nun, selbst wenn Sie versuchen, alle Dateien zu Git hinzuzufügen, respektiert es Ihre .gitignore-Datei und trackt die angegebenen Muster nicht:

git add .
git status

Sie sollten sehen, dass die Protokolldateien und das temp-Verzeichnis nicht zum Tracking von Git hinzugefügt werden.

Sie haben jetzt gelernt, wie man mehrere Dateien und Verzeichnisse aus dem Git-Cache entfernt und wie man mit einer .gitignore-Datei verhindert, dass bestimmte Dateien in Zukunft getrackt werden.

Fortgeschrittene Techniken und Best Practices

Nachdem Sie nun die Grundlagen des Entfernens von Dateien aus dem Git-Cache verstehen, wollen wir einige fortgeschrittene Techniken und Best Practices erkunden, um Ihren Workflow zu verbessern.

Dateien in einem Schritt entfernen und ignorieren

Wenn Sie Dateien haben, die bereits von Git getrackt werden und Sie sie sowohl aus dem Tracking entfernen als auch zu Ihrer .gitignore-Datei hinzufügen möchten, können Sie diesen effizienten Ansatz verwenden:

1. Erstellen wir einen neuen Dateityp, den wir ignorieren möchten:

## 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. Fügen Sie diese Dateien zu Git hinzu:

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

3. Entfernen wir sie nun aus dem Tracking von Git und aktualisieren unsere .gitignore-Datei in einem Workflow:

## 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. Überprüfen Sie, ob die Dateien nicht mehr getrackt werden, aber lokal noch existieren:

git ls-files
ls -la build/

Umgang mit sensiblen Informationen

Wenn Sie versehentlich eine Datei mit sensiblen Informationen wie Passwörtern oder API-Schlüsseln committet haben, ist das Entfernen aus dem Git-Cache nur der erste Schritt. Git verwaltet eine Historie aller Commits, sodass die sensiblen Informationen weiterhin in der Historie Ihres Repositorys vorhanden sind.

Für sensible Informationen müssen Sie:

1. Die Datei aus dem Git-Cache entfernen, wie wir gelernt haben.
2. Alle kompromittierten Passwörter oder Schlüssel ändern.
3. Erwägen Sie die Verwendung von Tools wie git filter-branch oder BFG Repo-Cleaner, um die sensiblen Daten aus der Historie zu entfernen.

Dies geht über den Rahmen dieses Tutorials hinaus, aber es ist wichtig, sich dieser Einschränkung bewusst zu sein.

Best Practices für das Git-Cache-Management

Hier sind einige Best Practices, die Sie befolgen sollten:

1. Erstellen Sie frühzeitig in Ihrem Projekt eine gute .gitignore-Datei: Dies verhindert, dass versehentlich unerwünschte Dateien getrackt werden.

2. Verwenden Sie globale .gitignore-Dateien für gängige Muster: Sie können eine globale .gitignore-Datei einrichten, die für alle Ihre Repositories gilt:

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

3. Seien Sie vorsichtig mit git add .: Dieser Befehl fügt alle nicht getrackten Dateien hinzu. Verwenden Sie nach Möglichkeit spezifischere Befehle wie git add <file>.

4. Überprüfen Sie Änderungen vor dem Committen: Verwenden Sie immer git status und git diff --cached, um zu überprüfen, was Sie committen möchten.

5. Verwenden Sie Aliase für gängige Operationen: Sie könnten beispielsweise einen Alias zum Entfernen gecachter Dateien einrichten:

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

Dann könnten Sie verwenden:

git uncache <file>

Mit diesen Techniken und Best Practices verfügen Sie nun über ein umfassendes Verständnis, wie Sie den Git-Cache effektiv verwalten können, um ein sauberes und effizientes Repository zu erhalten.

Zusammenfassung

In diesem Tutorial haben Sie gelernt, wie Sie den Befehl git rm --cached effektiv einsetzen, um Dateien aus dem Tracking-System von Git zu entfernen und sie gleichzeitig in Ihrem lokalen Verzeichnis zu behalten. Folgendes haben Sie erreicht:

1. Ein Git-Repository eingerichtet und das Konzept des Git-Caching kennengelernt
2. Dateien zum Tracking-System von Git hinzugefügt
3. Einzelne Dateien mit git rm --cached aus dem Git-Cache entfernt
4. Mehrere Dateien und Verzeichnisse mit der rekursiven Option (-r) verwaltet
5. .gitignore verwendet, um zu verhindern, dass unerwünschte Dateien getrackt werden
6. Fortgeschrittene Techniken und Best Practices für die Verwaltung des Git-Caches erkundet

Diese Fähigkeiten helfen Ihnen, ein sauberes und effizientes Git-Repository zu verwalten, das Tracking unerwünschter Dateien zu verhindern und sensible Informationen zu schützen. Durch die ordnungsgemäße Verwaltung, welche Dateien Git trackt, können Sie sich auf die wichtigen Code- und Konfigurationsdateien konzentrieren und gleichzeitig temporäre Dateien, Protokolle und Build-Artefakte ignorieren.

Denken Sie daran, dass das Entfernen von Dateien aus dem Git-Cache sie nicht aus Ihrem lokalen Dateisystem löscht – es weist Git lediglich an, sie nicht mehr zu tracken. Dies ist ein leistungsstarkes Werkzeug zur Verwaltung des Inhalts Ihres Repositorys und zur Sicherstellung, dass nur die erforderlichen Dateien in der Historie Ihres Projekts enthalten sind.