Inhalt

Versionierung mit Git

GIT ist ein verteiltes Versionskontrollsystem, das von Einzelpersonen und Teams verwendet wird, um die Entwicklung von Softwareprojekten zu verwalten. Es hilft bei der Nachverfolgung von Änderungen, erleichtert die Zusammenarbeit und ermöglicht es, zu früheren Versionen eines Projekts zurückzukehren.

1. Installation von GIT

GIT Installieren

Download und Installation von GIT: Besuche git-scm.com und lade die passende Version für dein Betriebssystem herunter.

Authentifizierung mittels SSH am Beispiel von GitHub

1. Überprüfen, ob ein SSH-Schlüssel vorhanden ist

ls -al ~/.ssh

Falls Dateien wie id_rsa und id_rsa.pub oder id_ed25519 und id_ed25519.pub vorhanden sind, hast du bereits ein SSH-Schlüsselpaar.

2. Falls kein Schlüssel vorhanden → neuen Schlüssel anlegen

ssh-keygen -t ed25519 -C "deine.email@domain.at"

Generating public/private ed25519 key pair.
Enter file in which to save the key (~/.ssh/id_ed25519): ~/.ssh/id_ed25519
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in ~/.ssh/id_ed25519
Your public key has been saved in ~/.ssh/id_ed25519.pub
The key fingerprint is:
SHA256:VfG7pA5KD+J/z6sK+E1N58Lr7kW8Y3tjzPX2Wc8P9Dk deine.email@domain.at
The key's randomart image is:
+--[ED25519 256]--+
|        . .o.    |
|       . . o o   |
|      . .  o +   |
|       +..o.. .  |
|      . S..o.    |
|       .oo +     |
|      ..Eo.o.    |
|      .+o=.o.    |
|      .o+o.      |
+----[SHA256]-----+

Die ASCII-Kunst (Random Art) wird von OpenSSH automatisch generiert, um eine visuelle Repräsentation des SSH-Schlüssels zu bieten. Sie hilft dabei, Fingerprints schneller zu erkennen und manuelle Vergleiche zu erleichtern.

3. SSH-Agent starten und Schlüssel hinzufügen

eval "$(ssh-agent -s)"
ssh-add ~/.ssh/id_ed25519   # oder ~/.ssh/id_rsa

4. Öffentlichen Schlüssel zu GitHub hinzufügen

cat ~/.ssh/id_ed25519.pub

Anzeigen des Schlüssels

Auf github.com:

  1. Gehe zu GitHub → Einstellungen (Profilbild oben rechts anklicken).
  2. Links unter SSH and GPG keys → New SSH key klicken.
  3. Einen Namen vergeben (z. B. “Mein Laptop”).
  4. Den kopierten Schlüssel in das Feld einfügen und speichern.

Verbindung zu GitHub testen

ssh -T git@github.com

Falls alles klappt, siehst du eine Meldung wie:

Hi username! You've successfully authenticated, but GitHub does not provide shell access.

Falls nicht, überprüfe:

2. Funktionsweise von GIT

Hier der vereinfachte, grundlegende Arbeitsablaufs mit Git:

┌─────────────────────┐
│  Working Directory  │  (Lokale Dateien/Quellcode)
└─────────┬───────────┘
          │
          │ git add <datei>  (Änderungen vormerken)
          ▼
┌────────────────────┐
│    Staging Area    │
└─────────┬──────────┘
          │
          │ git commit -m "Nachricht"  (Änderungen festschreiben)
          ▼
┌────────────────────┐
│    Lokales Repo    │
└─────────┬──────────┘
          │
          │ git push origin <branch>   (Änderungen hochladen)
          ▼
┌─────────────────────┐
│  Remote Repository  │   (z.B. GitHub)
└─────────────────────┘

Funktionsweise von GIT

  1. Working Directory: Lokales Verzeichnis, in dem die Dateien bearbeitet werden.
  2. git add: Markiert Änderungen, die in den nächsten Commit aufgenommen werden sollen (Staging Area).
  3. git commit: Schreibt diese „gestagten“ Änderungen in deinen lokalen Git-Verlauf (lokales Repository).
  4. git push: Überträgt die lokalen Commits in das zentrale oder entfernte Repository (z. B. auf GitHub).

3. Anlegen eines Git-Repositories

Insbesondere in der Softwareentwicklung sorgt Git dafür, dass mehrere Personen gleichzeitig an demselben Code arbeiten können, ohne einander in die Quere zu kommen. Bevor man allerdings loslegen kann, muss dein Projekt unter Versionskontrolle gestellt werden. Dabei gibt es zwei übliche Wege:

  1. Man erstellst zuerst ein leeres Repository auf einem Git-Server (z.B. GitHub, GitLab, Gitea, etc.) und klont dieses anschließend auf ein lokales Gerät.
  2. Man wandelt ein existierendes, lokales Verzeichnis in ein Git-Repository um und verknüpft es danach mit einem leeren Remote-Repository auf dem Git-Server.

3.1. Leeres Projekt auf dem Git-Server anlegen und klonen

Ablauf

  1. Neues Repository auf dem Git-Server erstellen
    • Anmelden auf einem/r Gitserver/Git-Plattform (z.B. GitHub, Gitea, …)
    • Neues Repository erstellen, Namen vergeben, Sichtbarkeit festlegen
  2. Repository klonen
    • Clone-URL (HTTPS oder SSH) kopieren.
    • Im Terminal / Kommandozeile auf dem lokalen Rechner: 
      git clone <deine-Repo-URL>

      Der Befehl erstellt eine lokale Kopie, die bereits ein .git-Verzeichnis enthält und mit dem Remote-Repository auf dem Server verknüpft ist.

  3. Dateien hinzufügen
    • In den frisch geklonten Ordner wechseln: 
      cd <dein-Repo-Ordner>
    • Projektdateien anlegen oder vorhandene Dateien in dieses Verzeichnis kopieren.
  4. Commit und Push
    • Alle Dateien zur Versionskontrolle hinzufüge: 
      git add .
    • Einen ersten Commit erstellen: 
      git commit -m "Beschreibung zum ersten Commit"
    • Änderungen auf den Server übertragen: 
      git push origin main

      Benutzernamen und E-Mail setzen

      Git speichert bei jedem Commit den Namen und die E-Mail-Adresse des Commiters. Dazu müssen diese Informationen gesetzt werden:

      Für alle Repositories

      git config --global user.name "Max Muster"
git config --global user.email "max.muster@gmail.com"`

      Nur für dieses Repository

      git config user.name "Max Muster"
git config user.email "max.muster@gmail.com"`

3.2. Lokales Git-Repository mit einem Remote verbinden

Ablauf

  1. Lokales Verzeichnis initialisieren
    • Öffne das Terminal im Ordner deines bereits existierenden Projekts, etwa: 
      cd /pfad/zu/deinem/projekt
    • Initialisiere Git: 
      git init
    • Jetzt ist dein Ordner ein Git-Repository. Ein .git-Verzeichnis wurde angelegt.
  2. Ersten Commit lokal anlegen
    • Füge bestehende Dateien zur Versionskontrolle hinzu: 
      git add .
    • Erstelle deinen ersten Commit: 
      git commit -m "Initial commit from local project"
  3. Remote Repository anlegen
    • Gehe zu GitHub oder GitLab und klicke auf „New Repository“ bzw. „New Project“.
    • Lass das Repository wieder komplett leer (ohne README, .gitignore, etc.).
  4. Remote hinzufügen
    • Kopiere die URL deines neu angelegten (leeren) Remote-Repositorys.
    • Verknüpfe dein lokales Projekt mit diesem Remote: 
      git remote add origin <deine-Repo-URL>
    • Prüfe, ob die Verbindung richtig gesetzt wurde: 
      git remote -v
  5. Änderungen hochladen
    • Lade deinen lokal erstellten Commit in das entfernte Repository hoch: 
      git push -u origin main
    • Falls der Git-Server den Standard-Branch master nennt oder ein anderer Branch verwenden werden soll, passe main entsprechend an.

4. Git‐Workflow für Einzelpersonen

  1. Repository einrichten
    • Erstelle entweder lokal mit git init ein neues Git‐Repository oder klone ein bereits angelegtes (z. B. von GitHub).
    • Richte (falls nötig) ein Remote‐Repo ein, um deinen Code zu sichern oder von verschiedenen Rechnern aus daran zu arbeiten.
  2. Regelmäßig committen
    • Bearbeite deine Dateien im Working Directory.
    • Nutze git add und git commit, um logische Arbeitsschritte festzuhalten. Regelmäßige, kleine Commits mit präzisen Commit‐Nachrichten helfen dir, deinen Fortschritt nachzuvollziehen.
  3. Synchronisation (optional)
    • Falls du ein Remote‐Repository nutzt (z. B. GitHub), lade deine Commits mit git push origin main hoch.
    • Nutze git pull, wenn du auf verschiedenen Rechnern arbeitest, um immer den aktuellen Stand herunterzuladen.
  4. Branches verwenden (optional)
    • Als Einzelperson kannst du direkt in main oder master arbeiten, oder feature‐bezogene Branches anlegen, wenn du unterschiedliche Ideen oder experimentelle Features austesten möchtest.
    • Sobald ein Feature fertig ist, mergst du es zurück in main.

Vorteile (alleine):

5. Git‐Workflow für das Arbeiten im Team, erweiterte Konzepte

Branches

Code Reviews und Pull Requests

Konflikte

Gitignore

Übersicht der wichtigsten Kommandozeilenbefehle

Verzeichnisse, Dateien und Navigation

Operation Windows (CMD/PowerShell) macOS/Linux (bash/zsh) Erläuterung
Verzeichnis wechseln cd <Ordner>
cd ..		 cd <Ordner>
cd ..		 cd steht für change directory.
.. wechselt ins übergeordnete Verzeichnis.
Laufwerk wechseln C: oder D: (macOS hat keine Laufwerks-Buchstaben) Unter Windows wechselt man so das Laufwerk.
Unter macOS greift man z. B. über /Volumes/Name auf andere Medien zu.
Verzeichnis anlegen md <Ordner> mkdir <Ordner> Erstellt einen neuen Ordner.
Verzeichnis löschen (leer) rd <Ordner> rmdir <Ordner> Löscht einen leeren Ordner.
Verzeichnis löschen (inkl. Inhalt) rd <Ordner> /s rm -r <Ordner> Löscht Ordner inklusive aller Unterordner und Dateien. Vorsicht: Irreversibel!
Datei löschen del <Datei> rm <Datei> Löscht eine Datei.
Datei/Ordner umbenennen rename <alt> <neu>
(Ordner): ren <alt> <neu>		 mv <alt> <neu> Ändert den Namen einer Datei oder eines Ordners.
Datei/Ordner verschieben move <Quelle> <Ziel> mv <Quelle> <Ziel> Verschiebt eine Datei/ein Verzeichnis.
Aktuelles Verzeichnis anzeigen (Windows zeigt Pfad in der Prompt-Zeile) pwd Zeigt das aktuelle Arbeitsverzeichnis an. (In Windows CMD ist der Pfad meist direkt in der Eingabeaufforderung ersichtlich.)
Inhalt eines Verzeichnisses dir ls Zeigt alle Dateien und Ordner im aktuellen Verzeichnis an.
Detail-Anzeige (Dateiliste) dir (zeigt Standard-Infos)
oder dir /w / dir /p für unterschiedliche Darstellungen		 ls -l /w zeigt Dateinamen breitflächig, /p seitenweise. ls -l listet Dateidetails (Größe, Rechte, Datum) auf.
Konsole leeren cls clear Räumt den Bildschirm in der Konsole auf.

Weitere nützliche Befehle

Operation Windows macOS/Linux Erläuterung
Dateiinhalt anzeigen type <Datei> cat <Datei> Zeigt den Inhalt einer Textdatei in der Konsole an.
Umgebungsvariablen prüfen echo %VARIABLE% (CMD)
$Env:VARIABLE (PowerShell)		 echo $VARIABLE Gibt den Wert einer Umgebungsvariablen aus (z. B. PATH).
Ausgabe umlenken > und >> (z. B. dir > liste.txt) > und >> (z. B. ls > liste.txt) Lenkt die Ausgabe eines Befehls in eine Datei um (> überschreibt, >> hängt an).
Programm/Datei suchen where <Programm> which <Programm> Zeigt den Pfad zu einer ausführbaren Datei (z. B. git).
Beenden/Exit exit exit Beendet die aktuelle Konsole oder Sitzung.

Git-Nutzung: Wichtige Ergänzungen für die Konsole

Wenn du Git über die Konsole benutzt, brauchst du zusätzlich zu den oben genannten Shell-Befehlen vor allem die Git-Befehle selbst (z. B. git init, git add, git commit, git status, git push, git pull, usw.). In Kombination mit den allgemeinen Systembefehlen gelingt dir so die komplette Projektverwaltung:

Durch die Kombination dieser beiden Bereiche (System- und Git-Befehle) kannst du sowohl im Dateisystem navigieren, Dateien/Ordner verwalten als auch deine Versionskontrolle vollständig über das Terminal abwickeln.

Ressourcen

Divers