Wie man git rm --cached verwendet, um eine Datei aus dem Git-Index zu entfernen

Einführung

Git ist ein leistungsstarkes Versionskontrollsystem, das Entwicklern hilft, ihre Codebasis effektiv zu verwalten. Eine häufige Aufgabe in Git ist das Entfernen von Dateien aus dem Index, dem Staging-Bereich für Änderungen. In diesem Tutorial werden wir untersuchen, wie man den Befehl git rm --cached verwendet, um eine Datei aus dem Git-Index zu entfernen, ohne sie von Ihrem lokalen Dateisystem zu löschen.

Das Git-Index verstehen – ein praktisches Beispiel

Der Git-Index, auch als Staging-Area bekannt, ist eine entscheidende Komponente im Git-Versionskontrollsystem. Er dient als Zwischenspeicherbereich zwischen Ihrem Arbeitsverzeichnis und dem Git-Repository. Wenn Sie Änderungen an Ihren Dateien vornehmen, committet Git diese Änderungen nicht automatisch. Stattdessen müssen Sie die Änderungen explizit dem Index hinzufügen, bevor Sie sie committen.

Lassen Sie uns ein einfaches Beispiel erstellen, um zu verstehen, wie der Git-Index funktioniert:

1. Erstellen wir zunächst ein neues Verzeichnis für unser Projekt und initialisieren ein Git-Repository:

mkdir git-index-demo
cd git-index-demo
git init

Sie sollten eine Ausgabe ähnlich dieser sehen:

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

2. Erstellen wir nun eine einfache Textdatei:

echo "Hello, Git!" > hello.txt

3. Überprüfen Sie den Status Ihres Repositorys:

git status

Sie sollten eine Ausgabe sehen, die anzeigt, dass hello.txt nicht verfolgt wird:

On branch master

No commits yet

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

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

4. Fügen Sie die Datei dem Git-Index hinzu:

git add hello.txt

5. Überprüfen Sie den Status erneut:

git status

Jetzt sollten Sie sehen, dass die Datei für den Commit vorbereitet ist:

On branch master

No commits yet

Changes to be committed:
  (use "git rm --cached <file>..." to unstage)
        new file:   hello.txt

Herzlichen Glückwunsch! Sie haben gerade eine Datei zum Git-Index hinzugefügt. Beachten Sie, dass Git Ihnen mitteilt, dass Sie git rm --cached <file> verwenden können, um die Datei aus dem Staging zu entfernen, was genau das ist, was wir im nächsten Schritt lernen werden.

Der Git-Index bietet mehrere Vorteile:

• Er ermöglicht es Ihnen, selektiv auszuwählen, welche Änderungen in Ihrem nächsten Commit enthalten sein sollen.
• Sie können bestimmte Teile einer Datei stagen.
• Er bietet eine Vorschau darauf, was Ihr nächster Commit enthalten wird.

Im nächsten Schritt werden wir lernen, wie man eine Datei mit dem Befehl git rm --cached aus dem Git-Index entfernt.

Verwenden von git rm --cached, um eine Datei aus dem Index zu entfernen

Nachdem wir nun eine Datei im Git-Index haben, wollen wir lernen, wie man sie mit dem Befehl git rm --cached entfernt. Dieser Befehl entfernt eine Datei aus dem Git-Index (Staging-Area), ohne sie von Ihrem lokalen Dateisystem zu löschen.

Fahren wir mit unserem Beispiel aus dem vorherigen Schritt fort:

1. Stellen Sie sicher, dass Sie sich noch im Verzeichnis git-index-demo befinden:

cd ~/project/git-index-demo

2. Überprüfen wir den aktuellen Status unseres Repositorys:

git status

Sie sollten sehen, dass hello.txt für den Commit vorbereitet ist (im Index):

On branch master

No commits yet

Changes to be committed:
  (use "git rm --cached <file>..." to unstage)
        new file:   hello.txt

3. Entfernen wir nun die Datei mit dem Befehl git rm --cached aus dem Git-Index:

git rm --cached hello.txt

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

rm 'hello.txt'

4. Überprüfen Sie den Status erneut:

git status

Sie werden feststellen, dass die Datei jetzt nicht mehr verfolgt wird:

On branch master

No commits yet

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

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

5. Bestätigen Sie, dass die Datei weiterhin in Ihrem lokalen Dateisystem existiert:

ls -l

Sie sollten hello.txt in der Ausgabe sehen:

total 4
-rw-r--r-- 1 labex labex 11 [date] hello.txt

Dies bestätigt, dass git rm --cached die Datei nur aus dem Git-Index entfernt hat, nicht aber aus Ihrem lokalen Dateisystem.

6. Erstellen wir eine weitere Datei, um zu verstehen, wie man mehrere Dateien aus dem Index entfernt:

echo "Another file" > another.txt
git add another.txt

7. Überprüfen Sie den Status:

git status

Sie sollten Folgendes sehen:

On branch master

No commits yet

Changes to be committed:
  (use "git rm --cached <file>..." to unstage)
        new file:   another.txt

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

8. Fügen wir nun hello.txt wieder dem Index hinzu und sehen, wie man mehrere Dateien entfernt:

git add hello.txt
git status

Sie sollten beide Dateien im Index sehen:

On branch master

No commits yet

Changes to be committed:
  (use "git rm --cached <file>..." to unstage)
        new file:   another.txt
        new file:   hello.txt

9. Um beide Dateien gleichzeitig aus dem Index zu entfernen:

git rm --cached hello.txt another.txt

10. Überprüfen Sie den Status noch einmal:

git status

Beide Dateien sollten jetzt nicht mehr verfolgt werden:

On branch master

No commits yet

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

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

Der Befehl git rm --cached ist besonders nützlich, wenn:

• Sie versehentlich eine Datei zum Git-Index hinzugefügt haben
• Sie die Verfolgung einer Datei beenden möchten, ohne sie von Ihrem System zu löschen
• Sie dabei sind, ein Dateimuster zu .gitignore hinzuzufügen, aber zuerst vorhandene Dateien aus dem Index entfernen müssen

Im nächsten Schritt werden wir einige praktische Anwendungsfälle für diesen Befehl untersuchen.

Praktische Anwendungsfälle mit .gitignore

Einer der häufigsten Anwendungsfälle für git rm --cached ist, wenn Sie die Verfolgung von Dateien beenden möchten, die ignoriert werden sollen. Lassen Sie uns dies anhand eines praktischen Beispiels untersuchen.

Erstellen und Committen von Dateien

Erstellen wir zunächst eine Situation, in der wir versehentlich Dateien committet haben, die wir hätten ignorieren sollen:

1. Stellen Sie sicher, dass Sie sich noch im Verzeichnis git-index-demo befinden:

cd ~/project/git-index-demo

2. Fügen wir unsere vorhandenen Dateien dem Index hinzu:

git add hello.txt another.txt

3. Committen wir nun diese Dateien:

git commit -m "Initial commit"

Sie sollten eine Ausgabe sehen, die den Commit bestätigt:

[master (root-commit) xxxxxxx] Initial commit
 2 files changed, 2 insertions(+)
 create mode 100644 another.txt
 create mode 100644 hello.txt

4. Erstellen Sie eine Protokolldatei, die eine generierte Datei simuliert, die wir nicht verfolgen möchten:

echo "Some log data" > application.log

5. Fügen wir diese Protokolldatei versehentlich hinzu und committen sie:

git add application.log
git commit -m "Add log file by mistake"

Sie sollten eine Ausgabe sehen, die den Commit bestätigt:

[master xxxxxxx] Add log file by mistake
 1 file changed, 1 insertion(+)
 create mode 100644 application.log

Verwenden von .gitignore und git rm --cached

Lassen Sie uns nun unseren Fehler beheben, indem wir eine .gitignore-Datei erstellen und git rm --cached verwenden:

1. Erstellen Sie eine .gitignore-Datei, um anzugeben, dass wir alle .log-Dateien ignorieren möchten:

echo "*.log" > .gitignore

2. Überprüfen Sie den Status:

git status

Sie sollten Folgendes sehen:

On branch master
Untracked files:
  (use "git add <file>..." to include in what will be committed)
        .gitignore

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

Beachten Sie, dass die Datei application.log nicht als geändert aufgeführt wird, obwohl wir die .gitignore-Datei mit dem Muster *.log haben. Dies liegt daran, dass .gitignore nur verhindert, dass nicht verfolgte Dateien dem Index hinzugefügt werden. Dateien, die bereits verfolgt werden, werden weiterhin verfolgt.

3. Fügen wir die .gitignore-Datei hinzu und committen sie:

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

4. Entfernen wir nun die Protokolldatei aus dem Git-Index, während wir sie in unserem Dateisystem behalten:

git rm --cached application.log

Sie sollten Folgendes sehen:

rm 'application.log'

5. Überprüfen Sie den Status:

git status

Sie sollten Folgendes sehen:

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

Dies zeigt an, dass das Löschen der Datei aus dem Tracking-System von Git im nächsten Commit enthalten sein wird.

6. Committen wir diese Änderung:

git commit -m "Stop tracking application.log"

7. Überprüfen Sie den Status noch einmal:

git status

Sie sollten Folgendes sehen:

On branch master
nothing to commit, working tree clean

8. Überprüfen wir nun, ob die Datei weiterhin in unserem Dateisystem existiert:

ls -l

Sie sollten sehen, dass application.log zusammen mit unseren anderen Dateien weiterhin existiert:

total 16
-rw-r--r-- 1 labex labex 13 [date] another.txt
-rw-r--r-- 1 labex labex 13 [date] application.log
-rw-r--r-- 1 labex labex 6  [date] .gitignore
-rw-r--r-- 1 labex labex 11 [date] hello.txt

9. Versuchen wir, die Protokolldatei zu ändern, um zu sehen, ob Git die Änderungen verfolgt:

echo "More log data" >> application.log
git status

Sie sollten Folgendes sehen:

On branch master
nothing to commit, working tree clean

Obwohl wir die Protokolldatei geändert haben, erkennt Git keine Änderungen, da die Datei aufgrund des .gitignore-Musters jetzt ignoriert wird.

Dies ist ein sehr gängiger Arbeitsablauf, wenn Sie versehentlich Dateien committen, die ignoriert werden sollen, wie z. B.:

• Build-Artefakte
• Protokolldateien
• Konfigurationsdateien mit sensiblen Informationen
• Abhängigkeitsverzeichnisse (wie node_modules in JavaScript-Projekten)

Durch die Verwendung von git rm --cached zusammen mit .gitignore können Sie:

1. Die Verfolgung von Dateien beenden, die ignoriert werden sollen
2. Die Dateien in Ihrem lokalen Dateisystem behalten
3. Verhindern, dass sie in Zukunft dem Repository hinzugefügt werden

Fortgeschrittenes Beispiel: Entfernen sensibler Informationen

Ein weiterer wichtiger Anwendungsfall für git rm --cached ist das Entfernen sensibler Informationen aus dem Repository-Verlauf. Während Git darauf ausgelegt ist, Änderungen zu verfolgen, können Sie manchmal versehentlich Dateien mit Passwörtern, API-Schlüsseln oder anderen sensiblen Daten committen.

Sehen wir uns an, wie Sie diese Situation handhaben:

1. Stellen Sie sicher, dass Sie sich immer noch im Verzeichnis git-index-demo befinden:

cd ~/project/git-index-demo

2. Erstellen Sie eine Datei, die eine Konfigurationsdatei mit sensiblen Informationen simuliert:

echo "API_KEY=1234567890abcdef" > config.properties
echo "DATABASE_PASSWORD=supersecretpassword" >> config.properties

3. Fügen Sie diese Datei hinzu und committen Sie sie:

git add config.properties
git commit -m "Add configuration file"

4. Nun stellen Sie fest, dass Sie sensible Informationen committet haben und diese aus der Nachverfolgung entfernen möchten, während Sie eine lokale Kopie behalten:

git rm --cached config.properties

5. Erstellen Sie eine Vorlagendatei, die nicht die tatsächlichen sensiblen Informationen enthält:

echo "API_KEY=your_api_key_here" > config.properties.template
echo "DATABASE_PASSWORD=your_password_here" >> config.properties.template

6. Fügen Sie die Vorlagendatei zu Git hinzu:

git add config.properties.template

7. Aktualisieren Sie die .gitignore-Datei, um die echte Konfigurationsdatei zu ignorieren, aber die Vorlage zu verfolgen:

echo "config.properties" >> .gitignore

8. Fügen Sie die aktualisierte .gitignore-Datei hinzu und committen Sie diese Änderungen:

git add .gitignore
git commit -m "Remove sensitive config from tracking, add template instead"

9. Überprüfen wir den Status unseres Repositories:

git status

Sie sollten sehen:

On branch master
nothing to commit, working tree clean

10. Verifizieren Sie, dass beide Dateien im Dateisystem vorhanden sind:

ls -l config*

Sie sollten sehen:

-rw-r--r-- 1 labex labex 60 [date] config.properties
-rw-r--r-- 1 labex labex 60 [date] config.properties.template

11. Überprüfen Sie, welche Dateien verfolgt werden:

git ls-files | grep config

Sie sollten nur sehen:

config.properties.template

Dieses Muster wird häufig in Projekten verwendet, um:

• Sensible Konfigurationen aus der Versionskontrolle herauszuhalten
• Vorlagen für andere Mitwirkende bereitzustellen, um ihre eigenen Konfigurationsdateien zu erstellen
• Versehentliche Commits sensibler Informationen zu verhindern

Denken Sie daran, dass git rm --cached die Datei zwar aus zukünftigen Commits entfernt, aber nicht aus dem Git-Verlauf. Wenn Sie bereits sensible Informationen in ein Remote-Repository gepusht haben, müssen Sie möglicherweise zusätzliche Schritte unternehmen, um sie vollständig aus dem Verlauf zu entfernen.

In einem realen Projektszenario sollten Sie Folgendes in Betracht ziehen:

• Sofortige Rotation aller kompromittierten Anmeldeinformationen
• Verwendung von Umgebungsvariablen anstelle von Konfigurationsdateien für sensible Informationen
• Verwendung dedizierter Secret-Management-Lösungen für Produktionsumgebungen

Damit ist unsere Erkundung praktischer Anwendungsfälle für den Befehl git rm --cached abgeschlossen!

Zusammenfassung

In diesem Tutorial haben Sie gelernt, wie Sie den Befehl git rm --cached verwenden, um Dateien aus dem Git-Index zu entfernen, ohne sie aus Ihrem lokalen Dateisystem zu löschen. Folgendes haben wir behandelt:

• Das Verständnis des Git-Index (Staging-Area) und seine Rolle im Git-Workflow
• Die Verwendung von git rm --cached, um einzelne und mehrere Dateien aus dem Index zu entfernen
• Die Integration von git rm --cached mit .gitignore, um die Verfolgung von Dateien zu beenden, die ignoriert werden sollen
• Die Anwendung dieser Konzepte auf praktische Szenarien, wie z. B. das Entfernen versehentlich committeter Dateien und den Umgang mit sensiblen Informationen

Diese Fähigkeiten sind unerlässlich, um ein sauberes Git-Repository zu verwalten und zu steuern, was in Ihrem Versionskontrollverlauf committet wird. Durch die Nutzung von git rm --cached können Sie besser kontrollieren, welche Dateien von Git verfolgt werden, während Sie Ihr lokales Arbeitsverzeichnis intakt halten.