Git und GitHub sind unverzichtbare Werkzeuge für jeden Entwickler. Sie werden bei fast jeder Art von Software-Entwicklungsprojekt eingesetzt.

Es gibt auch andere Git-Hosting-Dienste wie Gitlab und Bitbucket, aber GitHub ist die beliebteste Wahl für Entwickler. Du kannst sogar dein Profil bearbeiten, um für Personalverantwortliche attraktiver zu sein.

Du kannst Git und GitHub nutzen, um deine Projekte zu organisieren, mit anderen Entwicklern zusammenzuarbeiten und – natürlich – bei Kinsta.

Da Git und GitHub verwandte, aber unterschiedliche Tools sind, musst du deine Arbeitsabläufe mit jedem von ihnen ständig aktualisieren.

Wir empfehlen, SSH-Schlüssel für jeden deiner Rechner zu verwenden. In diesem Lernprogramm erfährst du, was das ist, welche Vorteile sie haben und wie du GitHub SSH-Schlüssel generierst und konfigurierst.

Los geht’s!

Was sind SSH-Schlüssel?

Einfach ausgedrückt sind SSH-Schlüssel Anmeldedaten, die für das SSH-Protokoll (Secure Shell) verwendet werden, um einen sicheren Zugang zu entfernten Computern über das Internet zu ermöglichen. Normalerweise erfolgt diese Authentifizierung in einer Befehlszeilenumgebung.

Dieses Protokoll basiert auf einer Client-Server-Architektur, was bedeutet, dass du als Benutzer (oder „Client“) eine spezielle Software, den sogenannten SSH-Client, verwenden musst, um dich bei einem entfernten Server anzumelden und Befehle auszuführen. Das ist im Grunde das, was du tust, wenn du dich über ein Terminal bei GitHub anmeldest.

Terminal showing two commands:
Git-Push.

SSH wird aber nicht nur für GitHub verwendet. Es wird auch von anderen Plattformen wie Kinsta, Google Cloud und Amazon Web Services verwendet, um einen sicheren Kanal für den Zugang zu ihren Diensten zu schaffen.

Um zu verstehen, wie SSH-Schlüssel wirklich funktionieren, musst du die Unterschiede zwischen öffentlichen und privaten Schlüsseln kennen.

Öffentliche und private Schlüssel

Beginnen wir mit den Grundlagen.

Das SSH-Protokoll verwendet eine kryptografische Technik namens asymmetrische Verschlüsselung. Dieser Begriff mag kompliziert und seltsam klingen, aber nichts könnte weiter von der Wahrheit entfernt sein.

Im Grunde ist die asymmetrische Verschlüsselung ein System, das ein Schlüsselpaar verwendet, nämlich einen öffentlichen und einen privaten Schlüssel.

Wie du dir vielleicht denken kannst, kann der öffentliche Schlüssel mit jedem geteilt werden. Sein Hauptzweck ist es, Daten zu verschlüsseln und die Nachricht in einen geheimen Code oder Chiffretext zu verwandeln. Dieser Schlüssel wird normalerweise an andere Systeme – z. B. Server – gesendet, um die Daten zu verschlüsseln, bevor sie über das Internet verschickt werden.

Der private Schlüssel hingegen ist der Schlüssel, den du für dich behalten musst. Er wird verwendet, um die verschlüsselten Daten mit deinem öffentlichen Schlüssel zu entschlüsseln. Ohne ihn ist es unmöglich, deine verschlüsselten Daten zu entschlüsseln.

Diese Methode ermöglicht es dir und dem Server, einen sicheren Kommunikationskanal für die Übermittlung der Daten zu nutzen.

Das passiert im Hintergrund, wenn du dich über SSH mit einem Server verbindest:

  1. Der Kunde sendet den öffentlichen Schlüssel an den Server.
  2. Der Server fordert den Kunden auf, eine zufällige Nachricht, die mit dem öffentlichen Schlüssel verschlüsselt wurde, mit dem privaten Schlüssel zu signieren.
  3. Der Kunde signiert die Nachricht und leitet das Ergebnis an den Server weiter.
  4. Es wird eine sichere Verbindung zwischen dem Client und dem Server hergestellt.

Es ist wichtig, dass du deine privaten Schlüssel sicher aufbewahrst und sie unter keinen Umständen mit anderen teilst. Sie sind buchstäblich der Schlüssel zu allen Informationen, die an dich gesendet werden.

SSH-Schlüssel bei GitHub verwenden

Seit dem 13. August 2021 akzeptiert Github keine Passwortauthentifizierung mehr für den Kommandozeilenzugang. Das bedeutet, dass du dich jetzt über ein persönliches Zugangs-Token authentifizieren oder einen SSH-Schlüssel verwenden musst (was ein bisschen bequemer ist).

So sieht es aus, wenn du versuchst, dich mit deinem GitHub-Passwort über HTTP in einem Terminal zu authentifizieren:

Username for 'https://github.com': yourusername

Password for 'https://[email protected]':

remote: Support for password authentication was removed on August 13, 2021. Please use a personal access token instead.

remote: Please see https://github.blog/2020-12-15-token-authentication-requirements-for-git-operations/ for more information.

fatal: Authentication failed for 'https://github.com/yourusername/repository.git/'

GitHub benötigt deinen öffentlichen Schlüssel, um dich zu autorisieren, eines deiner Repos über SSH zu bearbeiten.

Schauen wir uns an, wie du SSH-Schlüssel lokal erzeugen kannst.

Lokale SSH-Schlüssel generieren

Nachdem du nun ein wenig über das SSH-Protokoll und die Unterschiede zwischen öffentlichen und privaten Schlüsseln gelernt hast, ist es an der Zeit, den sicheren SSH-Kanal zwischen deinem Rechner und deinen GitHub-Repos einzurichten.

Bevor wir weitermachen, solltest du bereits ein GitHub-Konto und ein Terminal/eine Eingabeaufforderung mit Git in deinem System installiert haben. Wenn du mit Windows arbeitest, stelle sicher, dass du die Git-Bash installiert hast, die alle Werkzeuge enthält, die du für diese Anleitung brauchst.

Der OpenSSH-Client ist die beliebteste Open-Source-Software, die für die Verbindung über SSH verwendet wird. Du musst dir keine Gedanken über dein Betriebssystem machen, denn er ist unter Linux, macOS und Windows 10 standardmäßig installiert.

Um lokale SSH-Schlüssel zu erzeugen, musst du eine Eingabeaufforderung unter Windows oder ein Terminal auf Unix-basierten Systemen öffnen. Normalerweise kannst du das tun, indem du in deinem Anwendungsfenster nach „terminal“, „cmd“ oder „powershell“ suchst und dann auf das angezeigte Symbol klickst.

Application finder showing different terminal applications, including
Terminal-Anwendungssuche

Nachdem du das getan hast, solltest du ein Fenster ähnlich dem folgenden Bild sehen.

Semi-transparent terminal application running the fish shell.
Terminal-Anwendung.

Führe den folgenden Befehl aus, um ein lokales SSH-Schlüsselpaar zu erzeugen:

ssh-keygen -t ed25519 -C "[email protected]"

Ich verrate dir jetzt ein Geheimnis: Niemand kann sich diesen Befehl wirklich merken! Die meisten Entwickler müssen ihn jedes Mal googeln, weil:

  1. Es ist ein wirklich langer Befehl mit vergesslichen, zufällig wirkenden Zahlen.
  2. Wir benutzen ihn nur selten, also lohnt es sich meistens nicht, ihn auswendig zu lernen.

Es ist jedoch wichtig, jeden Befehl zu verstehen, den wir in unsere Terminals einführen, also lass uns sehen, was jeder Teil dieses Befehls bedeutet.

  • ssh-keygen: Das Kommandozeilentool zum Erstellen eines neuen SSH-Schlüsselpaars. Du kannst seine Flags sehen mit ssh-keygen help
  • –t ed25519: Das Flag -t wird verwendet, um den Algorithmus anzugeben, mit dem die digitale Signatur des Schlüsselpaars erstellt wird. Wenn dein System ihn unterstützt, ist ed25519 der beste Algorithmus, den du zur Erstellung von SSH-Schlüsselpaaren verwenden kannst.
  • -C „E-Mail“: Das Flag -C wird verwendet, um einen benutzerdefinierten Kommentar am Ende des öffentlichen Schlüssels anzugeben, bei dem es sich in der Regel um die E-Mail-Adresse oder die Kennung des Erstellers des Schlüsselpaars handelt.

Nachdem du den Befehl in dein Terminal eingegeben hast, musst du die Datei angeben, in der du die Schlüssel speichern möchtest. Standardmäßig befindet sie sich in deinem Home-Verzeichnis, in einem versteckten Ordner namens „.ssh“, aber du kannst sie nach Belieben ändern.

Dann wirst du nach einer Passphrase gefragt, die du zu deinem Schlüsselpaar hinzufügen kannst. Das ist eine zusätzliche Sicherheitsebene, falls dein Gerät zu irgendeinem Zeitpunkt kompromittiert wird. Das Hinzufügen einer Passphrase ist nicht obligatorisch, wird aber immer empfohlen.

So sieht der ganze Vorgang aus:

ssh-keygen command with various messages including the file the keys will be saved
ssh-keygen Befehl.

Wie du siehst, erzeugt dieser Befehl zwei Dateien in dem von dir gewählten Verzeichnis (normalerweise ~/.ssh): den öffentlichen Schlüssel mit der Erweiterung .pub und den privaten Schlüssel ohne Erweiterung.

Wir zeigen dir später, wie du den öffentlichen Schlüssel zu deinem GitHub-Konto hinzufügst.

SSH-Schlüssel zu ssh-agent hinzufügen

Das Programm ssh-agent läuft im Hintergrund, bewahrt deine privaten Schlüssel und Passphrasen sicher auf und hält sie für die Nutzung durch ssh bereit. Es ist ein großartiges Hilfsmittel, das dir das Eintippen deiner Passphrase erspart, wenn du dich mit einem Server verbinden willst.

Deshalb wirst du deinen neuen privaten Schlüssel zu diesem Agenten hinzufügen. So geht’s:

  1. Stelle sicher, dass ssh-agent im Hintergrund läuft. 
    eval `ssh-agent`
# Agent pid 334065

    Wenn du eine ähnliche Meldung wie diese erhältst, ist alles in Ordnung. Das bedeutet, dass der ssh-agent unter einer bestimmten Prozess-ID (PID) läuft.

  2. Füge deinen privaten SSH-Schlüssel (den ohne Erweiterung) zum ssh-agent hinzu. 
    ssh-add ~/.ssh/kinsta_keys

    Ersetze kinsta_keys durch den Namen deines SSH-Schlüssels. Wenn dies der erste Schlüssel ist, den du erstellt hast, sollte er „id_algorithm_used“ heißen, zum Beispiel id_ed25519.

SSH-Schlüssel zum GitHub-Konto hinzufügen

Der letzte Schritt besteht darin, deinen öffentlichen Schlüssel zu deinem GitHub-Konto hinzuzufügen. Folge einfach diesen Anweisungen:

  1. Kopiere deinen öffentlichen SSH-Schlüssel in deine Zwischenablage. Du kannst die Datei, in der er sich befindet, mit einem Texteditor öffnen und kopieren oder den Inhalt mit dem Terminal anzeigen. 
    cat ~/.ssh/kinsta_keys.pub
# ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIJl3dIeudNqd0DPMRD6OIh65tjkxFNOtwGcWB2gCgPhk [email protected]
  2. Logge dich bei GitHub ein und gehe in den oberen rechten Bereich der Seite, klicke auf dein Profilfoto und wähle Einstellungen.

    GitHub upper-right panel showing different sections with an arrow pointing to the Settings section.
    GitHub-Einstellungen.

  3. Klicke dann in deinen Profileinstellungen auf SSH- und GPG-Schlüssel.

    Profile settings panel showing the SSH and GPG keys option.
    SSH- und GPG-Schlüssel.

  4. Klicke auf die Schaltfläche Neuer SSH-Schlüssel.

    SSH keys section with an arrow pointing to the New SSH key button.
    Schaltfläche Neuer SSH-Schlüssel.

  5. Gib deinem neuen SSH-Schlüssel auf GitHub einen Titel – normalerweise das Gerät, von dem aus du den Schlüssel benutzen wirst. Dann fügst du den Schlüssel in den Schlüsselbereich ein.

    Add a new SSH key form with the fields
    Formular zum Hinzufügen eines neuen SSH-Schlüssels

  6. Füge deinen SSH-Schlüssel hinzu.

    Add SSH key button.
    Schaltfläche SSH-Schlüssel hinzufügen.

SSH-Verbindung mit einem Repo-Push testen

Jetzt ist es an der Zeit, alles zu testen, was du bisher gemacht hast. Du wirst ein bestehendes Repository per SSH ändern, übertragen und pushen, um sicherzustellen, dass deine Verbindung richtig eingerichtet ist.

Für unser Beispiel werden wir die einfache HTML-Seite ändern, die wir in unserem Tutorial Git für Webentwicklung erstellt haben.

Zuerst müssen wir das Repository auf unseren lokalen Rechner klonen. Wir können die Repository-Seite auf GitHub aufrufen und die dort angegebene SSH-Adresse kopieren.

GitHub page showing SSH clone command.
SSH-Clone-Befehl.

Dann klone das Repo mit einem Terminal:

git clone [email protected]:DaniDiazTech/HTML-site.git

Jetzt fügen wir einen einfachen <h1> Tag in die Datei index.html ein:

...
<div class="container my-2">
    <h1 class="text-center">A new title!<h1>
</div>

<div class="container my-3">
...
Simple HTML site with the title
Die einfache HTML-Seite.

Um diesen Beitrag einfach zu halten, fassen wir weder JavaScript noch CSS an. Aber wenn du dich mit JavaScript auskennst, findest du vielleicht einen Platz bei Kinsta. Prüfe die Programmierkenntnisse, die du brauchst, um Teil des Kinsta-Teams zu werden.

Nachdem du das getan hast, bestätige die Änderungen:

git commit -am "Added a simple title"

Pushe sie auf GitHub, wie du es normalerweise tun würdest.

git push

Wenn alles geklappt hat, herzlichen Glückwunsch! Du hast gerade eine SSH-Verbindung zwischen deinem Rechner und GitHub eingerichtet.

Mehrere SSH-Schlüssel für verschiedene GitHub-Konten verwalten

Wenn du mehrere GitHub-Konten hast – sagen wir eines für deine privaten Projekte und eines für deine Arbeit – ist es schwierig, SSH für beide zu nutzen. Normalerweise bräuchtest du getrennte Rechner, um dich bei verschiedenen GitHub-Konten zu authentifizieren.

Aber das lässt sich leicht lösen, indem du die SSH-Konfigurationsdatei konfigurierst.

Fangen wir damit an.

  1. Erstelle ein weiteres SSH-Schlüsselpaar und füge es zu deinem anderen GitHub-Konto hinzu. Merke dir den Namen der Datei, der du den neuen Schlüssel zuweist. 
    ssh-keygen -t ed25519 -C "[email protected]"
  2. Erstelle die SSH-Konfigurationsdatei. Die Konfigurationsdatei teilt dem ssh-Programm mit, wie es sich verhalten soll. Standardmäßig existiert die Konfigurationsdatei möglicherweise nicht, also erstelle sie im Ordner .ssh/: 
    touch ~/.ssh/config
  3. Ändere die SSH-Config-Datei. Öffne die Konfigurationsdatei und füge den unten stehenden Code ein: 
    #Your day-to-day GitHub account

Host github.com
  HostName github.com
  IdentityFile ~/.ssh/id_ed25519
  IdentitiesOnly yes

# Work account
Host github-work
  HostName github.com
  IdentityFile ~/.ssh/work_key_file
  IdentitiesOnly yes

Jedes Mal, wenn du dich über SSH mit deinem Arbeits- oder Zweitaccount authentifizieren musst, gibst du die SSH-Adresse des Repos ein wenig an:

[email protected]:workaccount/project.git

…zu:

git@github-work:workaccount/project.git

Zusammenfassung

Herzlichen Glückwunsch – du hast das meiste praktische Wissen gelernt, das du brauchst, um dich mit GitHub über SSH zu verbinden!

In diesem Tutorium haben wir uns mit der Notwendigkeit des SSH-Protokolls, den Unterschieden zwischen öffentlichen und privaten Schlüsseln, der Erstellung von Schlüsseln, dem Hinzufügen zu GitHub und der Verwaltung mehrerer SSH-Schlüssel für verschiedene GitHub-Konten beschäftigt. Denk daran, dass dein privater Schlüssel so bleiben muss, wie er ist, wenn du nicht den Zugriff auf alles verlieren willst: privat.

Mit diesem Wissen bist du nun in der Lage, einen reibungslosen Arbeitsablauf mit Git und GitHub zu entwickeln. Programmier weiter!

Daniel Diaz

Daniel ist ein autodidaktischer Python-Entwickler, technischer Redakteur und ein lebenslanger Lerner. Er liebt es, Software von Grund auf zu entwickeln und diesen Prozess in beeindruckenden Artikeln zu erklären. Folge ihm auf X: @DaniDiazTech