Skip to main content

Lokales Git-Repository mit GitHub verbinden 🔗

Du hast also schon fleißig lokal commitet und möchtest jetzt deinen Code sicher in der Cloud haben – sei es als Backup, um von mehreren Geräten darauf zuzugreifen oder um später mit anderen zusammenzuarbeiten. Die Verbindung zwischen deinem lokalen Repository und GitHub herzustellen ist ein wichtiger Meilenstein, und ich zeige dir hier ausführlich, wie das funktioniert.

Das Grundprinzip verstehen

Bevor wir loslegen, ist es hilfreich zu verstehen, was hier eigentlich passiert:

flowchart LR
    LOCAL["📁 Lokales Repository\nauf deinem Computer"] -->|git push| REMOTE["☁️ Remote Repository\nauf GitHub"]
    REMOTE -->|git pull| LOCAL

Dein lokales Repository enthält bereits deine gesamte Commit-Historie. GitHub stellt dir einen Remote zur Verfügung – das ist im Grunde eine Kopie deines Repositories auf einem Server, mit der du dein lokales Repository synchronisieren kannst. Die Verbindung zwischen beiden nennt man Remote-Verknüpfung, und der Standard-Name für die Haupt-Remote ist origin.

Schritt 1: Ein neues Repository auf GitHub erstellen

Zunächst brauchst du ein „Zuhause" für deinen Code auf GitHub. Dieses Repository erstellst du direkt auf der GitHub-Website.

  1. Bei GitHub anmelden

    Öffne github.com und melde dich mit deinem Account an. Falls du noch keinen hast, musst du zuerst einen erstellen.

  2. Neues Repository anlegen

    Klicke oben rechts auf das +-Symbol und wähle New repository (oder gehe direkt zu github.com/new).

  3. Repository-Einstellungen festlegen

    Jetzt siehst du ein Formular mit mehreren Optionen:

    • Repository name: Wähle einen aussagekräftigen Namen für dein Projekt. Am besten verwendest du den gleichen Namen wie dein lokaler Projektordner – das ist zwar nicht zwingend notwendig, macht es aber übersichtlicher. Beispiel: mein-webprojekt

    • Description (optional): Eine kurze Beschreibung deines Projekts. Das ist besonders nützlich, wenn du das Repository später öffentlich machst oder selbst nach Monaten noch wissen willst, worum es geht.

    • Visibility – Public oder Private:

      • Public: Jeder kann dein Repository sehen (aber nur du kannst Änderungen pushen, solange du niemanden einlädst).
      • Private: Nur du und eingeladene Personen können das Repository sehen.

      Für persönliche Projekte oder Lernprojekte ist „Private" oft die bessere Wahl – du kannst es später jederzeit öffentlich machen.

    • Initialize this repository with… ⚠️ Wichtig:

      Da du bereits ein lokales Repository mit Commits hast, solltest du hier nichts auswählen:

      • ❌ Kein Häkchen bei „Add a README file"
      • ❌ Kein Häkchen bei „Add .gitignore"
      • ❌ Kein Häkchen bei „Choose a license"

      Warum? Wenn GitHub diese Dateien automatisch erstellt, hat das neue Remote-Repository bereits einen Commit. Dein lokales Repository hat aber eine andere Historie – und das führt zu Konflikten beim ersten Push. Ein komplett leeres Repository lässt sich dagegen problemlos mit deinem bestehenden lokalen Repository verbinden.

  4. Repository erstellen

    Klicke auf Create repository. GitHub erstellt das Repository und zeigt dir eine Seite mit Anleitungen – genau diese werden wir im nächsten Schritt nutzen.

Schritt 2: Die Remote-URL kopieren

Nach der Erstellung zeigt GitHub dir eine Seite mit verschiedenen Optionen. Da du bereits ein lokales Repository hast, interessiert dich der Abschnitt „…or push an existing repository from the command line".

Bevor du die Befehle ausführst, brauchst du die URL deines Repositories. GitHub bietet zwei Varianten an:

Protokoll URL-Format Wann verwenden
HTTPS https://github.com/benutzername/repo.git Einfacher Einstieg, aber du musst dich bei jedem Push authentifizieren (oder einen Credential Manager nutzen)
SSH git@github.com:benutzername/repo.git Empfohlen, wenn du SSH-Keys eingerichtet hast – keine Passwort-Eingabe nötig

Falls du SSH-Keys bereits eingerichtet hast (siehe Kapitel zu SSH-Keys), wähle SSH. Ansonsten funktioniert HTTPS genauso gut – du wirst dann beim ersten Push nach deinen GitHub-Zugangsdaten gefragt.

Klicke auf den entsprechenden Tab (HTTPS oder SSH) und kopiere die angezeigte URL.

Schritt 3: Remote in PhpStorm hinzufügen

Jetzt verbindest du dein lokales Repository mit dem frisch erstellten GitHub-Repository. Das machst du, indem du eine Remote hinzufügst.

Variante A: Über das PhpStorm-Menü (empfohlen für Einsteiger)

  1. Git-Menü öffnen

    Gehe in PhpStorm zu Git → Manage Remotes… (in älteren Versionen: VCS → Git → Remotes…).

  2. Neue Remote hinzufügen

    Es öffnet sich ein Dialog, der alle konfigurierten Remotes anzeigt – bei einem frischen lokalen Repository ist diese Liste leer.

    Klicke auf das +-Symbol, um eine neue Remote hinzuzufügen.

  3. Name und URL eingeben

    • Name: Gib origin ein. Das ist der Standardname für die Haupt-Remote und wird von Git und den meisten Tools erwartet.
    • URL: Füge die kopierte GitHub-URL ein (HTTPS oder SSH).

    Klicke auf OK.

  4. Fertig!

    Die Remote ist jetzt konfiguriert. PhpStorm weiß nun, wo dein Code auf GitHub „wohnt".

Variante B: Über das Terminal in PhpStorm

Falls du lieber mit Befehlen arbeitest, kannst du das integrierte Terminal nutzen:

  1. Öffne das Terminal in PhpStorm (View → Tool Windows → Terminal oder Alt + F12).

  2. Gib folgenden Befehl ein (ersetze die URL durch deine eigene):

    git remote add origin https://github.com/dein-benutzername/mein-webprojekt.git

    Oder mit SSH:

    git remote add origin git@github.com:dein-benutzername/mein-webprojekt.git

  3. Überprüfe, ob die Remote korrekt hinzugefügt wurde:

    git remote -v

    Du solltest so etwas sehen:

    origin  https://github.com/dein-benutzername/mein-webprojekt.git (fetch)
origin  https://github.com/dein-benutzername/mein-webprojekt.git (push)

Schritt 4: Den ersten Push durchführen

Jetzt kommt der spannende Moment: Du lädst deine gesamte lokale Commit-Historie auf GitHub hoch!

In PhpStorm (grafisch)

  1. Push-Dialog öffnen

    Gehe zu Git → Push… (oder nutze das Tastenkürzel Ctrl + Shift + K auf Windows/Linux bzw. Cmd + Shift + K auf macOS).

  2. Push-Vorschau prüfen

    PhpStorm zeigt dir an, welche Commits gepusht werden – das sollten alle deine bisherigen lokalen Commits sein.

    Du siehst auch, zu welchem Branch gepusht wird. Standardmäßig ist das main (oder master, je nach deiner Git-Konfiguration).

  3. Push ausführen

    Klicke auf Push. Falls du HTTPS verwendest und noch keine Zugangsdaten gespeichert hast, wirst du nach deinem GitHub-Benutzernamen und Passwort gefragt (oder nach einem Personal Access Token – dazu gleich mehr).

Im Terminal

Alternativ kannst du den Push auch über das Terminal durchführen:

git push -u origin main

💡 Was bedeutet -u?

Die Option -u (oder --set-upstream) sorgt dafür, dass Git sich merkt, dass dein lokaler main-Branch mit dem Remote-Branch origin/main verknüpft ist. Danach reicht ein einfaches git push ohne weitere Parameter.

Falls dein Hauptbranch master heißt (bei älteren Git-Versionen oder Projekten), ersetze main durch master.

Authentifizierung bei HTTPS: Personal Access Token (PAT)

Falls du HTTPS verwendest und GitHub nach einem Passwort fragt, funktioniert dein normales GitHub-Passwort nicht mehr für Git-Operationen. Stattdessen benötigst du einen Personal Access Token (PAT).

Einen PAT erstellen

  1. Gehe auf GitHub zu Settings → Developer settings → Personal access tokens → Tokens (classic) (oder direkt: github.com/settings/tokens).

  2. Klicke auf Generate new token (classic).

  3. Gib dem Token einen beschreibenden Namen (z. B. „PhpStorm auf Laptop").

  4. Wähle ein Ablaufdatum – für mehr Sicherheit empfiehlt sich ein begrenzter Zeitraum (z. B. 90 Tage), den du bei Bedarf verlängern kannst.

  5. Setze mindestens folgende Berechtigungen (Scopes):

    • ✅ repo – Vollzugriff auf Repositories (nötig für Push/Pull)

  6. Klicke auf Generate token und kopiere den Token sofort – er wird nur einmal angezeigt!

Den Token verwenden

Wenn PhpStorm (oder Git) nach dem Passwort fragt, gibst du statt deines GitHub-Passworts den Personal Access Token ein.

💡 Tipp: PhpStorm kann den Token speichern, sodass du ihn nicht jedes Mal neu eingeben musst. Achte darauf, dass in den Einstellungen unter Appearance & Behavior → System Settings → Passwords ein sicherer Speicherort konfiguriert ist (z. B. der Systemschlüsselbund).

Nach dem Push: Überprüfen, ob alles geklappt hat ✅

  1. Auf GitHub nachschauen

    Öffne dein Repository auf GitHub (z. B. https://github.com/dein-benutzername/mein-webprojekt). Du solltest jetzt alle deine Dateien und die gesamte Commit-Historie sehen können.

  2. In PhpStorm

    Öffne das Git-Log (Git → Show Git Log). Du siehst jetzt neben deinen lokalen Branches auch den Remote-Branch origin/main, der auf denselben Commit zeigt wie dein lokaler main.

Zusammenfassung des gesamten Ablaufs

Hier nochmal alle Schritte im Überblick:

flowchart TD
    A["1. Leeres Repository\nauf GitHub erstellen"] --> B["2. Remote-URL kopieren\nHTTPS oder SSH"]
    B --> C["3. Remote in PhpStorm\nhinzufuegen via\nGit > Manage Remotes"]
    C --> D["4. Ersten Push durchfuehren\nGit > Push"]
    D --> E["5. Auf GitHub pruefen\nob alles angekommen ist"]

Häufige Probleme und Lösungen

„Failed to push: rejected – non-fast-forward"

Dieser Fehler tritt auf, wenn das Remote-Repository bereits Commits enthält, die du lokal nicht hast (z. B. weil du bei der Erstellung versehentlich eine README-Datei hast anlegen lassen).

Lösung:

  1. Ziehe zuerst die Remote-Änderungen mit git pull origin main --allow-unrelated-histories
  2. Löse eventuelle Merge-Konflikte
  3. Committe und pushe erneut

Besser: Erstelle das GitHub-Repository wirklich komplett leer (ohne README, ohne .gitignore, ohne Lizenz).

„Permission denied (publickey)"

Dieser Fehler erscheint, wenn du SSH verwendest, aber dein SSH-Key nicht korrekt eingerichtet ist.

Lösung:

  • Überprüfe, ob dein SSH-Key bei GitHub hinterlegt ist (unter github.com/settings/keys)
  • Teste die Verbindung mit ssh -T git@github.com
  • Alternativ: Wechsle zu HTTPS, bis du SSH korrekt eingerichtet hast

„Repository not found"

Entweder existiert das Repository nicht, der Name ist falsch geschrieben, oder du hast keine Zugriffsrechte (bei privaten Repositories).

Lösung:

  • Überprüfe die URL auf Tippfehler
  • Stelle sicher, dass du bei GitHub angemeldet bist
  • Bei privaten Repos: Prüfe, ob dein Account Zugriff hat

Wie es danach weitergeht

Nach dem ersten Push ändert sich dein Workflow nur minimal:

  1. Lokal arbeiten und committen – wie bisher
  2. Regelmäßig pushen – um deine Änderungen auf GitHub zu sichern (Git → Push oder Ctrl + Shift + K)
  3. Bei Bedarf pullen – falls du von einem anderen Gerät aus gepusht hast oder mit anderen zusammenarbeitest (Git → Pull)

Die Verknüpfung zwischen lokalem und Remote-Repository bleibt dauerhaft bestehen – du musst die Remote-Konfiguration nur einmal pro Projekt durchführen. 🎉

Back to top