Initial import: bare-metal stacks, Server UI, GPU fan, tutorials.

Infrastructure configs for GMKtec K11 (Docker, vLLM, LocalAI, ComfyUI,
control-plane, gpu-fan agent, Server UI with CLI/file explorer/GPU fan curve).

Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
tomasz-syn-grzegorza
2026-07-05 12:02:04 +00:00
commit 359afb3a59
153 changed files with 18169 additions and 0 deletions
+56
View File
@@ -0,0 +1,56 @@
# GPU Fan — START TUTAJ
**Cel:** Wiedzieć od czego zacząć i czy ta aplikacja idzie do Dockera.
**Czas:** 2 minuty czytania
**Wymagania:** Brak (to tylko mapa dokumentacji)
---
## Jednozdaniowa odpowiedź
**GPU Fan NIE działa w Dockerze — instalujesz go na hoście (systemd), raz, i zapominasz.**
Steruje wentylatorami karty graficznej. Reszta (ComfyUI, LocalAI) może być w Dockerze — to osobne programy.
---
## Mapa dokumentacji
| Plik | Kiedy czytać |
|------|----------------|
| [01-INSTALACJA-KROK-PO-KROKU.md](01-INSTALACJA-KROK-PO-KROKU.md) | Pierwsza instalacja na serwerze |
| [02-OTWIERANIE-UI-W-PRZEGLADARCE.md](02-OTWIERANIE-UI-W-PRZEGLADARCE.md) | Chcesz otworzyć panel w przeglądarce |
| [03-KRZYWa-I-TRYBY.md](03-KRZYWa-I-TRYBY.md) | Chcesz zmienić chłodzenie / tryb wentylatorów |
| [04-CZESTE-BLEDY.md](04-CZESTE-BLEDY.md) | Coś nie działa |
| [05-DLACZEGO-NIE-DOCKER.md](05-DLACZEGO-NIE-DOCKER.md) | „A czemu nie w kontenerze?” |
Dla agentów AI / deweloperów: [../coding-agent/DOCKER-VS-HOST-REPORT.md](../coding-agent/DOCKER-VS-HOST-REPORT.md)
---
## Szybka ścieżka (jeśli się spieszysz)
```bash
cd ~/cursor/ubuntu-bare-metal/stacks/gpu-fan
nvidia-smi # musi pokazać kartę — jeśli nie, najpierw napraw driver
sudo scripts/install.sh
sudo scripts/enable-lan.sh
sudo systemctl start gpu-fan
sudo systemctl status gpu-fan
```
Potem: [02-OTWIERANIE-UI-W-PRZEGLADARCE.md](02-OTWIERANIE-UI-W-PRZEGLADARCE.md)
---
## Co zobaczysz gdy działa
- `systemctl status gpu-fan`**active (running)**
- W przeglądarce: panel z temperaturą GPU i wykresem krzywej (port **8090**)
- Wentylatory reagują na temperaturę (w trybie **curve**)
---
## Co zrobić gdy nie działa
→ [04-CZESTE-BLEDY.md](04-CZESTE-BLEDY.md)
@@ -0,0 +1,127 @@
# Instalacja GPU Fan — krok po kroku
**Cel:** Zainstalować sterowanie wentylatorami GPU na serwerze.
**Czas:** ~10 minut
**Wymagania:** `sudo`, działający `nvidia-smi`, internet (pip)
---
## Krok 0 — Sprawdź kartę graficzną
Na serwerze wpisz:
```bash
nvidia-smi
```
**Co zobaczysz gdy OK:** tabela z nazwą karty (np. RTX 3090 Ti), driverem, temperaturą.
**Gdy nie działa:** najpierw napraw sterownik NVIDIA. Bez tego GPU Fan nie ma sensu.
---
## Krok 1 — Wejdź do katalogu stacku
```bash
cd ~/cursor/ubuntu-bare-metal/stacks/gpu-fan
```
(Ścieżka może być inna — ważne żebyś był w folderze z plikiem `app.py`.)
---
## Krok 2 — Zainstaluj na hoście (NIE Docker)
```bash
sudo scripts/install.sh
```
Skrypt:
- kopiuje pliki do `/opt/gpu-fan`
- tworzy `/etc/gpu-fan/curve.json` (domyślna krzywa chłodzenia)
- tworzy `/opt/control-plane/.env` z losowym `API_KEY` (przy pierwszej instalacji)
- instaluje usługę systemd `gpu-fan`
**Co zobaczysz gdy OK:** komunikat „Installed to /opt/gpu-fan” i instrukcja startu.
---
## Krok 3 — Włącz dostęp z sieci lokalnej (LAN)
```bash
sudo scripts/enable-lan.sh
```
Ustawia nasłuch na `0.0.0.0:8090` i upewnia się że jest `API_KEY`.
---
## Krok 4 — Uruchom usługę
```bash
sudo systemctl start gpu-fan
sudo systemctl enable gpu-fan
```
`enable` = start automatyczny po restarcie serwera.
---
## Krok 5 — Sprawdź czy działa
```bash
sudo systemctl status gpu-fan
```
**Co zobaczysz gdy OK:** `Active: active (running)` na zielono.
Logi na żywo:
```bash
journalctl -u gpu-fan -f
```
(Wyjdź: Ctrl+C)
Test API (skopiuj całość):
```bash
API_KEY=$(grep ^API_KEY= /opt/control-plane/.env | cut -d= -f2)
curl -s http://127.0.0.1:8090/api/status -H "X-API-Key: $API_KEY" | head -c 200
```
**Co zobaczysz gdy OK:** JSON z `"temperature_c"` i `"mode"`.
---
## Krok 6 — Otwórz panel w przeglądarce
→ [02-OTWIERANIE-UI-W-PRZEGLADARCE.md](02-OTWIERANIE-UI-W-PRZEGLADARCE.md)
---
## Po aktualizacji kodu w repo
Jeśli zmieniłeś pliki w `stacks/gpu-fan/`:
```bash
cd ~/cursor/ubuntu-bare-metal/stacks/gpu-fan
sudo scripts/install.sh
sudo systemctl restart gpu-fan
```
---
## Czego NIE robić
| Nie rób tego | Dlaczego |
|--------------|----------|
| `sudo scripts/start.sh` + `systemctl start gpu-fan` naraz | Dwa programy na porcie 8090 — błąd |
| Instalacja w Dockerze | Nie wspierane — patrz [05-DLACZEGO-NIE-DOCKER.md](05-DLACZEGO-NIE-DOCKER.md) |
| Edycja tylko `stacks/control-plane/.env` | Produkcja czyta `/opt/control-plane/.env` |
---
## Co zrobić gdy nie działa
→ [04-CZESTE-BLEDY.md](04-CZESTE-BLEDY.md)
@@ -0,0 +1,100 @@
# Otwieranie panelu GPU Fan w przeglądarce
**Cel:** Wejść do panelu sterowania wentylatorami GPU z komputera w sieci LAN.
**Czas:** ~3 minuty
**Wymagania:** Działające usługi `gpu-fan` (agent) i `server-ui` (panel)
> UI gpu-fan **nie** jest już na porcie 8090. Użyj **Server UI** na porcie **8091**, zakładka **GPU Fan**.
---
## Krok 1 — Sprawdź IP serwera
Na serwerze:
```bash
hostname -I | awk '{print $1}'
```
Przykład wyniku: `192.168.100.90` — to Twój adres w LAN.
---
## Krok 2 — Pobierz klucz API
Na serwerze:
```bash
grep ^API_KEY= /opt/control-plane/.env
# lub ten sam klucz z agenta:
grep ^API_KEY= /opt/control-plane/.env
```
Przykład: `API_KEY=a1b2c3d4e5f6...` — skopiuj część **po** znaku `=`.
---
## Krok 3 — Otwórz URL w przeglądarce
Z innego komputera w tej samej sieci WiFi/LAN:
```
http://192.168.100.90:8091/?api_key=WKLEJ_TUTAJ_KLUCZ#gpu-fan
```
Zamień:
- `192.168.100.90` → IP z kroku 1
- `WKLEJ_TUTAJ_KLUCZ` → wartość z kroku 2
Kliknij zakładkę **GPU Fan** (lub użyj `#gpu-fan` w URL).
**Co zobaczysz gdy OK:** wykres krzywej wentylatorów, temperatura GPU, monitoring mocy/VRAM.
Klucz zapisze się w przeglądarce (localStorage `server-ui-api-key`) — przy kolejnych wizytach wystarczy `http://IP:8091/#gpu-fan`.
---
## Dostęp tylko z samego serwera
```
http://127.0.0.1:8091/#gpu-fan
```
(API key może być wymagany gdy `SERVER_UI_HOST=0.0.0.0`.)
---
## Dostęp przez SSH (opcjonalnie)
Na **swoim** laptopie:
```bash
ssh -L 8091:127.0.0.1:8091 TWOJ_USER@192.168.100.90
```
W przeglądarce na laptopie: `http://localhost:8091/#gpu-fan`
---
## Co zrobić gdy nie działa
| Objaw | Co zrobić |
|-------|-----------|
| Strona się nie ładuje | `sudo systemctl status server-ui` — czy **running**? |
| Zakładka GPU Fan pusta / błąd 502 | `sudo systemctl status gpu-fan` — agent na :18090 |
| `401` / brak danych | Zły klucz API — sprawdź `/opt/control-plane/.env` |
| Agent nie odpowiada | `curl -s http://127.0.0.1:18090/api/status -H "X-API-Key: KLUCZ"` |
Test proxy:
```bash
curl -s http://127.0.0.1:8091/api/gpu-fan/health -H "X-API-Key: $(grep ^API_KEY= /opt/control-plane/.env | cut -d= -f2)"
```
---
## Bezpieczeństwo (krótko)
- Panel **nie** wystawiaj na internet bez firewall / VPN.
- W LAN używaj `API_KEY` w Server UI.
- Agent gpu-fan (:18090) nasłuchuje tylko na localhost.
+112
View File
@@ -0,0 +1,112 @@
# Krzywa temperatury i tryby wentylatorów
**Cel:** Zrozumieć jak GPU Fan reguluje wentylatory i kiedy zmienić tryb.
**Czas:** ~5 minut
**Wymagania:** Działający panel (patrz [02-OTWIERANIE-UI-W-PRZEGLADARCE.md](02-OTWIERANIE-UI-W-PRZEGLADARCE.md))
---
## Trzy tryby — który wybrać
| Tryb | Kiedy używać | Co robi |
|------|--------------|---------|
| **curve** | Normalna praca (domyślny) | Im wyższa temp GPU, tym szybsze wentylatory — według krzywej |
| **manual** | Awaryjnie: „na full” lub stała prędkość | Ustawiasz np. 100% ręcznie |
| **auto** | Chcesz oddać sterowanie driverowi NVIDIA | Jak bez GPU Fan — driver sam decyduje |
**Rekomendacja:** zostaw **curve** przy obciążeniu AI (ComfyUI, LocalAI). Użyj **manual 100%** tylko gdy karta się przegrzewa i chcesz na chwilę max chłodzenia.
---
## Jak działa krzywa (curve)
Plik: `/etc/gpu-fan/curve.json`
Przykład (uproszczony):
```json
{
"30": 50,
"40": 65,
"50": 80,
"55": 90,
"60": 100,
"70": 100
}
```
Znaczenie: przy **50°C** wentylatory ~**80%**, przy **60°C** i wyżej → **100%**.
Między punktami program **interpoluje** (płynna zmiana).
### Zasady (ważne)
- **3 do 7** punktów
- Temperatury **rosnąco**, każda **unikalna**
- Prędkość: **0** (= auto w API) albo **30100%** (wartości 129 są niedozwolone)
---
## Domyślna krzywa „max cooling”
Po instalacji masz agresywne chłodzenie (bezpieczne dla RTX 3090 Ti pod obciążeniem):
| Temp GPU | Wentylatory |
|----------|-------------|
| 30°C | 50% |
| 40°C | 65% |
| 50°C | 80% |
| 55°C | 90% |
| 60°C+ | 100% |
Źródło: `curve.default.json` w repo → kopiowane do `/etc/gpu-fan/curve.json`.
---
## Edycja w panelu web
1. Otwórz UI (port 8090)
2. Zmień punkty na wykresie / w tabeli
3. Kliknij **Zapisz** — zapisuje do `/etc/gpu-fan/curve.json` i włącza tryb **curve**
---
## Edycja z terminala
```bash
sudo nano /etc/gpu-fan/curve.json
sudo systemctl reload gpu-fan
```
`reload` przeładowuje plik bez pełnego restartu.
---
## Co zobaczysz w panelu
- **Temperatura** — aktualna temp GPU
- **Fan speeds** — odczyt z karty (%)
- **Target** — co program próbuje ustawić (w trybie curve/manual)
- **Mode** — curve / manual / auto
---
## Po zatrzymaniu usługi
```bash
sudo systemctl stop gpu-fan
```
Wentylatory wracają do trybu **auto** drivera NVIDIA — to zamierzone (bezpieczeństwo).
---
## Co zrobić gdy wentylatory „dziwnie” się zachowują
| Sytuacja | Wyjaśnienie |
|----------|-------------|
| 0% przy niskiej temp w trybie **auto** | Normalne — karta wyłącza wentylatory przy idle |
| Głośno od razu w **curve** | Domyślna krzywa jest agresywna — obniż prędkości w JSON |
| Brak reakcji | Sprawdź tryb — czy na pewno **curve**, nie **auto** |
Więcej: [04-CZESTE-BLEDY.md](04-CZESTE-BLEDY.md)
+163
View File
@@ -0,0 +1,163 @@
# Częste błędy GPU Fan
**Cel:** Naprawić typowe problemy bez zgadywania.
**Czas:** zależy od problemu (215 min)
**Wymagania:** Dostęp SSH do serwera, `sudo`
---
## Szybka diagnostyka (zrób to najpierw)
```bash
sudo systemctl status gpu-fan
nvidia-smi
scripts/status.sh
```
Skopiuj wynik jeśli dalej nie działa.
---
## Błąd: `Insufficient Permissions` w logach
**Przyczyna:** Program nie działa jako root.
**Naprawa:**
```bash
sudo systemctl restart gpu-fan
sudo systemctl status gpu-fan
```
Nie uruchamiaj `python app.py` bez sudo (chyba że `DRY_RUN=true` tylko do testów).
---
## Błąd: `address already in use` / port 8090 zajęty
**Przyczyna:** Dwie kopie programu naraz (najczęściej systemd + `scripts/start.sh`).
**Naprawa:**
```bash
sudo systemctl stop gpu-fan
sudo scripts/status.sh --cleanup
sudo systemctl start gpu-fan
```
**Nie zmieniaj portu na 8091** — to maskuje problem, nie go rozwiązuje.
---
## Błąd: Strona w przeglądarce się nie ładuje
| Sprawdź | Komenda |
|---------|---------|
| Usługa działa? | `sudo systemctl status gpu-fan` |
| Port nasłuchuje? | `ss -tlnp \| grep 8090` |
| LAN włączony? | `grep GPU_FAN_HOST /opt/control-plane/.env` → powinno być `0.0.0.0` |
| Firewall? | Upewnij się że LAN może dojść do 8090 |
Włącz LAN:
```bash
sudo scripts/enable-lan.sh
```
---
## Błąd: `401` / Invalid API key
**Przyczyna:** Zły klucz w URL lub brak nagłówka.
**Naprawa:**
```bash
grep ^API_KEY= /opt/control-plane/.env
```
Użyj w przeglądarce:
```
http://IP_SERWERA:8090/?api_key=KLUCZ_Z_PLIKU
```
Patrz: [02-OTWIERANIE-UI-W-PRZEGLADARCE.md](02-OTWIERANIE-UI-W-PRZEGLADARCE.md)
---
## Błąd: Zmieniam `.env` w repo i nic się nie dzieje
**Przyczyna:** Produkcja czyta **`/opt/control-plane/.env`**, nie `stacks/control-plane/.env`.
**Naprawa:**
```bash
sudo nano /opt/control-plane/.env
sudo systemctl restart gpu-fan
```
Albo pełna reinstalacja kodu (nie nadpisuje istniejącego `.env`):
```bash
sudo scripts/install.sh
```
---
## Błąd: `nvidia-smi` nie działa
**Przyczyna:** Brak / zły sterownik NVIDIA.
GPU Fan **nie naprawi** drivera. Najpierw napraw GPU w systemie, potem wróć do instalacji.
---
## Błąd: Po Ctrl+Z w terminalu port zajęty
**Przyczyna:** Proces zawieszony w tle nadal trzyma port.
**Naprawa:**
```bash
jobs -l # zobacz zawieszone
kill %1 # numer z jobs
# albo:
sudo scripts/status.sh --cleanup
```
---
## Błąd: Krzywa się nie zapisuje
Sprawdź format JSON — 37 punktów, temp unikalne, speed 0 lub 30100.
```bash
sudo cat /etc/gpu-fan/curve.json
journalctl -u gpu-fan -n 30
```
---
## Błąd: Chcę uruchomić w Dockerze
**Odpowiedź:** Nie rób tego. Patrz [05-DLACZEGO-NIE-DOCKER.md](05-DLACZEGO-NIE-DOCKER.md).
---
## Pełny reset (ostateczność)
```bash
sudo systemctl stop gpu-fan
sudo scripts/status.sh --cleanup
cd ~/cursor/ubuntu-bare-metal/stacks/gpu-fan
sudo scripts/install.sh
sudo scripts/enable-lan.sh
sudo systemctl start gpu-fan
```
Logi:
```bash
journalctl -u gpu-fan -f
```
@@ -0,0 +1,78 @@
# Dlaczego GPU Fan NIE jest w Dockerze
**Cel:** Zrozumieć dlaczego instalujemy na hoście, a nie jak ComfyUI.
**Czas:** 3 minuty
**Wymagania:** Brak
---
## Krótka odpowiedź
GPU Fan **musi** siedzieć na hoście obok sterownika NVIDIA. W Dockerze **nie ma** gotowego obrazu w tym repo i **nie planujemy** go dodawać.
ComfyUI / LocalAI = programy w kontenerach (obliczenia AI).
GPU Fan = „termometr + regulator wentylatorów” na poziomie sprzętu.
---
## Analogia
| Co | Gdzie | Dlaczego |
|----|-------|----------|
| Aplikacja w przeglądarce | Docker OK | Nie dotyka wentylatorów bezpośrednio |
| Sterownik wentylatorów karty | Host (root) | Tylko system z uprawnieniami root może pisać do NVML |
To jak termostat w kotłowni — nie wkładasz go do pudełka z aplikacją webową w innym pokoju.
---
## Co by się stało w Dockerze (gdyby ktoś próbował)
1. Kontener musiałby być **privileged** i **root**
2. I tak często dostaniesz **Insufficient Permissions** na kartach GeForce
3. Po awaryjnym `docker kill` wentylatory mogłyby zostać w trybie ręcznym
4. Zero korzyści — i tak potrzebujesz tego samego sterownika na hoście
Dlatego w repo jest tylko:
```bash
sudo scripts/install.sh
sudo systemctl start gpu-fan
```
---
## Jak to wygląda na serwerze (poprawnie)
```
HOST (Ubuntu)
├── gpu-fan.service ← steruje wentylatorami (port 8090)
├── sterownik NVIDIA
└── Docker
├── comfyui :8188
├── localai :8070
└── vllm :8000
```
Wszystko może działać **równocześnie**. GPU Fan nie koliduje z kontenerami AI.
---
## „Ale inne stacki są w Dockerze!”
Tak — bo tam Docker **ma sens** (izolacja aplikacji, GPU do inference).
GPU Fan to **daemon sprzętowy** — jak `nvidia-persistenced`, nie jak aplikacja webowa.
---
## Gdzie jest pełna analiza techniczna
Dla agentów / deweloperów:
[../coding-agent/DOCKER-VS-HOST-REPORT.md](../coding-agent/DOCKER-VS-HOST-REPORT.md)
---
## Co robić zamiast Dockera
→ [01-INSTALACJA-KROK-PO-KROKU.md](01-INSTALACJA-KROK-PO-KROKU.md)