SSH-Key für GitHub nutzen
SSH ist eine von zwei Möglichkeiten, dich bei GitHub auszuweisen – und nicht die einzige. GitHub hat 2021 die Passwort-Authentifizierung für Git-Vorgänge abgeschafft, nicht aber HTTPS als Weg. Über HTTPS funktioniert der Zugriff weiterhin, nur eben mit einem persönlichen Zugriffstoken statt eines Passworts. Du hast also die Wahl zwischen zwei Verfahren: HTTPS mit Token oder SSH mit einem Schlüsselpaar. Dieser Artikel zeigt den SSH-Weg – und vor allem jene Stelle, an der es in der Praxis klemmt: Die Adressform beim Klonen entscheidet darüber, worüber ein Klon später kommuniziert. Ein hinterlegter Schlüssel allein ändert daran nichts.
Zusammenfassung
- Zwei Wege zu GitHub: HTTPS mit Zugriffstoken oder SSH mit Schlüsselpaar
- Schlüsselpaar erzeugen mit
ssh-keygenund dem Verfahren Ed25519 - Hinterlegt wird ausschließlich der öffentliche Teil
- Die Adressform beim Klonen legt den Übertragungsweg fest
- Bestehenden Klon umstellen mit
git remote set-url - Zwei Konten brauchen zwei Schlüsselpaare und einen Eintrag in
~/.ssh/config
Wann SSH sich lohnt
Beide Wege führen zum Ziel, sie unterscheiden sich im Alltag aber spürbar. Ein Zugriffstoken läuft irgendwann ab und will erneuert werden. Für HTTPS gibt es Hilfsprogramme, die die Zugangsdaten zwischenspeichern, damit du sie nicht bei jedem Vorgang eintippst. GitHub empfiehlt für Token die fein abgestufte Variante, bei der du die Rechte einzeln festlegst.
Ein Schlüsselpaar ist dagegen einmal eingerichtet und danach still. Keine Eingabe bei jedem Vorgang, kein Ablaufdatum, keine Erneuerung.
| Merkmal | HTTPS mit Token | SSH mit Schlüsselpaar |
|---|---|---|
| Nachweis | persönliches Zugriffstoken | privater Schlüssel auf deinem Rechner |
| Gültigkeit | läuft ab, Erneuerung nötig | kein Ablaufdatum |
| Eingabe im Alltag | je nach Hilfsprogramm, das die Daten zwischenspeichert | keine, sobald der Agent den Schlüssel hält |
| Rechte | fein abgestuft festlegbar | am Konto hinterlegter Schlüssel |
| Weiterverwendung | an GitHub gebunden | derselbe Schlüssel auch für andere Dienste |
Der letzte Punkt wiegt mehr, als er klingt. Derselbe Schlüssel öffnet dir auch den Zugang zu eigenen Servern, etwa zu einem Linux vServer. Wenn du einen solchen Server in Betrieb nimmst, lohnt sich danach ein Blick in Server absichern.
Seit Oktober 2026 kann GitHub bei ungewöhnlich hohem Verkehrsaufkommen auch für anonyme Abrufe öffentlicher Repositories über HTTPS vorübergehend eine Anmeldung verlangen. Vorgänge über SSH sind davon ausdrücklich nicht betroffen.
Schlüssel erzeugen
Ein Schlüsselpaar entsteht mit einem einzigen Befehl:
ssh-keygen -t ed25519 -C "deine@adresse.example"bashDie Option -t wählt das Verfahren. Ed25519 ist heute die Standardempfehlung. Die Option -C hängt einen Kommentar an, meist eine Adresse als Bezeichnung. Dieser Kommentar dient nur als Etikett und muss nicht deine GitHub-Adresse sein. Mit -f legst du Pfad und Namen selbst fest, etwa -f ~/.ssh/github_ed25519.
Es entstehen zwei Dateien: der private Schlüssel ohne Endung und der öffentliche mit der Endung .pub. Ein öffentlicher Ed25519-Schlüssel beginnt mit ssh-ed25519 AAAAC3NzaC1lZDI1NTE5, der private mit -----BEGIN OPENSSH PRIVATE KEY-----. Allein daran erkennst du, welche Datei du vor dir hast.
Beim Erzeugen fragt der Befehl nach einer Passphrase. Diese Passphrase schützt den privaten Schlüssel auf der Platte und darf Leerzeichen enthalten. Der private Schlüssel wird niemals weitergegeben. Wer ihn hat, kann sich als die zugehörige Person ausgeben.
Damit du die Passphrase nicht bei jedem Vorgang erneut tippst, gibt es den SSH-Agenten. Das ist ein Hintergrundprogramm, das den entschlüsselten privaten Schlüssel vorhält, sodass die Passphrase nur einmal je Sitzung nötig ist. Hinzugefügt wird der Schlüssel mit ssh-add ~/.ssh/github_ed25519. Unter macOS ab Monterey lautet der Aufruf ssh-add --apple-use-keychain ~/.ssh/github_ed25519, damit der Schlüsselbund die Passphrase speichert.
Unter Windows ohne Linux-Umgebung gilt ein eigener Weg. Wie du dort ein Schlüsselpaar erzeugst und verwaltest, liest du in SSH-Key mit PuTTY.
Den öffentlichen Teil eintragen
Hinterlegt wird ausschließlich der öffentliche Schlüssel. Seinen Inhalt zeigt dir:
cat ~/.ssh/github_ed25519.pubbashDiese eine Zeile trägst du in den Einstellungen deines Kontos im Bereich für SSH- und GPG-Schlüssel ein. Ob die Oberfläche dort gerade so oder anders aussieht, spielt keine Rolle – der Weg führt immer über die Kontoeinstellungen.
Danach prüfst du die Verbindung:
ssh -T git@github.combashBeim ersten Verbindungsaufbau fragt SSH, ob der Server in die Liste der bekannten Hosts aufgenommen werden soll. Das bestätigst du einmal, danach taucht die Frage nicht mehr auf.
Dateien im SSH-Verzeichnis
Alles, was mit Schlüsseln zu tun hat, liegt in einem einzigen Verzeichnis. Diese Übersicht hilft, wenn du später suchst:
| Pfad | Inhalt |
|---|---|
~/.ssh/ |
Verzeichnis für Schlüssel und Konfiguration |
~/.ssh/name |
privater Schlüssel, ohne Endung |
~/.ssh/name.pub |
öffentlicher Schlüssel |
~/.ssh/config |
Zuordnung von Kürzeln zu Zielen und Schlüsseln |
~/.ssh/known_hosts |
bereits bestätigte Gegenstellen |
Die Konfigurationsdatei braucht eingeschränkte Rechte. Gesetzt werden sie mit chmod 600 ~/.ssh/config.
Klonen, ziehen, pushen
Hier liegt der Kern. Ein Repository lässt sich über zwei verschiedene Adressformen ansprechen, und die Form, mit der du klonst, entscheidet dauerhaft darüber, worüber dieser Klon kommuniziert:
- HTTPS-Form:
https://github.com/benutzer/projekt.git - SSH-Form:
git@github.com:benutzer/projekt.git
Wer mit https://github.com/... klont, kommuniziert über HTTPS. Das bleibt auch dann so, wenn im Konto längst ein Schlüssel hinterlegt ist. Der Schlüssel wird in diesem Fall schlicht nicht gefragt. Für SSH brauchst du die zweite Form:
git clone git@github.com:benutzer/projekt.gitbashAuf GitHub lässt sich die Adressform auf der Projektseite umschalten, bevor du sie kopierst. Ein Blick darauf erspart dir die ganze Fehlersuche.
Bestehenden Klon umhängen
Für ein Projekt, das schon auf der Platte liegt, braucht es keinen neuen Klon. Welche Adresse im Einsatz ist, zeigt git remote -v. Umgestellt wird mit:
git remote set-url origin git@github.com:benutzer/projekt.gitbashDanach laufen git pull und git push über SSH, ohne weitere Eingabe.
Lesender Zugriff auf öffentliche Repositories braucht überhaupt keine Anmeldung. Der Schlüssel wird erst beim Schreiben gebraucht oder bei privaten Repositories.
Von null zum ersten Push
Der vollständige Ablauf in sieben Schritten:
- Schlüsselpaar erzeugen mit
ssh-keygen -t ed25519 -C "deine@adresse.example", den Pfad bei Bedarf über-f ~/.ssh/github_ed25519festlegen. - Eine Passphrase vergeben, wenn der Befehl danach fragt.
- Den privaten Schlüssel dem Agenten übergeben mit
ssh-add ~/.ssh/github_ed25519. - Den öffentlichen Teil mit
cat ~/.ssh/github_ed25519.pubanzeigen und in den Kontoeinstellungen eintragen. - Die Verbindung testen mit
ssh -T git@github.comund die Gegenstelle einmalig bestätigen. - Das Projekt in der SSH-Form klonen mit
git clone git@github.com:benutzer/projekt.git, oder einen vorhandenen Klon mitgit remote set-urlumhängen. - Änderungen mit
git pushhochladen – ohne Passwort, ohne Token.
Zwei Konten nebeneinander
Einen öffentlichen Schlüssel kannst du bedenkenlos bei mehreren Diensten hinterlegen. GitHub nimmt denselben öffentlichen Schlüssel allerdings nicht in zwei Konten an: Der Versuch endet mit der Meldung Key is already in use. Wer ein berufliches und ein privates Konto getrennt halten will, braucht deshalb zwei Schlüsselpaare und eine Zuordnung über die Konfigurationsdatei unter ~/.ssh/config.
Ein Eintrag besteht aus Host als frei gewähltem Kürzel, HostName als tatsächlichem Ziel, User git, IdentityFile mit dem Pfad zum privaten Schlüssel und IdentitiesOnly yes:
Host git-arbeit
HostName github.com
User git
IdentityFile ~/.ssh/github_ed25519
IdentitiesOnly yestextIdentitiesOnly yes sorgt dafür, dass nur der angegebene Schlüssel probiert wird. Ohne diese Einstellung probiert SSH der Reihe nach alle vorhandenen Schlüssel durch und scheitert nach einigen Versuchen mit der Meldung Too many authentication failures.
Über das Kürzel lässt sich dann klonen:
git clone git-arbeit:benutzer/projekt.gitbashDas Kürzel tritt damit an die Stelle von git@github.com. Für jedes weitere Konto legst du einen zweiten Block mit eigenem Kürzel und eigenem IdentityFile an.
Damit sind beide Fragen beantwortet, die hinter dem Thema stecken. SSH ist für GitHub kein Muss, sondern die bequemere der beiden Möglichkeiten – ohne Ablaufdatum und ohne Eingabe bei jedem Vorgang. Entscheidend ist dabei nicht der Schlüssel allein, sondern die Adresse: Ein Klon über https://github.com/... bleibt bei HTTPS, ganz gleich was im Konto hinterlegt ist. Wer git remote -v liest und bei Bedarf git remote set-url setzt, hat den häufigsten Stolperstein hinter sich. Alles Weitere erledigt der Agent im Hintergrund, und derselbe Schlüssel trägt dich anschließend auch zu deinen eigenen Servern.