Github auf Linux initialisieren und nutzen

📅 Erstellt: 21.11.2025 🔄 Aktualisiert: 13.08.2026

Jo hier ma grober Ablauf ausm Kopf wie ich git unter CachyOS zum Laufen gebracht habe:

Ablauf mit git - "alte" Methode¶

Pakete git und github-cli müssen installiert sein
Ins Projektverzeichnis gehen hier Beispiel ~/bin
Repository anlegen: git init
Git konfigurieren
git config user.name "Username"
git config user.email "Username@Username.de"
Dateien zum ersten Commit hinzufügen und committen (lokal)
git add .
git commit -m "Initial commit"
SSH-Key erzeugen (wenn noch keiner existiert)
cd ~/.ssh
ssh-keygen -t ed25519 -C "Username@Username.de"
eval (ssh-agent -c
ssh-add ~/.ssh/<Private key name>
Achtung! Gegebenenfalls hat hier fish andere Quirks als ein bash, man prüft einfach, ob der Socket vorhanden ist in ~/.ssh/agent dann sollte alles funktionieren. Hier jedenfalls...
Alternativ siehe unten für Fish-Gedöns.
Den Inhalt des Public Keys ins Webinterface kopieren (oder mit github-cli gh erledigen)
Remote hinzufügen (SSH-URL)
git remote add origin git@github.com:USERNAME/REPO.git
Lokalen Branch ggf. umbenennen nach main (optional)
git branch -M main
Push (erstmalig mit -u)
git push -u origin main
Wahrscheinlich existiert der Remote noch nicht, checken mit:
git remote -v
SSH-Key prüfen
ssh -T git@github.com

Mit github-cli bzw. gh ein privates Repo anlegen¶

Mit gh auth login den Konfigurationsprozess starten, SSH verwenden und Key ggf. hochladen oder Skip wenn schon geschehen.
Dann ein neues privates Repo anlegen
gh repo create LinuxXXXXXxxxxXXXX --private
Mit git prüfen ob das Remote korrekt gesetzt wird
git remote -v
Ab jetzt kann man git push und git pull direkt aus einem Programm oder der Shell nutzen

Integration in Kate¶

TBD

Fish-Quirks¶

Sollte die Shell fish Probleme machen hier evtl. Lösungsmöglichkeit(en):

# starte ssh-agent und parse die Ausgabe
set -l out (ssh-agent -s)
set -x SSH_AUTH_SOCK (string match -r -- 'SSH_AUTH_SOCK=[^;]+' $out | string replace -r 'SSH_AUTH_SOCK=' '')
set -x SSH_AGENT_PID (string match -r -- 'SSH_AGENT_PID=[0-9]+' $out | string replace -r 'SSH_AGENT_PID=' '')

# Bestätigung
echo "SSH_AUTH_SOCK=$SSH_AUTH_SOCK"
echo "SSH_AGENT_PID=$SSH_AGENT_PID"

Danach den Key hinzufügen:
ssh-add ~/.ssh/<Private key name

Alternative für Fish (funktioniert!)¶

In die Datei ~/.config/fish/config.fish folgendes eintragen:
set -x SSH_AUTH_SOCK $XDG_RUNTIME_DIR/ssh-agent.socket

Ggf. muss auch der systemd Dienst gestartet sein, als User.

❯ systemctl status --user ssh-agent
● ssh-agent.service - OpenSSH key agent
     Loaded: loaded (/usr/lib/systemd/user/ssh-agent.service; indirect; preset: enabled)
     Active: active (running) since Sat 2025-11-22 09:24:19 CET; 7min ago
 Invocation: a98b7d0912d54a888718e68dd9810554
TriggeredBy: ● ssh-agent.socket
       Docs: man:ssh-agent(1)
             man:ssh-add(1)
             man:ssh(1)
   Main PID: 10161 (ssh-agent)
      Tasks: 1 (limit: 37836)
     Memory: 1.1M (peak: 1.7M)
        CPU: 4ms
     CGroup: /user.slice/user-1000.slice/user@1000.service/app.slice/ssh-agent.service
             └─10161 /usr/bin/ssh-agent -D

Nov 22 09:24:19 morphcachy systemd[1060]: Started OpenSSH key agent.

Bei Neustart der Fish Shell sollte bereits mit ssh-add -l eine andere Ausgabe kommen, kein Fehler:

❯ ssh-add -l
The agent has no identities.

❯ ssh-add ~/.ssh/xxxxx_git_key
Identity added: /home/Username/.ssh/xxxxx_git_key (xxxxx@xxx.org)
❯ ssh-add ~/.ssh/SSH_NAS_Username
Identity added: /home/Username/.ssh/SSH_NAS_Username (SSH_NAS_Username)
❯ ssh-add -l
256 SHA256:m... xxxxx@xxx.org (ED25519)
256 SHA256:o... SSH_NAS_Username (ED25519)

SSH auf Server "deployen"¶

Mit dem Befehl:
ssh-copy-id -i SSH_NAS_Username.pub Username@NASNAMELALA
wird der Public Key auf den entfernten SSH-Server kopiert. Der Server muss dazu einmalig ein Username/Passwort Login akzeptieren.

Git neu einrichten - Verzeichnisse synchronisieren¶

Alte CachyOS Installation -> neue CachyOS Installation

Was ist zu tun um z.B. lokal erstellte Skripte wieder zu und von GitHub zu "sichern" bzw. zu synchronisieren während auch schon Veränderungen oder weitere Skripte erstellt wurden?

Nutzerdaten global konfigurieren:

git config --global user.name "Dein Name"
git config --global user.email "deine.email@example.com"
git config --global init.defaultBranch main

SSH-Schlüssel einrichten:
ssh-keygen -t ed25519 -C "name@email.com"
3x Enter für Standardeinstellungen ohne Passwort
Öffentlichen Schlüssel anzeigen:
cat ~/.ssh/id_ed25519.pub
Das Schlüsselpaar zur besseren Handhabung umbenennen:
mv ~/.ssh/id_ed25519 ~/.ssh/id_ed25519_github
mv ~/.ssh/id_ed25519.pub ~/.ssh/id_ed25519_github.pub
SSH-Config anlegen/bearbeiten:
nano ~/.ssh/config
Den Block hinzufügen:
```
Host github.com
    HostName github.com
    User git
    IdentityFile ~/.ssh/id_ed25519_github
    IdentitiesOnly yes
```
Absichern:
chmod 600 ~/.ssh/config
chmod 600 ~/.ssh/id_ed25519_github
Den ~/bin-Ordner sichern (temporär):
cp -r ~/bin ~/bin_backup

In den Ordner wechseln und Git lokal initialisieren:
cd ~/bin

git init
Bestehendes Git-Repository in /home/DeinUsername/bin/.git/ neuinitialisiert

Das Remote-Repo hinzufügen per SSH:
git remote add origin git@github.com:DeinUsername/bin.git
oder wenn bereits ein Remote-Eintrag existiert:
git remote set-url origin git@github.com:DeinUsername/blabla-homebin.git
oder HTTPS:
git remote add origin https://github.com/DeinUsername/bin.git
oder wenn bereits ein Remote-Eintrag existiert, nehme ich an wird es äquivalent zur SSH-Methode funktionierten (nicht getestet)
Prüfung:
```
~/bin main*
❯ git remote -v
origin  git@github.com:DeinUsername/blabla-homebin.git (fetch)
origin  git@github.com:DeinUsername/blabla-homebin.git (push)
```

Remote-Verlauf abrufen (ohne Dateien zu überschreiben):
git fetch origin
Auszug:

❯ git fetch origin
The authenticity of host 'github.com (140.82.121.3)' can't be established.
ED25519 key fingerprint is: SHA256:+DiY3wvvV6TuJJhbpZisF/zLDA0zPMSvHdkr4UvCOqU
This key is not known by any other names.
Are you sure you want to continue connecting (yes/no/[fingerprint])? yes
Warning: Permanently added 'github.com' (ED25519) to the list of known hosts.
git@github.com: Permission denied (publickey).
Schwerwiegend: Konnte nicht vom Remote-Repository lesen.

Bitte stellen Sie sicher, dass die korrekten Zugriffsberechtigungen bestehen
und das Repository existiert.

Ist der Schlüssel noch nicht nutzbar, den Public Key kopieren und bei GitHub hinterlegen:
```
❯ cat ~/.ssh/id_ed25519_github.pub 
ssh-ed25519 AA... x.xxxxxxx@yyy.net
```
Bei GitHub Profilbild -> Settings -> SSH and GPG keys, New SSH key, siehe Bild:

Verbindung testen:

❯ ssh -T git@github.com
Hi xxyy! You've successfully authenticated, but GitHub does not provide shell access.

Erneut Remote-Verlauf abrufen (aus 7.):
git fetch origin
Läuft ohne irgendeine Meldung durch, dann (scheint) alles okay...

Remote-Branch überprüfen:

❯ git branch -r
  origin/HEAD -> origin/main
  origin/main

Commit-Historie verknüpfen (ohne lokale Dateien zu verändern):

❯ git reset --mixed origin/main
Nicht zum Commit vorgemerkte Änderungen nach Zurücksetzung:
M       xxxxxx_XX.sh

Status abfragen:

❯ git status
Auf Branch main
Ihr Branch ist auf demselben Stand wie 'origin/main'.

Änderungen, die nicht zum Commit vorgemerkt sind:
  (benutzen Sie "git add <Datei>...", um die Änderungen zum Commit vorzumerken)
  (benutzen Sie "git restore <Datei>...", um die Änderungen im Arbeitsverzeichnis zu verwerfen)
        geändert:       xxxxxx_XX.sh

Unversionierte Dateien:
  (benutzen Sie "git add <Datei>...", um die Änderungen zum Commit vorzumerken)
            neue_Datei.sh
            auch_neu_xD.py
            ...

keine Änderungen zum Commit vorgemerkt (benutzen Sie "git add" und/oder "git commit -a")

Änderungen sichern und hochladen:
git add .
git commit -m "Update scripts and add new tools after CachyOS reinstall"
Auszug:

❯ git commit -m "Update scripts and add new tools after CachyOS reinstall"
[main fxxxxxx] Update scripts and add new tools after CachyOS reinstall
 14 files changed, 1230 insertions(+), 5 deletions(-)
 create mode 100755 neue_Datei.sh
 create mode 100644 archiv/blabla.sh.working
 ...
 ...

Hochladen (push):
git push -u origin main
Auszug:

❯ git push -u origin main
Objekte aufzählen: 20, fertig.
Zähle Objekte: 100% (20/20), fertig.
Delta-Kompression verwendet bis zu 16 Threads.
Komprimiere Objekte: 100% (17/17), fertig.
Schreibe Objekte: 100% (17/17), 19.74 KiB | 3.95 MiB/s, fertig.
Gesamt 17 (Delta 5), Wiederverwendet 0 (Delta 0), Paket wiederverwendet 0 (von 0)
remote: Resolving deltas: 100% (5/5), completed with 2 local objects.
To github.com:DeinUsername/blabla-homebin.git
   8xxxxxx..fxxxxxx  main -> main
Branch 'main' folgt nun 'origin/main'.

Backup nach Prüfung aller Dateien dann wieder löschen:
rm -rf ~/bin_backup

Fertig.

Git abgleichen bzw. hochladen neuer/veränderter Dateien (regulärer Ablauf)¶

So, nun der allgemeine Prozess in der Linux-Shell, um einfach o.g. Repo zu aktualisieren.

ACHTUNG! Wir arbeiten hier im jeweiligen Verzeichnis, d.h. z.B. ~/bin, wir machen also vorher natürlich: cd ~/bin!

Zur Übung erstellen wir test.sh: touch test.sh

Änderungen vormerken (staging):
git add .
Dass es keine Ausgabe gibt ist hier wohl normal.

Commit erstellen (lokal speichern):
git commit -m "test.sh getouched :-))"
Auszug:

❯ git commit -m "test.sh getouched :-))"
[main 0xxxxxx] test.sh getouched :-))
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 test.sh

Auf GitHub hochladen:
git push
Auszug:

❯ git push
Objekte aufzählen: 4, fertig.
Zähle Objekte: 100% (4/4), fertig.
Delta-Kompression verwendet bis zu 16 Threads.
Komprimiere Objekte: 100% (2/2), fertig.
Schreibe Objekte: 100% (3/3), 272 Byte | 272.00 KiB/s, fertig.
Gesamt 3 (Delta 1), Wiederverwendet 1 (Delta 0), Paket wiederverwendet 0 (von 0)
remote: Resolving deltas: 100% (1/1), completed with 1 local object.
To github.com:DeinUsername/blabla-homebin.git
   fxxxxxx..0xxxxxx  main -> main

Ablauf mit Status prüfen (was läuft da überhaupt):

❯ git status
Auf Branch main
Ihr Branch ist auf demselben Stand wie 'origin/main'.

nichts zu committen, Arbeitsverzeichnis unverändert

~/bin main
❯ touch test2.sh

~/bin main*
❯ git status
Auf Branch main
Ihr Branch ist auf demselben Stand wie 'origin/main'.

Unversionierte Dateien:
  (benutzen Sie "git add <Datei>...", um die Änderungen zum Commit vorzumerken)
        test2.sh

nichts zum Commit vorgemerkt, aber es gibt unversionierte Dateien
(benutzen Sie "git add" zum Versionieren)

Automatisierung¶

TBD

...EOF