JonnyBravo/hugo_docker
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

first

Browse Source
This commit is contained in:
jonnybravo
2026-09-08 11:02:29 +02:00
commit 3ad8c9b5a6
66 changed files with 6169 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
content/AWX_und_Rundeck_install.md
+131
View File
@@ -0,0 +1,131 @@
---
title: "Rundeck und AWX Installation mit Docker"
date: "2026-09-08"
---
# Rundeck und AWX Installation mit Docker
Diese Anleitung zeigt, wie man Rundeck und AWX in Docker-Containern installiert, wobei alle wichtigen Daten persistent gespeichert werden.
## Voraussetzungen
- Docker und Docker-Compose installiert
- Ausreichend Speicherplatz (mindestens 2GB empfohlen)
- Ports 4440 und 8052 frei
## Rundeck Installation
1. Verzeichnis für persistente Daten erstellen:
```bash
mkdir -p ~/rundeck_data
```
2. Rundeck Container starten:
```bash
docker run -d \
-p 4440:4440 \
-v ~/rundeck_data:/home/rundeck/server/data \
--name rundeck \
rundeck/rundeck:latest
```
3. Zugriff:
- URL: http://<deine-ip>:4440
- Login: admin/admin
## AWX Installation
1. Verzeichnisse für persistente Daten erstellen:
```bash
mkdir -p ~/awx_data/postgres ~/awx_data/projects
```
2. docker-compose.yml erstellen:
```bash
cat <<EOL > ~/awx_data/docker-compose.yml
version: '3'
services:
postgres:
image: postgres:13
volumes:
- ~/awx_data/postgres:/var/lib/postgresql/data
environment:
POSTGRES_DB: awx
POSTGRES_USER: awx
POSTGRES_PASSWORD: awxpass
awx:
image: ansible/awx:latest
depends_on:
- postgres
ports:
- "8052:8052"
volumes:
- ~/awx_data/projects:/var/lib/awx/projects
environment:
DATABASE_USER: awx
DATABASE_PASSWORD: awxpass
DATABASE_NAME: awx
DATABASE_HOST: postgres
EOL
```
3. AWX starten:
```bash
cd ~/awx_data
docker-compose up -d
```
4. Zugriff:
- URL: http://<deine-ip>:8052
- Login: admin/password
## Persistenz und Autostart
Um sicherzustellen, dass die Container nach einem Neustart automatisch starten, können Systemd-Services eingerichtet werden:
1. Für Rundeck:
```bash
sudo bash -c 'cat <<EOL > /etc/systemd/system/rundeck-docker.service
[Unit]
Description=Rundeck Docker Container
After=docker.service
[Service]
Restart=always
ExecStart=/usr/bin/docker start -a rundeck
ExecStop=/usr/bin/docker stop -t 2 rundeck
[Install]
WantedBy=multi-user.target
EOL'
```
2. Für AWX:
```bash
sudo bash -c 'cat <<EOL > /etc/systemd/system/awx-docker.service
[Unit]
Description=AWX Docker Container
After=docker.service
[Service]
WorkingDirectory=/home/$(whoami)/awx_data
Restart=always
ExecStart=/usr/local/bin/docker-compose up
ExecStop=/usr/local/bin/docker-compose down
[Install]
WantedBy=multi-user.target
EOL'
```
3. Services aktivieren:
```bash
sudo systemctl daemon-reload
sudo systemctl enable rundeck-docker
sudo systemctl enable awx-docker
```
## Wichtige Hinweise
- Beide Lösungen können parallel betrieben werden
- Daten werden in ~/rundeck_data und ~/awx_data gespeichert
- Für Produktivumgebungen sollten zusätzliche Sicherheitsmaßnahmen getroffen werden
content/Install_Browser.md
+197
View File
@@ -0,0 +1,197 @@
---
title: "qutebrowser Installation (Wayland / Sway)"
date: "2026-09-08"
---
# qutebrowser Installation (Wayland / Sway)
Tastaturgesteuerter, vim-artiger Browser auf Basis von Python + QtWebEngine
(Chromium/Blink-Engine). Kein Fork, sondern eigenständig.
Hinweis: qutebrowser liegt im offiziellen Repo (`extra`), nicht im AUR.
---
## 1. Basis-Installation
```bash
sudo pacman -S qutebrowser
```
---
## 2. Video-Hardwarebeschleunigung (VAAPI)
Deine GPU: Intel Iris Xe (TigerLake). Dafür brauchst du den Intel-Media-Driver
und die VAAPI-Utils zum Prüfen:
```bash
sudo pacman -S intel-media-driver libva-utils
```
Testen ob VAAPI läuft:
```bash
vainfo
```
Erwartete Ausgabe: eine Liste mit Profilen (H264, HEVC/VP9-Decoding etc.).
Falls leer oder Fehler -> Treiberproblem.
In qutebrowser aktivieren (`:set` oder in `~/.config/qutebrowser/config.py`):
```
qt.args:
- ignore-gpu-blocklist
- enable-features=VaapiVideoDecoder,VaapiVideoDecodeLinuxGL
- enable-accelerated-video-decode
```
---
## 3. DRM / Widevine (Netflix, Prime, Spotify …)
Widevine ist proprietär und nicht im offiziellen Repo. Das AUR-Paket
`chromium-widevine` stellt das Widevine-CDM (`libwidevinecdm.so`) bereit:
```bash
yay -S chromium-widevine
```
Das Paket legt die Bibliothek ab unter:
```
/usr/lib/chromium/libwidevinecdm.so
```
Pfad in qutebrowser bekannt machen (in `config.py`):
```python
c.qt.args = [
"widevine-path=/usr/lib/chromium/libwidevinecdm.so",
"ignore-gpu-blocklist",
"enable-features=VaapiVideoDecoder",
]
```
Danach qutebrowser neu starten und prüfen:
```
:version
```
Dort sollte Widevine aufgelistet sein. Prüfseite: https://bitmovin.com/demos/drm
Wichtige Einschränkung: Widevine unter Linux liefert maximal **1080p** (L3-Lizenz).
4K-Streaming geht auf Linux nur mit Microsoft Edge oder Safari/macOS.
---
## 4. Wayland-nativ starten
Sway ist Wayland, also qutebrowser nativ (ohne XWayland) laufen lassen:
```
:set qt.args
```
oder in `config.py`:
```python
c.qt.args = ["widevine-path=..."]
```
Standardmäßig nutzt qutebrowser unter Sway bereits Wayland. Prüfen:
```
:version
```
Unter "Qt" sollte `wayland` als Platform stehen (nicht `xcb`).
---
## 5. Adblock & Datenschutz
qutebrowser hat einen eingebauten Host-Datei-Adblocker. Listen aktualisieren:
```
:adblock-update
```
Für besseren Schutz in `config.py`:
```python
# Standard-User-Agent abschalten (weniger Fingerprinting)
c.content.headers.user_agent = None
# DNT / Tracking-Opt-out
c.content.headers.do_not_track = True
```
---
## 6. Minimale Beispiel-Konfiguration
Datei: `~/.config/qutebrowser/config.py`
```python
import os
# DRM + Video-Hardwarebeschleunigung
c.qt.args = [
"widevine-path=/usr/lib/chromium/libwidevinecdm.so",
"ignore-gpu-blocklist",
"enable-features=VaapiVideoDecoder,VaapiVideoDecodeLinuxGL",
]
# Startseite
c.url.start_pages = ["https://duckduckgo.com"]
# Adblock-Listen
c.content.blocking.enabled = True
c.content.blocking.method = "both" # hosts + adblock
c.content.blocking.hosts.lists = [
"https://raw.githubusercontent.com/StevenBlack/hosts/master/hosts",
]
# Tabs / Verhalten
c.tabs.position = "top"
c.confirm_quit = ["downloads"]
# Tastatur: h/j/k/l Navigation (bereits Standard bei qutebrowser)
```
---
## 7. Wichtigste Tastenkürzel
| Taste | Aktion |
|---|---|
| `:` | Befehlszeile |
| `o` | URL öffnen |
| `O` | URL in neuem Tab öffnen |
| `f` | Links per Buchstabenkürzel anklicken |
| `H` / `L` | Zurück / Vor |
| `j` / `k` | Nach unten / oben scrollen |
| `gg` / `G` | Seitenanfang / -ende |
| `J` / `K` | Nächster / vorheriger Tab |
| `d` / `u` | Tab schließen / wieder öffnen |
| `/` | Suche auf Seite |
| `n` / `N` | Nächstes / vorheriges Suchergebnis |
| `yy` | URL in Zwischenablage |
| `ZZ` | qutebrowser beenden |
---
## 8. Alternativen im Überblick (schnell & sicher auf Sway)
| Browser | Engine | Install | Anmerkung |
|---|---|---|---|
| qutebrowser | Blink (Qt) | `sudo pacman -S qutebrowser` | Tastatur-only, ideal für Tiling |
| LibreWolf | Gecko (Firefox) | `yay -S librewolf-bin` | Firefox ohne Telemetrie, +uBlock |
| ungoogled-chromium | Blink | `yay -S ungoogled-chromium-bin` | Chromium ohne Google |
| Brave | Blink | `yay -S brave-bin` | Built-in Werbeblocker |
Für 4K-Streaming + Extensions: Brave. Für maximalen Datenschutz: LibreWolf.
Für reine Tastatur-Steuerung im Tiling-WM: qutebrowser.
content/Stretchen_laufen.md
+23
View File
@@ -0,0 +1,23 @@
---
title: "Stretchen_laufen"
date: "2026-09-08"
---
Aufwärmen:
10-15 Wh. 1-2 Sek.
1. Zwillingswadenmuskel dehnen S166
2. Zwillingswadenmuskel dehen S164
3. Beste Dhenübung der Welt S140
4. Girlanden-Haltung S126
5. Hüftkreisen im Stehen S148
6. Oberschenkelrückseite dynamisch dehen S163
Einsteiger :
10-15 Wh. 1-2 Sek.
1. Katze - Kuh S74
2. Quadrizeps dehnen im Stehen S156
3. Oberschenkelrückseite statisch S160
4. Hüftbeuger mithilfe eines Stuhles S137
5. Zwillingswardenmuskel dehnen S166
6. Hüftkreisen im Viertelfüser S150
7. Oberschenkelrückseite S163
content/astro-vim-recommendations.md
+48
View File
@@ -0,0 +1,48 @@
---
title: "Empfehlungen für AstroVim"
date: "2026-09-08"
---
# Empfehlungen für AstroVim
## 1. Tastenkürzel kennenlernen (Which‑Key)
AstroVim nutzt **which‑key** für kontextsensitive Key‑Menüs.
Drücke `<leader>` (Standard: Leertaste) und warte kurz, um das Menü
zu sehen. So erkennst du schnell verfügbare Aktionen.
## 2. Dateiexplorer (Neo‑Tree)
AstroVim bringt **neo‑tree** als Dateibaum mit.
- `<leader> e` öffnet / schließt den Explorer.
- `a` legt eine neue Datei an, `d` löscht, `r` benennt um.
- `H` blendet ausgeblendete Dateien ein / aus.
## 3. Fuzzy‑Finder (Telescope)
**Telescope** ist der Fuzzy‑Finder.
- `<leader> f f` : Dateien im Projekt suchen
- `<leader> f g` : live‑grep im Projekt
- `<leader> f b` : geöffnete Buffer durchsuchen
- `<leader> f h` : Hilfe‑Tags durchsuchen
## 4. Buffer‑Verwaltung
- `<leader> c` schließt den aktuellen Buffer.
- `[ b` / `] b` wechselt zum vorherigen / nächsten Buffer.
- `<leader> b` zeigt eine Liste offener Buffer.
## 5. Git‑Integration (LazyGit / Gitsigns)
- **LazyGit** startest du mit `<leader> g g` – eine vollwertige
Git‑TUI direkt im Terminal‑Fenster.
- **Gitsigns** zeigt Änderungen in der Sign‑Spalte.
- `] c` / `[ c` springt zur nächsten / vorherigen Änderung.
- `<leader> h s` stage a hunk, `<leader> h r` reset hunk.
## 6. Terminal im Editor
- `<leader> t f` öffnet ein floatendes Terminal.
- `<leader> t h` / `<leader> t v` teilt horizontal / vertikal
mit einem Terminal.
- `Ctrl+\ Ctrl+n` wechselt in den Normal‑Modus innerhalb des Terminals.
## 7. Snippets (LuaSnip)
AstroVim verwendet **LuaSnip**. Du kannst eigene Snippets unter
`~/.config/nvim/lua/user/snippets/` ablegen. Beispiel‑Datei
`python.lua`:
content/blueray_install_manjaro.md
+44
View File
@@ -0,0 +1,44 @@
---
title: "blueray_install_manjaro"
date: "2026-09-08"
---
### Befehle zur Einrichtung von VLC für Blu-rays (Manjaro)
Diese Schritte helfen Ihnen, VLC so zu konfigurieren, dass es Blu-ray-Discs abspielen kann.
1. **Benötigte Pakete installieren**
Dieser Befehl installiert alle notwendigen Pakete für die Blu-ray-Wiedergabe:
- `vlc`: Der Media Player.
- `libaacs`: Notwendig, um AACS-geschützte Blu-ray-Discs zu entschlüsseln.
- `libbluray`: Eine Bibliothek für die Navigation und Wiedergabe von Blu-ray-Discs.
- `jre-openjdk`: Eine Java-Laufzeitumgebung, die für Blu-ray-Menüs (BD-J) benötigt wird.
```bash
sudo pacman -S vlc libaacs libbluray jre-openjdk
```
*Hinweis: Der zuvor erwähnte Paket `libbdplus` wurde hier weggelassen, da er nicht direkt in den offiziellen Arch/Manjaro Repositories gefunden wurde und für viele Blu-rays möglicherweise nicht sofort notwendig ist. Sollten Sie später Probleme mit BD+-geschützten Discs haben, können wir die Installation aus dem AUR (Arch User Repository) in Betracht ziehen.*
2. **Verzeichnis für AACS-Schlüssel erstellen**
Dieser Befehl erstellt das notwendige Verzeichnis in Ihrem Home-Verzeichnis, wo die Entschlüsselungsschlüssel (`KEYDB.cfg`) für Blu-ray-Discs gespeichert werden. Das `-p`-Flag stellt sicher, dass alle übergeordneten Verzeichnisse bei Bedarf ebenfalls erstellt werden und unterdrückt Fehlermeldungen, falls das Verzeichnis bereits existiert.
```bash
mkdir -p ~/.config/aacs/
```
3. **KEYDB.cfg-Datei herunterladen**
Dieser Befehl lädt die Datei `KEYDB.cfg` herunter, welche die Datenbank der Blu-ray-Entschlüsselungsschlüssel enthält. Diese Datei ist entscheidend für die Wiedergabe vieler kommerzieller Blu-rays. Die Datei wird direkt in das zuvor erstellte `.config/aacs/`-Verzeichnis gespeichert.
```bash
wget -O ~/.config/aacs/KEYDB.cfg http://vlc-bluray.whoknowsmy.name/files/KEYDB.cfg
```
4. **Benutzerberechtigungen für das Blu-ray-Laufwerk korrigieren**
Sollten Sie die Fehlermeldung erhalten, dass VLC die Medienadresse nicht öffnen kann (`VLC kann die Medienadresse 'bluray:///dev/sr0' nicht öffnen`), liegt es wahrscheinlich an fehlenden Berechtigungen. Dieser Befehl fügt Ihren Benutzer zur `optical`-Gruppe hinzu, die den Zugriff auf optische Laufwerke ermöglicht.
```bash
sudo usermod -aG optical jonnybravo
```
**WICHTIG:** Damit diese Änderung wirksam wird, müssen Sie sich **vollständig von Ihrer aktuellen Sitzung abmelden und dann wieder neu anmelden** (oder den Computer neu starten).
content/calcurse_tastenkürzel.md
+75
View File
@@ -0,0 +1,75 @@
---
title: "Calcurse Tastenkürzel (Zusammenfassung)"
date: "2026-09-08"
---
# Calcurse Tastenkürzel (Zusammenfassung)
Basierend auf deiner Konfigurationsdatei sind hier die wichtigsten Tastenkürzel für `calcurse` zusammengefasst.
---
### **Allgemeine Steuerung**
| Taste(n) | Aktion |
|---------------|----------------------------------------------|
| `q`, `Q` | Calcurse beenden |
| `s`, `S` | Änderungen speichern |
| `?` | Hilfe anzeigen |
| `C` | Konfigurationsmenü öffnen |
| `TAB` | Zwischen den Ansichten wechseln (Termine/TODO) |
| `ESC` | Aktion abbrechen / Dialog schließen |
| `:` | Befehlszeile öffnen |
| `^R` | Bildschirm neu zeichnen |
### **Navigation im Kalender**
| Taste(n) | Aktion |
|---------------|----------------------------------------------|
| `t` | Nächster Tag |
| `T` | Vorheriger Tag |
| `w` | Nächste Woche |
| `W` | Vorherige Woche |
| `m` | Nächster Monat |
| `M` | Vorheriger Monat |
| `y` | Nächstes Jahr |
| `Y` | Vorheriges Jahr |
| `g`, `G` | Zu einem bestimmten Datum springen |
| `^G` | Zum heutigen Tag springen |
| `h`,`j`,`k`,`l`| Navigation (links, runter, hoch, rechts) |
### **Termine & TODOs verwalten**
| Taste(n) | Aktion |
|---------------|----------------------------------------------|
| `a`, `A` | Neuen Eintrag hinzufügen (je nach Ansicht) |
| `^A` | Direkt einen neuen **Termin** hinzufügen |
| `^T` | Direkt einen neuen **TODO**-Eintrag hinzufügen |
| `d`, `D` | Ausgewählten Eintrag löschen |
| `e`, `E` | Ausgewählten Eintrag bearbeiten |
| `v`, `Enter` | Details des Eintrags ansehen |
| `n`, `N` | Notiz bearbeiten/hinzufügen |
| `>` | Notiz ansehen |
| `c` | Eintrag kopieren |
| `p` | Eintrag einfügen |
| `r` | Wiederholung für einen Eintrag festlegen |
### **Speziell für die TODO-Liste**
| Taste(n) | Aktion |
|---------------|----------------------------------------------|
| `!` | Task als erledigt markieren (umschalten) |
| `+` | Priorität des Tasks erhöhen |
| `-` | Priorität des Tasks senken |
### **Daten Im- & Export**
| Taste(n) | Aktion |
|---------------|----------------------------------------------|
| `i`, `I` | Daten aus einer Datei importieren |
| `x`, `X` | Daten in eine Datei exportieren |
| `|` | Eintrag an ein externes Skript weiterleiten |
content/lazygit.md
+316
View File
@@ -0,0 +1,316 @@
---
title: "Lazygit – Der Terminal-Git-Client"
date: "2026-09-08"
---
# Lazygit – Der Terminal-Git-Client
Lazygit ist ein schneller, terminalbasierter Git-Client mit TUI (Terminal User
Interface). Du steuerst alles per Tastatur und behältst dein ganzes Repository
auf einen Blick – kein Merken von kryptischen `git`-Befehlen mehr.
## Installation
```bash
# Arch / Manjaro
sudo pacman -S lazygit
# Ubuntu / Debian
LAZYGIT_VERSION=$(curl -s "https://api.github.com/repos/jesseduffield/lazygit/releases/latest" | grep -Po '"tag_name": "v\K[^"]*')
curl -Lo lazygit.tar.gz "https://github.com/jesseduffield/lazygit/releases/latest/download/lazygit_${LAZYGIT_VERSION}_Linux_x86_64.tar.gz"
tar xf lazygit.tar.gz lazygit
sudo install lazygit /usr/local/bin
# macOS
brew install lazygit
# Windows (mit Winget)
winget install JesseDuffield.lazygit
```
Start: Einfach `lazygit` im Repository-Verzeichnis ausführen.
---
## Navigation (global)
| Taste | Aktion |
|-------|--------|
| `h` / `l` | Zwischen Panels wechseln (links/rechts) |
| `j` / `k` | In Liste nach unten/oben |
| `↑` / `↓` | Dasselbe wie j/k |
| `g` | Zum Anfang der Liste |
| `shift+G` | Zum Ende der Liste |
| `/` | Suchen (im aktuellen Panel) |
| `q` | Lazygit beenden |
| `esc` | Zurück / Aktion abbrechen |
| `?` | Hilfe anzeigen (alle Tasten) |
| `tab` | In neuem Panel: zwischen Bereichen springen |
---
## Panel 1: Status (ganz links)
Zeigt, ob du im normalen Modus, im Rebase, Merge-Konflikt etc. bist.
Normalerweise springst du mit `1`-`5` direkt in die anderen Panels.
---
## Panel 2: Dateien / Working Tree
Hier siehst du alle geänderten, neuen und gelöschten Dateien.
| Taste | Aktion |
|-------|--------|
| `Leertaste` | Datei stagen/unstagen (markiert) |
| `a` | Alle Dateien stagen/unstagen |
| `c` | Commit erstellen (öffnet Editor für Commit-Message) |
| `shift+C` | Commit mit Editor (git commit) |
| `enter` | Diff der ausgewählten Datei anzeigen |
| `d` | Änderungen der Datei verwerfen (Achtung, unwiderruflich!) |
| `shift+D` | Datei aus Working Tree löschen |
| `e` | Datei im Editor öffnen |
| `o` | Datei mit Standardprogramm öffnen |
| `i` | Datei zu .gitignore hinzufügen / Eintrag entfernen |
| `p` | Patch – interaktiv nur Teile einer Datei stagen |
### Patch-Modus (`p`)
Nach Drücken von `p` auf einer Datei:
| Taste | Aktion |
|-------|--------|
| `Leertaste` | Aktuellen Hunks stagen/unstagen |
| `j` / `k` | Zwischen Hunks navigieren |
| `v` | Selektionsmodus (visuell) – dann Leertaste für Auswahl |
| `tab` | In Diff-Fenster springen |
---
## Panel 3: Branches
| Taste | Aktion |
|-------|--------|
| `Leertaste` | Branch auschecken |
| `n` | Neuen Branch erstellen |
| `c` | Branch mit Namen umbenennen (checkout) |
| `shift+C` | Branch umbenennen (ohne checkout) |
| `d` | Branch löschen |
| `shift+D` | Branch force-löschen (auch wenn nicht gemerged) |
| `m` | Aktuellen Branch in ausgewählten Branch mergen |
| `M` | Merge ohne Fast-Forward |
| `enter` | Commits des Branches anzeigen |
| `r` | Branch rebasen auf ausgewählten Branch |
| `f` | Fast-Forward des ausgewählten Branches |
| `T` | Tag erstellen |
| `g` | Branch zurücksetzen (reset) auf ausgewählten |
---
## Panel 4: Commits (im Branch-Panel mit Enter)
| Taste | Aktion |
|-------|--------|
| `s` | Squash down – Commit in den darunterliegenden squashen |
| `shift+S` | Fixup – Commit in darunterliegenden squashen, Message verwerfen |
| `r` | Rebase auf diesen Commit starten / Rebase fortsetzen |
| `R` | Commit-Message mit `git commit --amend` bearbeiten |
| `A` | Commit mit Staged-Änderungen amendend (git commit --amend) |
| `t` | Commit rückgängig machen (revert) |
| `shift+T` | Revert erstellen, ohne zu commiten |
| `ctrl+j` / `ctrl+k` | Commit in der Liste nach unten/oben verschieben (interaktiv) |
| `g` | Reset auf diesen Commit – Optionen: |
| | `soft` – HEAD verschieben, Index bleibt |
| | `mixed` (default) – HEAD + Index verschieben |
| | `hard` – HEAD + Index + Working Tree (Achtung, verwirft!) |
| `d` | Commit löschen (während Rebase) |
| `shift+D` | Commits ab hier löschen (während Rebase) |
| `f` | Fixup-Commit erstellen |
| `shift+F` | Fixup-Commit für einen bestimmten Commit |
| `enter` | Dateien des Commits anzeigen |
| `ctrl+l` | Commit-Log anzeigen |
| `shift+C` | Commit kopieren (cherry-pick) |
| `v` | Commits in die Zwischenablage kopieren |
---
## Panel 5: Stash
| Taste | Aktion |
|-------|--------|
| `Leertaste` | Stash anwenden |
| `g` | Stash anwenden und danach löschen (pop) |
| `d` | Stash löschen |
| `enter` | Dateien des Stashs anzeigen |
| `n` | Neuen Stash mit Nachricht erstellen |
| `s` | Schnell-Stash (ohne Nachricht) |
---
## Reflog
Mit `ctrl+o` (oder im Commits-Panel) öffnest du das Reflog – alle HEAD-Bewegungen.
| Taste | Aktion |
|-------|--------|
| `enter` | Reflog-Eintrag anzeigen |
| `g` | Auf diesen Eintrag zurücksetzen (soft/mixed/hard) |
| `ctrl+o` | Reflog schließen |
---
## Remote / Push & Pull
| Taste | Aktion |
|-------|--------|
| `p` | Push (im Branch- oder Commits-Panel) |
| `shift+P` | Force-Push (`--force-with-lease`) |
| `shift+F` | Fetch (alle Remotes) |
| `ctrl+p` | Pull (fetch + merge) |
| `shift+ctrl+P` | Pull mit Rebase |
---
## Undo / Redo
Lazygit hat eine eingebaute Undo-Funktion – ein Lebensretter!
| Taste | Aktion |
|-------|--------|
| `z` | Letzte Git-Aktion rückgängig machen (undo) |
| `shift+Z` | Rückgängig gemachte Aktion wiederholen (redo) |
Funktioniert für: Commit, Stash, Branch-Reset, Checkout, Cherry-Pick, Revert,
Merge ...
---
## Konflikte lösen
Im Merge-Konflikt-Fall zeigt Lazygit die betroffenen Dateien.
| Taste | Aktion |
|-------|--------|
| `Leertaste` | Datei als "ours" markieren (eigene Version) |
| `b` | Datei als "theirs" markieren (fremde Version) |
| `↑` / `↓` | Hunk auswählen |
| `Leertaste` | Hunk auswählen (ours/theirs oder beide) |
| `a` | Alle Hunks auf einmal akzeptieren |
| `shift+M` | Merge-Tool für diese Datei öffnen |
---
## Submodule
| Taste | Aktion |
|-------|--------|
| `enter` | In Submodule wechseln (öffnet neue Lazygit-Instanz) |
| `i` | Submodule init |
| `u` | Submodule updaten |
| `n` | Submodule hinzufügen |
---
## Worktrees
| Taste | Aktion |
|-------|--------|
| `n` | Neues Worktree erstellen |
| `enter` | In Worktree wechseln |
| `d` | Worktree löschen |
---
## Tipps & häufige Workflows
### Änderungen committen
```
1. j/k → Datei auswählen
2. Leertaste → Stagen
3. c → Commit-Message schreiben, Enter
4. p → Pushen
```
### Letzten Commit ändern (amend)
```
1. a → Alle Dateien stagen
2. shift+A → Amend (fügt Staged-Änderungen zum letzten Commit hinzu)
```
### Branch erstellen und wechseln
```
1. 3 → Branch-Panel
2. n → Neuen Branch, Namen eingeben, Enter
```
### Commits zusammenfassen (squash)
```
1. 4 → Commits-Panel
2. j/k → Commit auswählen (der, der in den darunterliegenden gesquasht werden soll)
3. s → Squash
```
### Commit rückgängig machen
```
1. 4 → Commits-Panel
2. g → "reset"
3. soft → HEAD verschieben, Änderungen bleiben im Index
```
Falls du es dir anders überlegst: `z` (undo).
### Interaktives Rebase
```
1. 4 → Commits-Panel
2. r auf einem älteren Commit → Rebase starten
3. j/k → Commits auswählen, dann s/f/d zum Squashen/Fixen/Löschen
4. r → Rebase fortsetzen
```
---
## Konfiguration
Die Konfigurationsdatei liegt unter:
- Linux/macOS: `~/.config/lazygit/config.yml`
- Windows: `%APPDATA%/lazygit/config.yml`
Beispiel für ein nützliches Config-Snippet:
```yaml
gui:
theme:
activeBorderColor:
- '#89b4fa'
- bold
inactiveBorderColor:
- '#a6adc8'
nerdFontsVersion: "3"
git:
paging:
colorArg: always
pager: delta --dark --paging=never
# Commit-Konvention für Merge-Commits
commitPrefixes:
my_project:
pattern: "^(\\w+\\/\\w+-\\d+)"
replace: "[$1] "
```
---
## Fazit
Lazygit macht Git massiv schneller: Du siehst Diff, Branches, Commits und
Stashes gleichzeitig, stagen mit Leertaste, commiten mit `c`, pushen mit `p`.
Kein `git status`-Tippen mehr, kein `git log --oneline`-Starren.
Die beiden wichtigsten Tasten: `z` für Undo und `?` für Hilfe.
content/networkconfig_dns.md
+187
View File
@@ -0,0 +1,187 @@
---
title: "Zusammenfassung der vorgenommenen Änderungen und Konfigurationen"
date: "2026-09-08"
---
# Zusammenfassung der vorgenommenen Änderungen und Konfigurationen
Dieses Dokument fasst die wichtigsten Änderungen und Konfigurationen zusammen, die wir besprochen und durchgeführt haben.
---
## 1. Python Logging (sync.py und logging_config.py)
Um die Log-Ausgabe des `sync.py`-Skripts zu verbessern, wurde eine modulare Logging-Konfiguration mit Log-Rotation erstellt und in eine separate Datei ausgelagert.
### `logging_config.py` erstellt
**Zweck:** Enthält die Funktion `setup_logging()` zur Konfiguration eines Root-Loggers, der Logs in eine Datei (`sync_log.log`) schreibt, diese bei Erreichen einer Größe von 5 MB rotiert und 5 Backups behält. Optional kann auch ein Konsolen-Logger aktiviert werden.
**Inhalt der Datei (`/home/jonnybravo/Projekte/python_tests/rclone/logging_config.py`):**
```python
import logging
from logging.handlers import RotatingFileHandler, TimedRotatingFileHandler
import os
def setup_logging(console_logging=False):
"""Konfiguriert das Root-Logging für die Anwendung mit Rotation.
Diese Funktion richtet einen Root-Logger ein, der Log-Nachrichten in eine Datei schreibt,
welche bei Erreichen einer bestimmten Größe rotiert wird.
:param console_logging: Wenn True, werden Logs zusätzlich zur Datei auch auf der Konsole ausgegeben.
Standardmäßig ist dies deaktiviert (False).
"""
# --- Allgemeine Einstellungen ---
log_file = "sync_log.log" # Name der Log-Datei
# Maximale Größe der Log-Datei in Bytes, bevor sie rotiert wird (hier 5 MB)
max_log_size = 5 * 1024 * 1024
# Anzahl der rotierenden Backup-Dateien, die behalten werden sollen (hier 5)
backup_count = 5
# --- Logger-Initialisierung ---
logger = logging.getLogger()
if logger.hasHandlers():
return
# --- Logging-Level einstellen ---
# Mögliche Levels: DEBUG, INFO, WARNING, ERROR, CRITICAL
logger.setLevel(logging.INFO)
# --- Formatter erstellen ---
# Definiert das Layout der Log-Nachrichten.
formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
# --- Handler erstellen und dem Logger hinzufügen ---
# 1. RotatingFileHandler (immer aktiv)
file_handler = RotatingFileHandler(
log_file,
maxBytes=max_log_size,
backupCount=backup_count,
encoding='utf-8'
)
file_handler.setFormatter(formatter)
logger.addHandler(file_handler)
# 2. StreamHandler für Konsolen-Ausgabe (optional)
if console_logging:
console_handler = logging.StreamHandler()
console_handler.setFormatter(formatter)
logger.addHandler(console_handler)
# --- Weitere Referenzen und alternative Handler ---
# (Ausführliche Kommentare sind in der Datei enthalten, hier gekürzt)
```
### `sync.py` angepasst
**Zweck:** Importiert die `setup_logging`-Funktion und ruft sie ganz am Anfang des Skripts auf, um die Logging-Konfiguration zu initialisieren.
**Relevanten Änderungen in `/home/jonnybravo/Projekte/python_tests/rclone/sync.py`:**
```python
from logging_config import setup_logging
# Logging so früh wie möglich einrichten
setup_logging() # Optional: setup_logging(console_logging=True) für Konsolen-Logs
from rclone_python import rclone as rc
from rclone_python.utils import RcloneException
import os
import logging
# ... (restlicher Code)
```
---
## 2. DNS-Konfiguration auf dem Manjaro-System
Um den AdGuard Home-Server `10.50.0.3` als primären DNS-Server für das gesamte System und alle Verbindungen zu nutzen, wurden folgende Schritte durchgeführt:
### Globale `systemd-resolved` Konfiguration
**Zweck:** Setzt `10.50.0.3` als systemweiten DNS-Server für `systemd-resolved`.
**Änderungen in `/etc/systemd/resolved.conf`:**
```ini
[Resolve]
DNS=10.50.0.3
# FallbackDNS= # Auskommentieren oder auf FallbackDNS= setzen, um Fallback zu verhindern
```
Nach der Bearbeitung: `sudo systemctl restart systemd-resolved`
### NetworkManager Überschreibung für alle Verbindungen
**Zweck:** Weist NetworkManager an, bei allen Netzwerkverbindungen (bestehende und neue) den vom DHCP-Server angebotenen DNS zu ignorieren. Dadurch wird der globale DNS von `systemd-resolved` verwendet.
**Neue Datei erstellt: `/etc/NetworkManager/conf.d/99-global-dns-override.conf`**
```ini
[connection]
# Diese Einstellung gilt für alle neuen und bestehenden Verbindungen.
# Sie weist NetworkManager an, den DNS-Server vom DHCP zu ignorieren.
ipv4.ignore-auto-dns=true
ipv6.ignore-auto-dns=true
```
Nach der Erstellung: `sudo systemctl restart NetworkManager`
### Anpassung des spezifischen WLAN-Profils (SweetHome-5G)
**Zweck:** Hinzufügen der DNS-Suchdomäne, damit lokale Hostnamen ohne vollen Domain-Namen aufgelöst werden können.
**Befehle für die Kommandozeile (nmcli):**
(Ersetzen Sie "Ihr Verbindungsname" durch den tatsächlichen Namen, z.B. "SweetHome-5G")
```bash
nmcli connection modify "Ihr Verbindungsname" ipv4.dns-search "speedport.ip"
# optional für IPv6: nmcli connection modify "Ihr Verbindungsname" ipv6.dns-search "speedport.ip"
nmcli connection up "Ihr Verbindungsname"
```
---
## 3. AdGuard Home Konfiguration
### Installation & SSL-Einrichtung
**Zweck:** Installation von AdGuard Home auf einem Linux-Server und Absicherung der Weboberfläche mit einem selbstsignierten SSL-Zertifikat und eigener CA.
**Schritte (ausführlich in vorherigen Antworten beschrieben):**
1. AdGuard Home installieren (`curl ... install.sh`).
2. Eigene CA (`MyCA.key`, `MyCA.pem`) und Server-Zertifikat (`adguard.key`, `adguard.crt`) mit `openssl` erstellen, inklusive SAN-Erweiterung für IP-Adresse/lokalen Hostnamen.
3. Zertifikate in AdGuard Home (`adguard.crt`, `adguard.key`) unter **Einstellungen → Verschlüsselungseinstellungen** konfigurieren.
4. `MyCA.pem` auf Client-Geräten als vertrauenswürdige Stammzertifizierungsstelle installieren.
### Bedingte Weiterleitung für lokale Namen
**Zweck:** Ermöglicht AdGuard Home die Auflösung lokaler Hostnamen durch Weiterleitung an den Router.
**Konfiguration in der AdGuard Home Weboberfläche:**
1. Gehen Sie zu **Einstellungen → DNS-Einstellungen**.
2. Im Abschnitt **"Upstream-DNS-Server"** die folgende Zeile hinzufügen (zusätzlich zu öffentlichen DNS-Servern):
```
[/speedport.ip/]192.168.50.1
```
3. Einstellungen speichern.
---
## 4. Problembehebung WireGuard DNS
**Zweck:** Behebung des Konflikts, bei dem WireGuard die DNS-Einstellungen überschrieben und auf einen nicht existierenden Server (`10.50.0.3` ohne installierten DNS-Dienst) gezeigt hat.
**Änderung in der WireGuard-Konfigurationsdatei:**
* In `/etc/wireguard/wg0.conf` (im Abschnitt `[Interface]`) die Zeile `DNS = 10.50.0.3` auskommentieren oder auf einen anderen DNS-Server ändern.
```ini
[Interface]
# DNS = 10.50.0.3
```
* WireGuard neu starten: `sudo systemctl restart wg-quick@wg0` (oder `sudo wg-quick down wg0 && sudo wg-quick up wg0`).
content/string_prefixes.md
+81
View File
@@ -0,0 +1,81 @@
---
title: "Python String-Präfixe"
date: "2026-09-08"
---
# Python String-Präfixe
In Python gibt es verschiedene Präfixe für String-Literale, die bestimmen, wie der Interpreter den Inhalt des Strings verarbeitet. Suffixe für String-Literale existieren in Python nicht direkt (anders als in Sprachen wie C++), aber es gibt Methoden auf String-Objekten wie `.startswith()` und `.endswith()`.
Hier ist die Liste aller String-Präfixe in Python mit Beschreibung und logischen Beispielen:
| Präfix | Beschreibung | Logisches Beispiel |
| :--- | :--- | :--- |
| **Keines** | Standard-Unicode-String (UTF-8 in Python 3). Verarbeitet normale Escape-Sequenzen wie `\n` oder `\t`. | `text = "Zeile 1\nZeile 2"` |
| **`f` / `F`** | **Formatted String (f-string):** Ermöglicht die direkte Einbettung von Python-Ausdrücken und Variablen in geschweiften Klammern `{}`. | `name = "Welt"\nprint(f"Hallo {name}!")` *(Ausgabe: Hallo Welt!)* |
| **`r` / `R`** | **Raw String:** Behandelt Backslashes `\` als normale Zeichen und ignoriert Escape-Sequenzen. Ideal für reguläre Ausdrücke oder Dateipfade. | `pfad = r"C:\Users\Name\Documents"` |
| **`b` / `B`** | **Byte-String:** Erzeugt ein `bytes`-Objekt statt eines Standard-Strings. Erlaubt nur ASCII-Zeichen (Werte 0-127). | `daten = b"Hallo"` *(Typ ist `bytes`)* |
| **`u` / `U`** | **Unicode-String:** In Python 3 standardmäßig das Standardverhalten. Wird heute hauptsächlich für die Abwärtskompatibilität mit Python 2 verwendet. | `unicode_text = u"Café"` |
| **`fr` / `rf`** | **Kombination (Raw f-string):** Erlaubt sowohl die Formatierung mit `{}` als auch die Ignorierung von Escape-Sequenzen. | `ordner = "Bilder"\npfad = fr"C:\{ordner}\bild.png"` |
| **`br` / `rb`** | **Kombination (Raw Byte-string):** Erzeugt ein Byte-Objekt, bei dem Backslashes nicht als Escape-Sequenzen interpretiert werden. | `regex_bytes = rb"a\nb"` |
*(Hinweis: Die Groß- und Kleinschreibung der Präfixe ist beliebig, d. h. `f""` verhält sich identisch zu `F""`.)*
## Python String-Methoden
Hier ist eine Übersicht über die wichtigsten eingebauten Methoden von String-Objekten (`str`) in Python, sortiert nach ihrer Funktion:
### 1. Bereinigen und Ausrichten
| Methode | Beschreibung | Logisches Beispiel |
| :--- | :--- | :--- |
| **`strip([chars])`** | Entfernt führende und folgende Whitespaces (oder die angegebenen Zeichen in `chars`). | `" hallo ".strip()` *(Ergebnis: `"hallo"`)* |
| **`lstrip([chars])`** | Entfernt nur führende Whitespaces oder Zeichen. | `" hallo ".lstrip()` *(Ergebnis: `"hallo "`)* |
| **`rstrip([chars])`** | Entfernt nur folgende Whitespaces oder Zeichen. | `" hallo ".rstrip()` *(Ergebnis: `" hallo"`)* |
| **`ljust(width[, fillchar])`** | Richtet den String linksbündig in einem Feld der Breite `width` aus. | `"test".ljust(10, "-")` *(Ergebnis: `"test------"`)* |
| **`rjust(width[, fillchar])`** | Richtet den String rechtsbündig in einem Feld der Breite `width` aus. | `"test".rjust(10, "-")` *(Ergebnis: `"------test"`)* |
| **`center(width[, fillchar])`** | Zentriert den String in einem Feld der Breite `width`. | `"test".center(10, "-")` *(Ergebnis: `"---test---"`)* |
| **`zfill(width)`** | Füllt den String links mit Nullen auf, bis die Breite `width` erreicht ist. | `"42".zfill(5)` *(Ergebnis: `"00042"`)* |
### 2. Suchen und Ersetzen
| Methode | Beschreibung | Logisches Beispiel |
| :--- | :--- | :--- |
| **`replace(old, new[, count])`** | Ersetzt Vorkommen von `old` durch `new`. Optional wird die Anzahl durch `count` begrenzt. | `"A-B-C".replace("-", "/")` *(Ergebnis: `"A/B/C"`)* |
| **`find(sub[, start[, end]])`** | Gibt den niedrigsten Index zurück, an dem `sub` gefunden wird. Gibt `-1` zurück, wenn nicht gefunden. | `"hallo".find("ll")` *(Ergebnis: `2`)* |
| **`rfind(sub[, start[, end]])`** | Gibt den höchsten Index zurück, an dem `sub` gefunden wird. Gibt `-1` zurück, wenn nicht gefunden. | `"hallo".rfind("l")` *(Ergebnis: `3`)* |
| **`index(sub[, start[, end]])`** | Wie `find()`, wirft aber einen `ValueError`, wenn das Substring nicht gefunden wird. | `"hallo".index("x")` *(Ergebnis: `ValueError`)* |
| **`rindex(sub[, start[, end]])`** | Wie `rfind()`, wirft aber einen `ValueError`, wenn nicht gefunden. | `"hallo".rindex("l")` *(Ergebnis: `3`)* |
| **`count(sub[, start[, end]])`** | Zählt, wie oft das Substring `sub` im String vorkommt. | `"banane".count("an")` *(Ergebnis: `2`)* |
### 3. Aufteilen und Verbinden
| Methode | Beschreibung | Logisches Beispiel |
| :--- | :--- | :--- |
| **`split(sep=None, maxsplit=-1)`** | Teilt den String an Trennzeichen `sep` und gibt eine Liste zurück. | `"A,B,C".split(",")` *(Ergebnis: `['A', 'B', 'C']`)* |
| **`rsplit(sep=None, maxsplit=-1)`** | Teilt den String vom Ende her auf. | `"A,B,C".rsplit(",", 1)` *(Ergebnis: `['A,B', 'C']`)* |
| **`splitlines([keepends])`** | Teilt den String an Zeilenumbrüchen auf. | `"A\nB".splitlines()` *(Ergebnis: `['A', 'B']`)* |
| **`join(iterable)`** | Verbindet die Elemente eines Iterables (z.B. Liste) mit dem String als Trennzeichen. | `"-".join(["A", "B"])` *(Ergebnis: `"A-B"`)* |
| **`partition(sep)`** | Teilt den String beim ersten Vorkommen von `sep` in ein Tupel: `(vor, sep, nach)`. | `"A-B-C".partition("-")` *(Ergebnis: `('A', '-', 'B-C')`)* |
| **`rpartition(sep)`** | Teilt den String beim letzten Vorkommen von `sep`. | `"A-B-C".rpartition("-")` *(Ergebnis: `('A-B', '-', 'C')`)* |
### 4. Groß-/Kleinschreibung ändern
| Methode | Beschreibung | Logisches Beispiel |
| :--- | :--- | :--- |
| **`lower()`** | Konvertiert alle Zeichen in Kleinbuchstaben. | `"Hallo".lower()` *(Ergebnis: `"hallo"`)* |
| **`upper()`** | Konvertiert alle Zeichen in Großbuchstaben. | `"Hallo".upper()` *(Ergebnis: `"HALLO"`)* |
| **`capitalize()`** | Setzt das erste Zeichen auf Groß und den Rest auf Klein. | `"hallo welt".capitalize()` *(Ergebnis: `"Hallo welt"`)* |
| **`title()`** | Setzt den ersten Buchstaben jedes Wortes auf Groß. | `"hallo welt".title()` *(Ergebnis: `"Hallo Welt"`)* |
| **`swapcase()`** | Vertauscht Groß- und Kleinschreibung. | `"HAllo".swapcase()` *(Ergebnis: `"haLLO"`)* |
| **`casefold()`** | Ähnlich wie `lower()`, ist aber aggressiver beim Entfernen von Groß-/Kleinschreibungsunterschieden (gut für Caseless Matching in Unicode). | `"Straße".casefold()` *(Ergebnis: `"strasse"`)* |
### 5. Überprüfungsmethoden (Geben `True` oder `False` zurück)
| Methode | Beschreibung | Logisches Beispiel |
| :--- | :--- | :--- |
| **`startswith(prefix[, start[, end]])`** | Prüft, ob der String mit `prefix` beginnt. | `"hallo".startswith("ha")` *(Ergebnis: `True`)* |
| **`endswith(suffix[, start[, end]])`** | Prüft, ob der String mit `suffix` endet. | `"hallo".endswith("lo")` *(Ergebnis: `True`)* |
| **`isalnum()`** | Prüft, ob alle Zeichen alphanumerisch sind (Buchstaben und Zahlen) und mindestens ein Zeichen vorhanden ist. | `"Python3".isalnum()` *(Ergebnis: `True`)* |
| **`isalpha()`** | Prüft, ob alle Zeichen Buchstaben sind. | `"Python".isalpha()` *(Ergebnis: `True`)* |
| **`isdigit()`** | Prüft, ob alle Zeichen Ziffern sind (z. B. auch hochgestellte Zahlen). | `"123".isdigit()` *(Ergebnis: `True`)* |
| **`isnumeric()`** | Prüft, ob alle Zeichen numerisch sind (auch Brüche wie ½). | `"½".isnumeric()` *(Ergebnis: `True`)* |
| **`isspace()`** | Prüft, ob der String nur aus Whitespaces (Leerzeichen, Tabs, Zeilenumbrüchen) besteht. | `" \n".isspace()` *(Ergebnis: `True`)* |
| **`islower()`** | Prüft, ob alle buchstabenbasierten Zeichen kleingeschrieben sind. | `"hallo".islower()` *(Ergebnis: `True`)* |
| **`isupper()`** | Prüft, ob alle buchstabenbasierten Zeichen großgeschrieben sind. | `"HALLO".isupper()` *(Ergebnis: `True`)* |
| **`istitle()`** | Prüft, ob der String im Titlecase-Format vorliegt. | `"Hallo Welt".istitle()` *(Ergebnis: `True`)* |
content/system-optimierung.md
+121
View File
@@ -0,0 +1,121 @@
---
title: "System Optimierung – nächste Schritte"
date: "2026-09-08"
---
# System Optimierung – nächste Schritte
> Letzte Bearbeitung: 07.09.2026
> Chat-Session-ID: `20260907_182659_6403f3`
> Chat wieder aufrufen: `@session:default/20260907_182659_6403f3` in Hermes Agent eingeben
---
## 1. flashfocus patchen (Marshmallow-4.x-Inkompatibilität)
**Einmalig ausführen:**
```bash
sudo sed -i 's/fields\.Number/fields.Float/g' /usr/lib/python3.14/site-packages/flashfocus/config.py
```
**Danach testen:**
```bash
flashfocus --help
```
Wenn kein Traceback kommt, ist der Patch erfolgreich.
**Achtung:** Nach jedem `pacman -Syu`, bei dem flashfocus aktualisiert wird, muss der Patch erneut angewendet werden.
---
## 2. Systemd-User-Services masken
Die Manjaro-Sway-Config versucht die Dienste bei jedem Start neu zu enablen.
Nur `disable` reicht nicht – sie müssen **maskiert** werden.
```bash
systemctl --user mask mako.service flashfocus.service pcmanfm.service poweralertd.service xdg-desktop-portal-gtk.service xdg-desktop-portal-lxqt.service
```
**Kontrolle:**
```bash
systemctl --user status mako flashfocus pcmanfm poweralertd xdg-desktop-portal-gtk xdg-desktop-portal-lxqt
```
Alle sollten `masked` anzeigen (nicht `failed`).
---
## 3. Neustart und Test
Sway neustarten (Super+Shift+R) oder System rebooten.
Nach dem Neustart prüfen, ob alle Dienste laufen:
```bash
pgrep -a mako
pgrep -a pcmanfm-qt
pgrep -a poweralertd
pgrep -a flashfocus
pgrep -a xdg-desktop-portal
```
Jeder Befehl sollte eine PID und den Prozessnamen ausgeben.
**Journal aufräumen** – keine neuen Crash-Logs mehr:
```bash
journalctl --user -p 3 --since "1 minute ago"
```
---
## 4. Weitere Performance-Empfehlungen
Die vollständige Analyse ist in diesem Chat dokumentiert. Hier die Top-Empfehlungen als Übersicht:
| Priorität | Maßnahme | Befehl |
|---|---|---|
| Hoch | swappiness auf 40 senken (ZRAM) | `sudo sysctl vm.swappiness=40` (temporär) oder `/etc/sysctl.d/99-zram.conf` |
| Hoch | vfs_cache_pressure auf 50 | `sudo sysctl vm.vfs_cache_pressure=50` |
| Mittel | ollama stoppen (294 MB RAM) | `sudo systemctl disable --now ollama` |
| Mittel | lxd/docker stoppen (530 MB RAM) | `sudo systemctl disable --now lxd docker` |
| Mittel | CPU-Governor auf powersave | `sudo cpupower frequency-set -g powersave` |
| Niedrig | Boot beschleunigen | `sudo systemctl disable NetworkManager-wait-online` |
| Niedrig | Journal-Größe limitieren (3,9 GB → 500 MB) | `sudo nano /etc/systemd/journald.conf` → `SystemMaxUse=500M` |
---
## 5. Verwaiste Pakete aufräumen
```bash
sudo pacman -Rns $(pacman -Qtdq) # 9 verwaiste Pakete
```
---
## Wie diesen Chat wieder aufrufen
In einer neuen Hermes-Agent-Session einfach eingeben:
```
@session:default/20260907_182659_6403f3
```
Dann lädt der Agent den kompletten Chatverlauf aus der Datenbank.
---
## Dateien, die geändert wurden
| Datei | Zweck |
|---|---|
| `~/.config/sway/config.d/10-autostart-fix.conf` | Korrigierte Autostarts (exec statt systemd) |
| `/usr/lib/python3.14/site-packages/flashfocus/config.py` | Marshmallow-4.x-Patch (sudo nötig) |
| `/home/jonnybravo/Projekte/Python_Skripte/create_selfsign/selfsing.py` | CA + Zertifikats-Script (vorherige Session) |
| `~/scripts/mount-nfs.sh` | Manuelle NFS-Mount-Steuerung (vorherige Session) |
| `~/scripts/mounts.md` | NFS-Mount-Dokumentation (vorherige Session) |
content/tinydb_vs_sqlite.md
+54
View File
@@ -0,0 +1,54 @@
---
title: "Vergleich: TinyDB vs. SQLite"
date: "2026-09-08"
---
# Vergleich: TinyDB vs. SQLite
Sowohl TinyDB als auch SQLite sind hervorragende "Embedded Databases" (eingebettete Datenbanken), die ihre Daten in einer Datei speichern, ohne dass ein separater Serverprozess läuft. Der Unterschied liegt hauptsächlich in ihrem Ansatz zur Datenspeicherung und -abfrage.
---
### SQLite
**Vorteile (`Pros`):**
* **Sehr robust und bewährt:** Seit Jahrzehnten im Einsatz, extrem zuverlässig (ACID-konform).
* **Standard-SQL:** Bietet eine mächtige, standardisierte Abfragesprache, die von vielen Entwicklern beherrscht wird und plattformübergreifend kompatibel ist.
* **Performance:** Sehr gute Leistung für komplexe Abfragen, Joins und große Datensätze.
* **Strikte Schemas:** Erzwingt Datenintegrität durch vordefinierte Tabellenstrukturen und Datentypen.
* **Großes Ökosystem:** Viele Tools, Treiber und Support in fast jeder Programmiersprache verfügbar.
* **Transaktionen:** Robuste Unterstützung für atomare Transaktionen.
**Nachteile (`Cons`):**
* **SQL-Kenntnisse erforderlich:** Entwickler, die kein SQL beherrschen, müssen es lernen.
* **Schema-Bindung:** Änderungen am Datenmodell erfordern oft Schema-Migrationen, die aufwendig sein können. Weniger flexibel für sich schnell ändernde Daten.
* **Binärdateien:** Die Datenbankdateien sind binär und nicht direkt menschenlesbar, was das Debugging erschweren kann.
* **Boilerplate-Code:** Für einfache Operationen kann der SQL-Code im Vergleich zu einer NoSQL-Datenbank länger sein.
* **Keine native Unterstützung für verschachtelte Daten:** Das Speichern von hierarchischen Daten (JSON) erfordert oft JSON-Funktionen in SQL oder separate Tabellen.
---
### TinyDB
**Vorteile (`Pros`):**
* **Rein Pythonisch:** Die API ist zu 100% in Python geschrieben und fühlt sich sehr natürlich an. Keine SQL-Kenntnisse erforderlich.
* **Schema-los (NoSQL):** Speichert Daten als Python-Wörterbücher (ähnlich JSON). Keine Schema-Definitionen im Voraus notwendig, maximale Flexibilität für sich ändernde Datenmodelle.
* **Extrem einfach und schnell zu starten:** Ideal für kleine Projekte, Prototypen und den schnellen Einstieg.
* **Menschenlesbare Daten:** Speichert Daten standardmäßig in JSON (oder YAML/CBOR), die Datenbankdatei ist mit einem Texteditor lesbar.
* **Hervorragend für verschachtelte Daten:** Ideal für das Speichern und Abfragen von Daten mit komplexen, hierarchischen Strukturen direkt als Python-Objekte.
* **Keine Konfiguration:** Einfach importieren und loslegen.
**Nachteile (`Cons`):**
* **Python-spezifisch:** Nicht leicht in anderen Programmiersprachen zu verwenden (im Gegensatz zu SQL).
* **Keine komplexe relationale Abfrage:** Nicht für komplexe Joins oder Aggregationen über mehrere "Tabellen" hinweg konzipiert.
* **Leistung bei großen Datensätzen:** Bei sehr großen Datenmengen kann die Leistung leiden, da TinyDB für einige Operationen die gesamte Datei lesen muss.
* **Weniger strenge ACID-Garantien:** Obwohl es Transaktionen bietet, ist es im Vergleich zu SQLite weniger robust in Bezug auf strikte ACID-Konformität.
* **Kleineres Ökosystem:** Weniger Tools, Treiber und Community-Support als für SQLite.
---
Die Wahl zwischen beiden hängt stark von den spezifischen Anforderungen Ihres Projekts ab, insbesondere von der Art der Daten, der Komplexität der Abfragen und der Notwendigkeit einer schemalosen Flexibilität.
content/ver_next_einbinden.md
+97
View File
@@ -0,0 +1,97 @@
---
title: "Anleitung: Bestehende `rclone`-Konfiguration auf einen neuen Rechner übertragen"
date: "2026-09-08"
---
# Anleitung: Bestehende `rclone`-Konfiguration auf einen neuen Rechner übertragen
Diese Anleitung erklärt, wie Sie eine bereits existierende `rclone`-Konfiguration, insbesondere für einen verschlüsselten Nextcloud-Speicher, auf einen neuen Computer umziehen können, ohne alles neu einrichten zu müssen.
---
### Worum geht es?
Alle Ihre `rclone`-Einstellungen, einschließlich der Zugangsdaten zu Ihren Cloud-Speichern, sind in einer einzigen Datei namens `rclone.conf` gespeichert. Indem Sie diese Datei auf einen neuen Rechner übertragen, "kennt" `rclone` dort sofort alle Ihre eingerichteten Verbindungen (Remotes).
---
### Voraussetzungen
Bevor Sie beginnen, stellen Sie sicher, dass Sie Folgendes haben:
1. **Zugriff auf den alten Rechner**, auf dem `rclone` bereits konfiguriert ist.
2. **Das Passwort für Ihr verschlüsseltes `crypt`-Remote.** Dies ist extrem wichtig! Ohne dieses Passwort können Sie auf Ihre verschlüsselten Daten nicht mehr zugreifen. Das Kopieren der Konfigurationsdatei allein reicht nicht, wenn Sie das Passwort nicht kennen.
3. Einen Weg, eine einzelne Datei zu übertragen (z.B. ein USB-Stick, ein sicheres Netzlaufwerk etc.).
---
### Schritt-für-Schritt-Anleitung
#### Schritt 1: `rclone.conf`-Datei auf dem alten Rechner finden und kopieren
Die Konfigurationsdatei, die Sie benötigen, befindet sich im Home-Verzeichnis Ihres Benutzers.
1. Öffnen Sie ein Terminal auf Ihrem **alten Rechner**.
2. Der Pfad zur Datei lautet: `~/.config/rclone/rclone.conf`.
3. Kopieren Sie diese Datei auf Ihr Übertragungsmedium (z.B. einen USB-Stick).
```bash
# Beispiel für das Kopieren auf einen USB-Stick, der unter /media/MeinStick gemountet ist
cp ~/.config/rclone/rclone.conf /media/MeinStick/
```
#### Schritt 2: `rclone` auf dem neuen Rechner installieren
Falls `rclone` auf dem **neuen Computer** noch nicht installiert ist, müssen Sie dies nachholen.
```bash
# Auf Manjaro/Arch Linux
sudo pacman -S rclone
# Auf Debian/Ubuntu
sudo apt install rclone
```
#### Schritt 3: Konfigurationsdatei auf dem neuen Rechner einfügen
Nun bringen Sie die Konfiguration auf den neuen Rechner.
1. Öffnen Sie ein Terminal auf Ihrem **neuen Rechner**.
2. Stellen Sie sicher, dass das Zielverzeichnis existiert. Der folgende Befehl erstellt es, falls es fehlt:
```bash
mkdir -p ~/.config/rclone/
```
3. Kopieren Sie die `rclone.conf`-Datei von Ihrem Übertragungsmedium in dieses Verzeichnis.
```bash
# Beispiel für das Kopieren von einem USB-Stick
cp /media/MeinStick/rclone.conf ~/.config/rclone/
```
#### Schritt 4: Überprüfung und erster Test auf dem neuen Rechner
Jetzt können Sie überprüfen, ob `rclone` die Konfiguration erfolgreich übernommen hat.
1. **Lassen Sie sich alle erkannten Remotes anzeigen:**
```bash
rclone listremotes
```
Die Ausgabe sollte nun die Namen Ihrer Remotes (z.B. `nextcloud_unverschluesselt:` und `nextcloud_verschluesselt:`) auflisten.
2. **Führen Sie einen Test durch:**
Der beste Test ist, den Inhalt Ihres verschlüsselten Remotes aufzulisten.
```bash
rclone ls nextcloud_verschluesselt:
```
* Möglicherweise fragt `rclone` Sie an dieser Stelle einmalig nach dem Passwort für Ihr verschlüsseltes Remote, um es zu verifizieren. Geben Sie hier das Passwort ein, das Sie sich gemerkt haben.
* Wenn der Befehl erfolgreich ist und eine Liste Ihrer verschlüsselten Dateien und Ordner anzeigt, war der Umzug erfolgreich!
---
### ⚠️ Wichtiger Warnhinweis zum Passwort
Die `rclone.conf`-Datei speichert Ihr Verschlüsselungspasswort nur in einer verschleierten Form. **Sie ersetzt nicht die Notwendigkeit, dass Sie das Passwort kennen!**
* **Bewahren Sie Ihr Passwort immer an einem sicheren Ort auf** (z.B. in einem Passwort-Manager).
* Ohne das korrekte Passwort sind Ihre verschlüsselten Daten **unwiderruflich verloren**, selbst wenn Sie die `rclone.conf`-Datei haben.
* Betrachten Sie die `rclone.conf`-Datei selbst als sensibel, da sie die Zugangsdaten zu Ihren Cloud-Konten enthält.
content/willkommen.md
+22
View File
@@ -0,0 +1,22 @@
---
title: "Willkommen bei Hugo Docker"
date: "2026-09-08"
---
Das ist eine Beispiel-Seite. **Funktioniert!**
Einfach `.md`-Dateien in den Ordner `content/` kopieren – Hugo rendert sie automatisch.
## So geht's
```bash
# Neue Seite anlegen
echo '---
title: "Meine Seite"
date: "2026-09-08"
---
Inhalt hier ...
' > content/meine-seite.md
```
Änderungen werden dank `--watch` in Echtzeit übernommen.
content/yubikey_setup_guide.md
+148
View File
@@ -0,0 +1,148 @@
---
title: "YubiKey-Einrichtung unter Manjaro Sway"
date: "2026-09-08"
---
# YubiKey-Einrichtung unter Manjaro Sway
Diese Anleitung beschreibt, wie Sie einen YubiKey unter Manjaro Sway für verschiedene Anwendungsfälle konfigurieren.
---
### Übersicht der Anwendungsfälle:
1. **FIDO2/U2F:** Für die Zwei-Faktor-Authentifizierung auf Webseiten.
2. **GPG:** Zur Verschlüsselung von E-Mails/Dateien und zum Signieren von Git-Commits.
3. **SSH:** Zur sicheren Anmeldung auf Servern.
4. **PAM:** Zur Anmeldung am System oder für `sudo` (fortgeschritten und mit Vorsicht zu genießen).
---
### Schritt 1: Notwendige Pakete installieren
Zuerst müssen Sie die erforderlichen Pakete über den Paketmanager `pacman` installieren. Öffnen Sie ein Terminal und führen Sie den folgenden Befehl aus:
```bash
sudo pacman -S yubikey-manager yubikey-personalization libfido2 gnupg pcsclite ccid
```
**Erklärung der Pakete:**
* `yubikey-manager`: Das wichtigste Werkzeug zur Konfiguration Ihres YubiKeys.
* `yubikey-personalization`: Für ältere YubiKey-Modelle oder spezielle Konfigurationen (obwohl `yubikey-manager` oft bevorzugt wird).
* `libfido2`: Stellt die FIDO2-Unterstützung für WebAuthn in Browsern sicher.
* `gnupg`: Das GnuPG-Programm, notwendig für die Smartcard-Funktionen des YubiKeys.
* `pcsclite` & `ccid`: Systemdienste, die die Kommunikation mit dem YubiKey als Smartcard ermöglichen.
Nach der Installation ist es eine gute Idee, den `pcscd`-Dienst zu aktivieren und zu starten:
```bash
sudo systemctl enable pcscd.service
sudo systemctl start pcscd.service
```
### Schritt 2: YubiKey erkennen und Status prüfen
Stecken Sie Ihren YubiKey ein und überprüfen Sie, ob das System ihn erkennt:
```bash
ykman info
```
Wenn alles korrekt ist, sollten Sie hier Informationen zu Ihrem YubiKey-Modell und dessen Firmware-Version sehen.
---
### Anwendungsfälle:
#### Anwendungsfall A: Web-Authentifizierung (FIDO2/U2F)
Dies ist der einfachste Fall und erfordert in der Regel keine zusätzliche Konfiguration nach der Installation von `libfido2`.
1. **Voraussetzung:** Ein unterstützter Webbrowser (Firefox, Chrome, Brave, Edge, etc.).
2. **Registrierung:** Gehen Sie zu einer Webseite, die WebAuthn oder FIDO2 unterstützt (z.B. GitHub, Google, GitLab). Navigieren Sie zu den Sicherheitseinstellungen der Webseite.
3. **YubiKey hinzufügen:** Registrieren Sie Ihren YubiKey als neuen Sicherheitsschlüssel. Der Browser sollte Sie auffordern, den YubiKey zu berühren.
Das war's schon! Sie können den YubiKey nun für die Zwei-Faktor-Authentifizierung (2FA) auf diesen Seiten verwenden.
#### Anwendungsfall B: GPG für Verschlüsselung und Signaturen
Sie können den YubiKey als Hardware-Speicher für Ihre GPG-Schlüssel verwenden. Das ist sehr sicher, da die privaten Schlüssel den YubiKey niemals verlassen.
1. **GPG-Status prüfen:** Stecken Sie den YubiKey ein und führen Sie aus:
```bash
gpg --card-status
```
Wenn GPG den YubiKey als "Card" erkennt, sind Sie bereit für die weitere Konfiguration.
2. **Schlüssel generieren oder importieren:**
Der Prozess, GPG-Schlüssel zu erstellen und auf den YubiKey zu übertragen, ist sehr umfangreich und sollte sorgfältig durchgeführt werden. Die offizielle Anleitung von Yubico ist hierfür die beste Quelle:
[Yubico Docs: Using Your YubiKey with GPG](https://developers.yubico.com/PGP/)
(Stellen Sie sicher, dass Sie eine aktuelle Anleitung verwenden, die zu Ihrer YubiKey-Firmware passt.)
#### Anwendungsfall C: SSH-Authentifizierung
Sie können den YubiKey auch für die SSH-Authentifizierung verwenden, um sich sicher auf Servern anzumelden.
**Möglichkeit 1: SSH-Authentifizierung über GPG**
Wenn Sie bereits GPG (Anwendungsfall B) eingerichtet haben, können Sie den Authentifizierungs-Unterschlüssel Ihres GPG-Schlüssels für SSH verwenden.
1. Fügen Sie `enable-ssh-support` zu Ihrer `~/.gnupg/gpg-agent.conf` hinzu.
2. Folgen Sie einer Anleitung, um den GPG-Agent als SSH-Agent zu konfigurieren, z.B. für Arch Linux (Manjaro basiert darauf):
[ArchWiki: GnuPG - SSH agent](https://wiki.archlinux.org/title/GnuPG#SSH_agent)
**Möglichkeit 2: Direkte FIDO-basierte SSH-Schlüssel (neuere YubiKeys)**
Neuere YubiKeys (ab Firmware 5.2.7) können direkt als FIDO-Gerät für SSH-Schlüssel vom Typ `ecdsa-sk` oder `ed25519-sk` verwendet werden. Dies erfordert OpenSSH ab Version 8.2.
1. **Schlüssel generieren:**
```bash
ssh-keygen -t ed25519-sk -C "mein-yubikey-ssh-schluessel"
```
`ssh-keygen` wird Sie auffordern, Ihren YubiKey zu berühren, um den Schlüssel zu erstellen.
2. **Öffentlichen Schlüssel verwenden:**
Den generierten öffentlichen Schlüssel (z.B. `~/.ssh/id_ed25519_sk.pub`) können Sie wie gewohnt auf Ihre Server in die `~/.ssh/authorized_keys`-Datei kopieren. Bei der SSH-Anmeldung wird Ihre SSH-Anwendung Sie dann auffordern, den YubiKey zu berühren.
#### Anwendungsfall D: System-Login und Sudo (PAM) - **Für Fortgeschrittene und mit äußerster Vorsicht!**
Sie können den YubiKey auch verwenden, um sich am System anzumelden oder `sudo`-Befehle zu autorisieren. Eine Fehlkonfiguration hier kann Sie von Ihrem System ausschließen.
**⚠️ WARNUNG:**
* **Lassen Sie IMMER ein zweites Terminal mit einer aktiven Root-Shell (`sudo -i`) offen**, während Sie die PAM-Konfiguration ändern. So können Sie Fehler sofort korrigieren.
* Erstellen Sie vor Änderungen an PAM-Dateien **immer Backups** der Originaldateien (z.B. `sudo cp /etc/pam.d/sudo /etc/pam.d/sudo.bak`).
1. **PAM-Modul installieren:**
```bash
sudo pacman -S pam-u2f
```
2. **Konfigurationsdatei für den YubiKey erstellen:**
Diese Datei ordnet Ihren YubiKey Ihrem Benutzerkonto zu.
```bash
mkdir -p ~/.config/Yubico
pamu2fcfg > ~/.config/Yubico/u2f_keys
```
**Wichtig:** Stecken Sie Ihren YubiKey ein und berühren Sie ihn, wenn die LED während der Ausführung von `pamu2fcfg` blinkt.
3. **PAM-Datei bearbeiten (Beispiel für `sudo`):**
Öffnen Sie die `sudo`-PAM-Konfiguration zum Bearbeiten:
```bash
sudo nano /etc/pam.d/sudo
```
Fügen Sie die folgende Zeile **GANZ OBEN** in die Datei ein:
```
auth sufficient pam_u2f.so authfile=/home/DEIN_BENUTZER/.config/Yubico/u2f_keys
```
* Ersetzen Sie `DEIN_BENUTZER` durch Ihren tatsächlichen Linux-Benutzernamen (z.B. `jonnybravo`).
* `auth sufficient`: Bedeutet, dass eine erfolgreiche Authentifizierung mit dem YubiKey **ausreicht**. Wenn der YubiKey nicht eingesteckt ist oder die Authentifizierung fehlschlägt, wird die nächste Authentifizierungsmethode (normalerweise das Passwort) verwendet. Dies ist sicherer, um sich nicht auszusperren. Wenn Sie `required` verwenden, MUSS der YubiKey funktionieren.
4. **Testen:**
Öffnen Sie ein *neues* Terminal (NICHT das, in dem Ihre Root-Shell läuft) und testen Sie den `sudo`-Befehl (z.B. `sudo ls`). Sie sollten aufgefordert werden, Ihren YubiKey zu berühren. Berühren Sie ihn und prüfen Sie, ob `sudo` funktioniert. Funktioniert es nicht, nutzen Sie das Root-Terminal, um die Änderungen rückgängig zu machen.
**Weitere PAM-Anwendungen:**
Ähnliche Einträge können Sie auch für den Login-Manager (z.B. `sddm`, `gdm`, `lightdm`) oder den Screensaver (z.B. `swaylock`) in deren entsprechenden PAM-Dateien (`/etc/pam.d/<dienstname>`) hinzufügen. Das genaue Vorgehen kann je nach Dienst variieren.
---
### Wichtige Hinweise:
* **PINs und PUKs:** Merken Sie sich die PINs und PUKs Ihres YubiKeys. Sie sind für viele Funktionen unerlässlich.
* **Backups:** Erstellen Sie immer Backups Ihrer GPG-Schlüssel, bevor Sie diese auf den YubiKey verschieben.
* **Vorsicht bei PAM:** PAM-Konfigurationen sind mächtig. Testen Sie Änderungen immer sorgfältig und haben Sie einen Notfallplan (z.B. eine Live-CD oder das offene Root-Terminal).
* **Firmware:** Stellen Sie sicher, dass die Firmware Ihres YubiKeys aktuell ist (`ykman firmware info`).
* **Dokumentation:** Die Yubico-Dokumentation ist exzellent und sollte bei spezifischen Problemen oder fortgeschrittenen Konfigurationen konsultiert werden.