So richten Sie die Git-Personal Access Token-Konfiguration ein

Einführung

In diesem Tutorial führen wir Sie durch den Prozess der Einrichtung und Konfiguration von Git-Personal Access Tokens (Git-Personen-Zugangstoken). Sie erfahren, wie Sie diese Token generieren, schützen und verwalten können, sowie warum sie im Git-Ökosystem wichtig sind. Am Ende dieses Leitfadens werden Sie wissen, wie Sie Personal Access Tokens effektiv für sichere Git-Operationen nutzen können.

Dieser Lab (Übungsumgebung) erfordert eine Internetverbindung zum Lernen. Daher können nur Pro-Nutzer die virtuelle Maschine starten. Upgrade Sie Ihr Konto auf Pro.

Grundlagen zu Git-Personal Access Tokens

Git ist ein weit verbreitetes verteiltes Versionskontrollsystem, das es Entwicklern ermöglicht, an Projekten zusammenzuarbeiten, Änderungen zu verfolgen und Code-Repositories (Code-Archiv) zu verwalten. Ein wesentlicher Aspekt der effektiven Nutzung von Git ist die sichere Authentifizierung bei der Interaktion mit Remote-Repositories (Entfernten Code-Archiven).

Was sind Personal Access Tokens?

Personal Access Tokens (PATs, Personen-Zugangstoken) sind Authentifizierungsdaten, die es Ihnen ermöglichen, auf Ihre Git-Repositories sicher zuzugreifen, ohne Ihren Benutzernamen und Ihr Passwort zu verwenden. Sie funktionieren ähnlich wie Passwörter, bieten jedoch mehrere Vorteile:

Erhöhte Sicherheit: PATs können widerrufen oder ausgetauscht werden, ohne dass Sie Ihr Hauptkonto-Passwort ändern müssen.
Feingranulare Berechtigungen: Sie können beschränken, welche Aktionen ein Token ausführen kann, indem Sie bestimmte Bereiche (Scopes) zuweisen.
Unterstützung für Automatisierung: PATs ermöglichen den programmgesteuerten Zugriff für Skripte, CI/CD-Pipelines und andere Tools.
Kompatibilität mit Multi-Faktor-Authentifizierung: PATs funktionieren nahtlos mit Konten, für die die Zwei-Faktor-Authentifizierung (MFA) aktiviert ist.

Warum sollten Sie Personal Access Tokens verwenden?

Viele Git-Hosting-Plattformen, darunter GitHub, GitLab und Bitbucket, setzen die Passwort-basierte Authentifizierung für Git-Operationen zunehmend außer Kraft. Dieser Übergang wird hauptsächlich durch Sicherheitsbedenken motiviert. Personal Access Tokens bieten eine sicherere Alternative, die das Risiko, das mit langlebigen, umfassenden Zugangsdaten verbunden ist, verringert.

Wenn Sie anstelle eines Passworts ein Personal Access Token verwenden:

können Sie die Funktionen des Tokens auf das beschränken, was tatsächlich benötigt wird
können Sie mehrere Token für verschiedene Zwecke erstellen
können Sie einzelne Token widerrufen, ohne andere zu beeinträchtigen
können Sie bessere Überwachungspfade für Zugang und Nutzung aufrechterhalten

In den folgenden Schritten werden wir ein Personal Access Token erstellen und Git so konfigurieren, dass es dieses Token zur Authentifizierung verwendet.

Generieren eines Personal Access Tokens auf GitHub

In diesem Schritt werden wir ein Personal Access Token auf GitHub generieren. Der Prozess ist auf anderen Git-Plattformen wie GitLab oder Bitbucket ähnlich, mit geringen Unterschieden in der Benutzeroberfläche.

Erstellen eines Tokens auf GitHub

Folgen Sie diesen Schritten, um Ihr Personal Access Token zu generieren:

Öffnen Sie ein Terminal und installieren Sie das GitHub CLI-Tool, das eine bequeme Möglichkeit bietet, mit GitHub zu interagieren:
```
sudo apt-get update
sudo apt-get install -y gh
```
Authentifizieren Sie sich bei GitHub, indem Sie folgenden Befehl ausführen:
```
gh auth login
```

Befolgen Sie die interaktiven Anweisungen:

Wählen Sie "GitHub.com" aus, wenn Sie nach dem Konto gefragt werden.
Wählen Sie "HTTPS" als bevorzugtes Protokoll.
Bestätigen Sie, dass Sie sich mit Ihren GitHub-Anmeldeinformationen authentifizieren möchten.
Wählen Sie "Mit einem Webbrowser anmelden", wenn Sie nach der Authentifizierungsmethode gefragt werden.

Es wird ein Einmalkenncode angezeigt. GitHub wird in Ihrem Browser geöffnet, oder Sie werden aufgefordert, eine URL zu besuchen und diesen Code einzugeben.

Nach erfolgreicher Authentifizierung generieren Sie ein neues Personal Access Token:
```
gh auth token
```
Dieser Befehl zeigt Ihr aktuelles Authentifizierungstoken an. Kopieren Sie dieses Token und speichern Sie es an einem sicheren Ort, da wir es in den nächsten Schritten benötigen werden.

Wenn Sie lieber direkt ein Token mit bestimmten Bereichen (Scopes) erstellen möchten, können Sie Folgendes verwenden:
```
gh auth refresh -s repo,read:org
gh auth token
```
Dies erstellt ein Token mit Lesezugriff auf Repositorys und Organisationen.
Alternativ können Sie ein Token direkt über die GitHub-Website generieren:

Besuchen Sie GitHub unter https://github.com.
Klicken Sie auf Ihr Profilbild in der oberen rechten Ecke.
Wählen Sie "Settings" (Einstellungen).
Scrollen Sie nach unten und klicken Sie im linken Seitenbereich auf "Developer settings" (Entwicklereinstellungen).
Klicken Sie auf "Personal access tokens" (Persönliche Zugangstoken) und dann auf "Tokens (classic)" (Tokens (klassisch)).
Klicken Sie auf "Generate new token" (Neues Token generieren) und wählen Sie "Generate new token (classic)" (Neues Token (klassisch) generieren).
Geben Sie Ihrem Token einen beschreibenden Namen wie "Git CLI access" (Git CLI-Zugang).
Wählen Sie die entsprechenden Bereiche (Scopes) aus (wählen Sie mindestens "repo" für den Repository-Zugang).
Klicken Sie auf "Generate token" (Token generieren).
Kopieren Sie das generierte Token und speichern Sie es sicher.

Denken Sie daran, Ihr Token an einem sicheren Ort zu speichern, da GitHub es nur einmal anzeigt. Wenn Sie es verlieren, müssen Sie ein neues generieren.

Konfigurieren von Git zur Verwendung Ihres Personal Access Tokens

Nachdem Sie nun ein Personal Access Token generiert haben, müssen Sie Git so konfigurieren, dass es dieses Token zur Authentifizierung bei der Interaktion mit Remote-Repositories verwendet. Es gibt mehrere Methoden, um dies zu erreichen.

Methode 1: Verwendung des Git Credential Helper

Der Git Credential Helper ermöglicht es Git, Ihre Anmeldeinformationen zu speichern, sodass Sie sie nicht jedes Mal eingeben müssen.

Öffnen Sie ein Terminal und navigieren Sie in Ihr Projektverzeichnis:
```
cd ~/project
```
Konfigurieren Sie Git so, dass es den Credential Helper verwendet, um Ihre Anmeldeinformationen zu speichern:
```
git config --global credential.helper store
```
Hinweis: Dadurch werden Ihre Anmeldeinformationen unverschlüsselt auf Ihrer Festplatte gespeichert. Für eine sicherere Option können Sie stattdessen den Cache Helper verwenden, der die Anmeldeinformationen temporär im Speicher speichert:
```
git config --global credential.helper 'cache --timeout=3600'
```
Dadurch werden Ihre Anmeldeinformationen für 1 Stunde (3600 Sekunden) im Speicher gespeichert.
Erstellen Sie ein Beispiel-Git-Repository, um Ihre Konfiguration zu testen:
```
mkdir -p ~/project/test-repo
cd ~/project/test-repo
git init
```
Fügen Sie ein Remote-Repository hinzu (Sie müssen yourusername durch Ihren tatsächlichen GitHub-Benutzernamen ersetzen):
```
git remote add origin https://github.com/yourusername/test-repo.git
```
Das nächste Mal, wenn Git eine Authentifizierung erfordert (z. B. beim Pushen oder Pullen), werden Sie aufgefordert, Ihre Anmeldeinformationen einzugeben. Geben Sie Ihren GitHub-Benutzernamen ein und verwenden Sie Ihr Personal Access Token als Passwort.

Methode 2: Verwendung der URL-basierten Authentifizierung

Eine andere Möglichkeit besteht darin, Ihr Token direkt in die Repository-URL einzubetten:

Konfigurieren Sie in Ihrem Projektverzeichnis die URL des Remote-Repositories mit Ihrem Token:
```
git remote set-url origin https://YOUR_TOKEN@github.com/yourusername/test-repo.git
```
Ersetzen Sie YOUR_TOKEN durch Ihr tatsächliches Personal Access Token und yourusername durch Ihren GitHub-Benutzernamen.

Erstellen Sie eine Testdatei, um die Konfiguration zu überprüfen:

echo "## Test Repository" > README.md
git add README.md
git commit -m "Initial commit"

Methode 3: Verwendung der Git-Konfigurationsdatei

Sie können auch direkt die Git-Konfigurationsdatei bearbeiten:

Erstellen Sie oder bearbeiten Sie die .git/config-Datei in Ihrem Repository:
```
nano ~/project/test-repo/.git/config
```
Aktualisieren Sie die URL für das Remote-Repository origin, um Ihr Token einzubeziehen:
```
[remote "origin"]
    url = https://YOUR_TOKEN@github.com/yourusername/test-repo.git
    fetch = +refs/heads/*:refs/remotes/origin/*
```
Ersetzen Sie YOUR_TOKEN durch Ihr tatsächliches Personal Access Token und yourusername durch Ihren GitHub-Benutzernamen.
Speichern Sie die Datei, indem Sie Strg+O drücken, dann Enter, und verlassen Sie den Editor mit Strg+X.

Aus Sicherheitsgründen wird für die meisten Benutzer im Allgemeinen die Methode mit dem Credential Helper (Methode 1) empfohlen, da dadurch vermieden wird, dass Ihr Token direkt in Konfigurationsdateien gespeichert wird.

Testen Ihres Personal Access Tokens

Nachdem Sie Git so konfiguriert haben, dass es Ihr Personal Access Token verwendet, ist es wichtig zu überprüfen, ob die Authentifizierung korrekt funktioniert. In diesem Schritt werden wir das Token durch Ausführen gängiger Git-Operationen testen.

Erstellen eines Test-Repositories auf GitHub

Zunächst erstellen wir ein Test-Repository auf GitHub mit der GitHub CLI:

Erstellen Sie ein neues Repository auf GitHub:
```
cd ~/project
gh repo create test-pat-repo --private --clone
cd test-pat-repo
```
Dieser Befehl erstellt ein neues privates Repository namens "test-pat-repo" und klont es auf Ihren lokalen Rechner.

Testen grundlegender Git-Operationen

Jetzt führen wir einige grundlegende Git-Operationen aus, um sicherzustellen, dass Ihr Personal Access Token korrekt funktioniert:

Erstellen Sie eine einfache README-Datei:

echo "## Test PAT Repository" > README.md
echo "This repository is used to test Personal Access Token configuration." >> README.md

Fügen Sie die Datei hinzu und committen Sie sie:

git add README.md
git commit -m "Add README file"

Pushen Sie die Änderungen auf GitHub:
```
git push -u origin main
```
Wenn Ihr Personal Access Token korrekt konfiguriert ist, sollte der Pushvorgang ohne Passwortaufforderung erfolgreich sein. Wenn Sie den Credential Helper verwenden und dies Ihr erster Push ist, werden Sie möglicherweise nach Ihrem Benutzernamen und Token gefragt, die dann für zukünftige Verwendung gespeichert werden.
Führen Sie eine weitere Änderung durch, um die gespeicherten Anmeldeinformationen zu überprüfen:
```
echo "### Additional Information" >> README.md
echo "This section contains additional information about the repository." >> README.md
git add README.md
git commit -m "Update README with additional information"
git push
```
Dieser zweite Pushvorgang sollte ohne Authentifizierungsaufforderungen ablaufen, was bestätigt, dass Ihr Token korrekt verwendet wird.

Überprüfen des Repository-Zugangs

Um weiter zu bestätigen, dass Ihr Token korrekt funktioniert, können Sie Ihre Repositorys auflisten:

gh repo list --limit 5

Dieser Befehl sollte eine Liste Ihrer GitHub-Repositorys anzeigen, einschließlich des Test-Repositorys, das wir gerade erstellt haben. Wenn dieser Befehl erfolgreich ausgeführt wird, bestätigt dies, dass Ihr Personal Access Token die richtigen Berechtigungen für den Repository-Zugang hat.

Wenn Sie bei diesen Tests Probleme auftreten, überprüfen Sie noch einmal Ihre Token-Konfiguration und stellen Sie sicher, dass das Token die erforderlichen Bereiche (Permissions) für die Operationen hat, die Sie ausführen möchten.

Verwalten und Rotieren Ihrer Personal Access Tokens

Personal Access Tokens sollten genauso sorgfältig behandelt werden wie Passwörter. In diesem letzten Schritt werden wir bewährte Verfahren für die Verwaltung und Rotation Ihrer Tokens besprechen, um die Sicherheit aufrechtzuerhalten.

Auflisten Ihrer Personal Access Tokens

Um Ihre vorhandenen Personal Access Tokens auf GitHub anzuzeigen:

Mit der GitHub CLI:
```
gh auth status
```
Dieser Befehl zeigt Informationen über Ihren aktuellen Authentifizierungsstatus an, einschließlich des verwendeten Tokens.
Alternativ können Sie alle Ihre Tokens über die GitHub-Weboberfläche anzeigen:
- Gehen Sie auf GitHub.com und melden Sie sich an.
- Klicken Sie auf Ihr Profilbild oben rechts.
- Wählen Sie "Settings" (Einstellungen).
- Navigieren Sie zu "Developer settings" (Entwicklereinstellungen) > "Personal access tokens" (Persönliche Zugangstoken) > "Tokens (classic)" (Tokens (klassisch)).

Bewährte Verfahren für die Token-Sicherheit

Um die Sicherheit Ihrer Personal Access Tokens aufrechtzuerhalten, befolgen Sie diese bewährten Verfahren:

Begrenzen Sie die Token-Bereiche (Scopes): Gewähren Sie nur die minimal erforderlichen Berechtigungen für den vorgesehenen Zweck des Tokens.
Verwenden Sie beschreibende Namen: Geben Sie Ihren Tokens sinnvolle Namen, die ihren Zweck und ihre Verwendung anzeigen.
Setzen Sie Ablaufdatumsangaben: Für nicht-kritische Tokens setzen Sie ein Ablaufdatum, um eine regelmäßige Rotation zu erzwingen.

Um ein Token mit einem Ablaufdatum mit der GitHub CLI zu erstellen:
```
gh auth refresh -s repo,read:org --expiry 30d
gh auth token
```
Dies erstellt ein Token, das in 30 Tagen abläuft.
Überprüfen Sie regelmäßig Ihre Tokens: Überprüfen Sie regelmäßig Ihre Tokens und widerrufen Sie alle, die nicht mehr benötigt werden.
Speichern Sie Tokens sicher: Speichern Sie Tokens niemals in öffentlichen Repositorys, unverschlüsselten Dateien oder teilen Sie sie mit anderen.
Verwenden Sie Umgebungsvariablen: Wenn Sie Tokens in Skripten oder Anwendungen verwenden, speichern Sie sie als Umgebungsvariablen anstatt sie hartzucodieren.

Beispiel:
```
export GITHUB_TOKEN=your_token_here
```

Widerrufen eines Personal Access Tokens

Wenn Sie vermuten, dass ein Token kompromittiert wurde oder nicht mehr benötigt wird, widerrufen Sie es sofort:

Mit der GitHub CLI (ersetzen Sie TOKEN durch Ihr Token):
```
gh auth logout
```
Dies meldet Sie ab und macht das aktuelle Token ungültig.
Über die GitHub-Weboberfläche:
- Gehen Sie auf GitHub.com und melden Sie sich an.
- Navigieren Sie zu "Settings" (Einstellungen) > "Developer settings" (Entwicklereinstellungen) > "Personal access tokens" (Persönliche Zugangstoken) > "Tokens (classic)" (Tokens (klassisch)).
- Suchen Sie das Token, das Sie widerrufen möchten.
- Klicken Sie auf "Delete" (Löschen) und bestätigen Sie die Aktion.

Rotieren Ihrer Tokens

Eine regelmäßige Token-Rotation ist eine gute Sicherheitsmaßnahme. So rotieren Sie Ihre Tokens:

Generieren Sie ein neues Token mit den gleichen Berechtigungen wie das alte.
Aktualisieren Sie Ihre Anwendungen und Konfigurationen, um das neue Token zu verwenden.
Testen Sie, ob alles mit dem neuen Token funktioniert.
Widerrufen Sie das alte Token.

Für automatisierte Prozesse sollten Sie in Betracht ziehen, Umgebungsvariablen oder sichere Tresore zur Speicherung von Tokens zu verwenden, um die Rotation zu vereinfachen.

## Generate a new token
gh auth refresh -s repo,read:org
NEW_TOKEN=$(gh auth token)

## Update your Git remote URL with the new token
git remote set-url origin https://${NEW_TOKEN}@github.com/yourusername/your-repo.git

## Verify it works
git fetch

## Revoke the old token through GitHub website
echo "Remember to revoke your old token in GitHub settings"

Indem Sie diese bewährten Verfahren befolgen, können Sie einen sicheren Zugang zu Ihren Git-Repositorys aufrechterhalten und gleichzeitig das Risiko eines unbefugten Zugangs minimieren.

Zusammenfassung

In diesem Tutorial haben Sie gelernt, wie Sie effektiv mit Git Personal Access Tokens arbeiten können. Hier ist eine Zusammenfassung dessen, was Sie erreicht haben:

Sie verstehen die Wichtigkeit und die Vorteile der Verwendung von Personal Access Tokens für die Git-Authentifizierung.
Sie haben ein Personal Access Token auf GitHub sowohl mit der CLI als auch über die Weboberfläche generiert.
Sie haben Git so konfiguriert, dass es Ihr Personal Access Token für Repository-Operationen verwendet.
Sie haben Ihre Token-Konfiguration durch Ausführen grundlegender Git-Operationen getestet.
Sie haben bewährte Verfahren für die Verwaltung, Sicherheit und Rotation Ihrer Tokens gelernt.

Indem Sie Personal Access Tokens anstelle von Passwörtern verwenden, haben Sie die Sicherheit Ihres Git-Workflows verbessert. Sie können jetzt Tokens mit bestimmten Berechtigungen erstellen, ihre Lebensdauer begrenzen und sie bei Bedarf widerrufen, ohne dass sich dies auf Ihre Hauptkontoanmeldeinformationen auswirkt.

Denken Sie an diese wichtigen Punkte:

Verwenden Sie immer die minimal erforderlichen Berechtigungen für Ihre Tokens.
Speichern Sie Tokens sicher und teilen Sie sie niemals.
Rotieren Sie Tokens regelmäßig, insbesondere für sensible Repositorys.
Widerrufen Sie unbenutzte oder kompromittierte Tokens sofort.

Mit diesen Praktiken können Sie einen sicheren Zugang zu Ihren Git-Repositorys aufrechterhalten und gleichzeitig die Sicherheitsrisiken minimieren.