Domowe laboratorium dla lokalnych modeli LLM: Docker i zintegrowana grafika AMD

Piotr Zagorowski / / Porady

Uruchamianie lokalnych modeli LLM w domu jest łatwiejsze, niż się wydaje. Z odpowiednim mini PC, dobrze skonfigurowanym Ubuntu, kilkoma zmianami w BIOS-ie i kontenerami Dockera możesz zbudować wydajne laboratorium, w którym na sprzęcie AMD działają modele takie jak Mistral 7B i Ollama. Oto jak przygotowałem swoje.

Zaczęło się tak jak wiele moich majsterkowiczowskich projektów: od kubka kawy i spokojnego sobotniego poranka. Od tygodni myślałem o zbudowaniu małego serwera: na tyle cichego, żeby mógł stać pod biurkiem, na tyle mocnego, żeby poradził sobie z modelami 7B–8B (a nawet 12–14B!), i na tyle elastycznego, żebym mógł porządnie nauczyć się Dockera bez topienia laptopa. Tym razem zamiast tylko marzyć, naprawdę kliknąłem „Zamów”. Małe pudełko było w drodze, żeby stać się moim domowym LABORATORIUM LLM.

Jakie ziarna kupić? (Wybór sprzętu do lokalnych LLM)

Tak jak w przypadku ziaren kawy, wybór sprzętu robi całą różnicę. Wpisałem swoje wymagania do Perplexity: mała obudowa, mocna zintegrowana grafika, 64 GB RAM, co najmniej 1 TB NVMe, Wi-Fi 7, USB4; musi bez problemu obsługiwać lokalne modele.

Po zawężeniu listy wybór „w sam raz” padł na:

GMKtec EVO-X2 AI Mini PC: AMD Ryzen AI Max+ 395 (do 5,1 GHz), 64 GB LPDDR5X 8000 MHz, dysk SSD 1 TB PCIe 4.0, obsługa czterech ekranów 8K, Wi-Fi 7 i USB4, czytnik kart SD 4.0.
Kompaktowy, cichy i wystarczająco mocny, żeby być prawdziwym placem zabaw dla LLM.


Ubuntu czy Fedora? (Najlepsza dystrybucja Linuksa dla LLM)

Kiedy pudełko dotarło, pojawiło się kolejne pytanie: jaki Linux zainstalować?
Wybór dystrybucji nadaje ton wszystkiemu innemu, tak jak wybór ziaren nadaje bazowy smak kawie.

Rozważałem dwie główne opcje:

  • Fedora: bardzo świeże jądra i Mesa (świetne dla najnowszych kart AMD), domyślnie SELinux, szybki cykl wydań.
  • Ubuntu 24.04 LTS: długie wsparcie, ogromna społeczność, przewidywalne pakiety, a jądro HWE utrzymuje sterowniki graficzne w miarę aktualne.

Ubuntu znam obecnie najlepiej, więc wybór padł na Ubuntu 24.04.3 LTS.


Mielenie ziaren: bootowalny pendrive

Zanim zainstalujemy Ubuntu, musimy je jakoś dostarczyć na komputer. Czyli przygotować bootowalny pendrive.
To odpowiednik mielenia ziaren przed parzeniem: mały, ale niezbędny krok.

# 1) Identify the target device (careful!)
lsblk -o NAME,SIZE,MODEL,TRAN

# 2) Write the ISO (note the capital M in bs=4M)
sudo dd if=~/Downloads/ubuntu-24.04.3-desktop-amd64.iso of=/dev/sdX bs=4M status=progress oflag=sync
sync

Wskazówka: to 4M, a nie 4m. Mała litera „m” kończy się błędem dd: invalid number: '4m'.


Dopracowanie przepisu: ustawienia BIOS

Teraz czas na przygotowania za kulisami.
Zanim system operacyjny w ogóle się uruchomi, trzeba upewnić się, że BIOS jest dobrze ustawiony, żeby sprzęt mógł działać na pełnych obrotach. To jak sprawdzenie czajnika, młynka i wagi przed parzeniem.

  • Rozruch UEFI, najpierw NVMe (USB na pierwszym miejscu tylko na czas instalacji)
  • SVM / wirtualizacja: włączone
  • Resizable BAR / Above 4G Decoding: włączone (jeśli jest dostępne)
  • Secure Boot: można zostawić włączony
  • Pamięć UMA/iGPU: niska (bez monitora) albo 8–16 GB, jeśli podłączysz monitor
  • Profil wentylatorów: Performance

Zapisz → uruchom ponownie → uruchom z pendrive’a.


Pierwsze parzenie: problemy z instalatorem

Z gotowym BIOS-em przyszedł czas na instalację Ubuntu.
Zwykle idzie to gładko, ale każdy, kto stawiał serwery, wie, że czasem trafia się na wyboje.

U mnie instalator przerwał pracę z „nieznanym błędem”. Winowajcą okazał się niestabilny oficjalny serwer lustrzany. Rozwiązanie:

  • Przełącz instalator w tryb offline
  • Odłącz kabel sieciowy
  • Przeprowadź całą instalację offline → sukces

Ta mała przeszkoda przypomniała mi stare, dobre czasy administratora.


Pierwsze uruchomienie: aktualizacje, serwery lustrzane, SSH

Po instalacji system działał, ale nie był jeszcze gotowy.
Świeża instalacja Linuksa zawsze potrzebuje aktualizacji, dobrego serwera lustrzanego i bezpiecznego sposobu na zdalne połączenie. Oto jak to ustawiłem.

Szybki serwer lustrzany po HTTPS (format deb822 w 24.04)

sudo cp /etc/apt/sources.list.d/ubuntu.sources{,.bak} 2>/dev/null || true
sudo tee /etc/apt/sources.list.d/ubuntu.sources >/dev/null <<'EOF'
Types: deb
URIs: https://mirror.mythic-beasts.com/ubuntu
Suites: noble noble-updates noble-backports
Components: main restricted universe multiverse
Signed-By: /usr/share/keyrings/ubuntu-archive-keyring.gpg

Types: deb
URIs: https://mirror.mythic-beasts.com/ubuntu
Suites: noble-security
Components: main restricted universe multiverse
Signed-By: /usr/share/keyrings/ubuntu-archive-keyring.gpg
EOF

echo 'Acquire::ForceIPv4 "true";' | sudo tee /etc/apt/apt.conf.d/99force-ipv4
sudo apt clean && sudo apt update

Aktualizacja, jądro HWE, firmware, restart

sudo apt full-upgrade -y
sudo apt install -y linux-generic-hwe-24.04
sudo apt install --reinstall -y linux-firmware
sudo reboot

Serwer SSH + podstawowe zabezpieczenia

sudo apt install -y openssh-server
sudo systemctl enable --now ssh
sudo ufw allow OpenSSH

# keys (from your client):
ssh-keygen -t ed25519 -C "$(whoami)@$(hostname)"
ssh-copy-id <user>@<server-ip>

# simple hardening
sudo bash -c 'cat >/etc/ssh/sshd_config.d/90-custom.conf' <<'EOF'
PermitRootLogin no
PasswordAuthentication no
PubkeyAuthentication yes
KbdInteractiveAuthentication no
X11Forwarding no
ClientAliveInterval 60
ClientAliveCountMax 3
MaxAuthTries 3
EOF
sudo sshd -t && sudo systemctl reload ssh

Parzenie z Vulkanem: zintegrowana grafika AMD dla llama.cpp

Gdy system był już w sieci i zabezpieczony, przyszedł czas na akcelerację GPU.
Wydajne uruchamianie modeli na zintegrowanej grafice AMD wymaga sterowników Vulkan i odpowiednich uprawnień grup. To ten krok decyduje, czy serwer po prostu uruchamia LLM-y, czy uruchamia je dobrze.

# Userspace + tools
sudo apt install -y git build-essential cmake pkg-config \
  libvulkan-dev libvulkan1 mesa-vulkan-drivers vulkan-tools \
  libcurl4-openssl-dev glslc spirv-tools radeontop

# GPU access (new login required to apply groups)
sudo usermod -aG render,video "$USER"

# Optional: silence headless warning in current shell
export XDG_RUNTIME_DIR=/run/user/$(id -u); mkdir -p "$XDG_RUNTIME_DIR"; chmod 700 "$XDG_RUNTIME_DIR"

# Quick check
vulkaninfo --summary | head -n 20

Kompilacja llama.cpp z Vulkanem (+ serwer)

cd ~
git clone https://github.com/ggerganov/llama.cpp.git
cd ~/llama.cpp
cmake -S . -B build -DGGML_VULKAN=ON -DLLAMA_BUILD_SERVER=ON
cmake --build build -j"$(nproc)"

Szybki test na małym modelu:

mkdir -p ~/models/tinyllama && cd ~/models/tinyllama
curl -L -o TinyLlama-1.1B-Chat-v1.0.Q4_K_M.gguf \
  "https://huggingface.co/TinyLlama/TinyLlama-1.1B-Chat-v1.0-GGUF/resolve/main/TinyLlama-1.1B-Chat-v1.0.Q4_K_M.gguf?download=true"
xxd -l 4 -p TinyLlama-1.1B-Chat-v1.0.Q4_K_M.gguf   # 47475546 = "GGUF"

AMD_VULKAN_ICD=RADV ~/llama.cpp/build/bin/llama-cli \
  -m ~/models/tinyllama/TinyLlama-1.1B-Chat-v1.0.Q4_K_M.gguf \
  -ngl 999 -c 4096 -b 512 \
  -p "Say hello in one short sentence."

Od espresso do pełnego dzbanka: Mistral 7B lokalnie

Kiedy test zadziałał, czas było przejść na prawdziwy model: Mistral 7B.
Ten krok zmienia pudełko z „zabawki” w „poważne laboratorium LLM”.

export LLAMA_CACHE=~/models/.cache/llama
mkdir -p "$LLAMA_CACHE"

# Serve on all interfaces so Docker bridge containers can reach it
AMD_VULKAN_ICD=RADV ~/llama.cpp/build/bin/llama-server \
  --hf-repo TheBloke/Mistral-7B-Instruct-v0.2-GGUF \
  --hf-file mistral-7b-instruct-v0.2.Q4_K_M.gguf \
  --alias mistral-7b-q4km \
  -ngl 999 -c 8192 -b 512 --threads "$(nproc)" \
  --host 0.0.0.0 --port 8081

Sprawdzenie:

curl -s http://127.0.0.1:8081/v1/models | jq .

Ollama: szybka kawa z przelewu

Nie każda interakcja wymaga GPU. Czasem chcesz po prostu czegoś szybkiego i prostego.
Tu sprawdza się Ollama: łatwe pobieranie modeli, API zgodne z OpenAI i, na dzień dzisiejszy, działanie na CPU na Linuksie z AMD.

curl -fsSL https://ollama.com/install.sh | sh
sudo systemctl enable --now ollama
curl -s http://127.0.0.1:11434/api/tags | jq .

CPU czy GPU? Obserwuj oba:

# CPU
htop   # look for "ollama"

# GPU busy % (AMD)
watch -n0.5 'cat /sys/class/drm/card0/device/gpu_busy_percent'
sudo apt install -y radeontop && radeontop

# Who's using the render node?
sudo lsof -nP /dev/dri/renderD128

Jeśli chcesz mieć pewność akceleracji na GPU AMD, większe zadania uruchamiaj przez llama.cpp (Vulkan), a Ollamę zostaw do szybkich eksperymentów.


Docker: sprzęt do parzenia

Na tym etapie moje domowe laboratorium potrafi już uruchamiać modele bezpośrednio. Ale żeby naprawdę się uczyć i skalować, Docker jest niezbędny.
Kontenery utrzymują eksperymenty w porządku i pozwalają je powtarzać, tak jak osobne zaparzacze do espresso, przelewu i cold brew, żeby nie mieszać smaków.

# prerequisites
sudo apt-get remove -y docker docker-engine docker.io containerd runc 2>/dev/null || true
sudo apt update
sudo apt install -y ca-certificates curl gnupg

# repo + key
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | \
  sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] \
  https://download.docker.com/linux/ubuntu noble stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list >/dev/null

sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
sudo usermod -aG docker "$USER"
newgrp docker <<<' '
docker version

Open WebUI: kawiarniana lada

Kiedy działają już Ollama i llama.cpp, Open WebUI staje się przyjaznym baristą.
Spina wszystko w całość: jeden interfejs do zarządzania modelami, promptami i historią rozmów. To kawiarniana lada, przy której spotykają się wszystkie narzędzia.

Opcja 1: sieć hosta (najprościej)

# docker-compose.yml
services:
  open-webui:
    image: ghcr.io/open-webui/open-webui:main
    container_name: open-webui
    network_mode: "host"
    environment:
      - OLLAMA_BASE_URL=http://127.0.0.1:11434
      # We’ll add llama.cpp as a second "OpenAI-compatible" provider in the UI:
      - OPENAI_API_BASE=http://127.0.0.1:8081
      - OPENAI_API_KEY=local
    volumes:
      - /home/zagor/src/open-webui/data:/app/backend/data
    restart: unless-stopped

Uruchom:

docker compose up -d

Otwórz http://<adres-ip-serwera>:8080, przejdź do Settings → Providers → Add OpenAI-compatible:

  • Base URL: http://127.0.0.1:8081 (bez /v1)
  • API key: local (cokolwiek)

Monitorowanie: pilnowanie parzenia

Kiedy modele już działają, łatwo zapomnieć o samym systemie.
Ale obserwowanie obciążenia GPU, pamięci i kontenerów zapewnia płynną pracę. To jak pilnowanie czajnika, kiedy kawa się przelewa.

# GPU
watch -n0.5 'cat /sys/class/drm/card0/device/gpu_busy_percent'
sudo apt install -y radeontop && radeontop
sudo mount -t debugfs none /sys/kernel/debug 2>/dev/null || true
watch -n0.5 'sudo egrep "GPU load|GPU clock|Memory clock" /sys/kernel/debug/dri/0/amdgpu_pm_info'

# RAM + swap
watch -n1 free -h
swapon --show

# Containers
docker stats

Przydatne linki

KategoriaOpisLink
Oficjalna strona i dokumentacjaGłówna strona LM Studiolmstudio.ai
Wymagania systemoweWymagania sprzętowe i programoweSystem Requirements
Pierwsze krokiPodstawy obsługi i konfiguracjiGetting Started
Wsparcie AMD ROCmInformacje o obsłudze GPU AMD przez ROCmROCm & Ryzen AI
Obraz Dockera (nieoficjalny)Obraz Dockera z LM Studio i CUDADocker Hub - noneabove1182/lmstudio-cuda
Przykład Docker ComposePrzykładowy docker-compose dla LM StudioGitLab LM Studio docker-compose
Poradnik MCP ToolkitJak uruchomić MCP Toolkit z LM StudioDEV Guide
LLM-y w LM StudioOgólny poradnik uruchamiania lokalnych LLMGPU Mart Guide
GPU wspierane przez ROCmLista kart AMD zgodnych z ROCmROCm Supported GPUs
Odblokowanie GPU AMDJak uruchomić LM Studio na dowolnym GPU AMDROCm Unlock Guide
LLM na GPU AMDPoradnik dla początkujących: GPU AMD i lokalne LLMTechTeamGB Guide

Czego nauczyła mnie ta kawowa podróż

  • Budowa serwera jest jak parzenie kawy: cierpliwość i drobne korekty robią różnicę.
  • Ustawienia BIOS-u znaczą więcej, niż myślisz; jak temperatura wody: źle ustawione i nic nie smakuje.
  • Spodziewaj się problemów: niestabilny serwer lustrzany albo literówka w parametrze dd to część podróży.
  • Dokumentuj na bieżąco: przyszły Ty podziękuje, kiedy coś się zepsuje o drugiej w nocy.
  • Zacznij od małego modelu (TinyLlama), zanim przejdziesz do pełnego espresso (Mistral 7B).

Zanim skończyły się ostatnie polecenia, moja kawa zdążyła wystygnąć, ale LABORATORIUM żyło. Pod biurkiem stoi teraz konkretny serwer z kontenerami Dockera, Ollamą do szybkich eksperymentów i llama.cpp z akceleracją Vulkan, kiedy chcę docisnąć GPU.

I tak jak przy parzeniu kawy, frajda nie polega na perfekcji. Polega na praktyce.

PS. Użyłem obrazka wygenerowanego przez AI, bo moje biurko jest zbyt zabałaganione :)


👉 Teraz Twoja kolej: czy próbowałeś już postawić własne laboratorium z lokalnymi LLM? Na jakie problemy z serwerami lustrzanymi albo dziwactwa BIOS-u trafiłeś? Podziel się swoimi historiami, chętnie porównam je z moją sagą o domowym laboratorium :)


Ten wpis ukazał się pierwotnie po angielsku na moim blogu Coffee Journeys.

Coffee JourneysTechnologienarzędzia