Dealownia
Menu
sprawdzono – jak sprawdzamy oferty

Ollama na VPS bez GPU: ile RAM i vCPU potrzebuje model

Które modele Ollama działają na VPS bez karty graficznej, ile RAM i vCPU wziąć, instalacja w Dockerze, zabezpieczenie portu 11434 i pomiar szybkości.

AI i modelezaktualizowano 9 min czytania

Redakcja serwisu Dealownia · ceny i fakty ze stron dostawców, jak sprawdzamy

Na VPS-ie bez karty graficznej Ollama uruchomi każdy model, który zmieści się w pamięci RAM. Rozsądna granica to modele do kilkunastu miliardów parametrów w domyślnej kwantyzacji 4-bitowej oraz modele typu MoE (mixture of experts), które liczą każdy token tylko częścią wag. O tym, czy model w ogóle ruszy, decyduje RAM: potrzebujesz co najmniej tyle, ile waży plik modelu, plus zapas na kontekst i system. Procesor i przepustowość pamięci decydują o tym, jak szybko pojawia się odpowiedź. Przed zakupem rocznego planu zmierz to na serwerze rozliczanym godzinowo – niżej jest gotowe polecenie.

Ile RAM na który model

Rozmiary pochodzą z biblioteki Ollama (stan na 12.11.2026). To rozmiary domyślnych wariantów – np. qwen3:30b jest skwantyzowany do Q4_K_M. Kolumna z RAM to orientacyjne wyliczenie: rozmiar pliku plus ok. 2–4 GB na kontekst, system i inne usługi. Rzeczywiste zużycie po załadowaniu pokaże ollama ps (krok 3).

Model (tag w Ollama) Plik Kontekst wg biblioteki Plan VPS (orientacyjnie)
llama3.2:3b 2,0 GB 128K 4 GB RAM
gemma3:4b 3,4 GB 128K 8 GB RAM
qwen3:8b 5,2 GB 40K 8 GB RAM (na styk), lepiej 12 GB
gemma3:12b 8,2 GB 128K 16 GB RAM
qwen3:14b 9,3 GB 40K 16 GB RAM
gemma4:26b (MoE, ok. 4 mld aktywnych) 16–19 GB 256K 24–32 GB RAM
qwen3:30b (MoE, 3,3 mld aktywnych) 19 GB 256K 24–32 GB RAM
qwen3:32b (gęsty) 20 GB 40K 32 GB RAM

Dwie rzeczy, które łatwo przeoczyć:

  • Modele MoE na CPU. qwen3:30b ma według karty modelu 30,5 mld parametrów, ale na każdy token aktywuje 3,3 mld (8 ze 128 ekspertów). W RAM musi się zmieścić cały, za to na token przelicza tylko niewielką część wag. Dlatego na procesorze zwykle odpowiada wyraźnie szybciej niż gęsty qwen3:32b o podobnym rozmiarze pliku. Jeśli masz 32 GB RAM, sprawdź najpierw model MoE.
  • Kontekst kosztuje pamięć. Ollama domyślnie używa okna 4096 tokenów, nawet jeśli model obsługuje 128K. Większe okno ustawisz zmienną OLLAMA_CONTEXT_LENGTH, ale według FAQ Ollamy potrzebna pamięć rośnie z iloczynem OLLAMA_NUM_PARALLEL × OLLAMA_CONTEXT_LENGTH. Na małym serwerze zostaw jedno równoległe zapytanie i podnoś kontekst stopniowo, patrząc na ollama ps.

FAQ opisuje też kwantyzację pamięci kontekstu (OLLAMA_KV_CACHE_TYPE=q8_0 zajmuje ok. połowę pamięci domyślnego f16), ale działa ona tylko z włączonym Flash Attention (OLLAMA_FLASH_ATTENTION=1). Przy pierwszym uruchomieniu zostaw ustawienia domyślne.

Procesor, dysk i rodzaj vCPU

  • vCPU. Więcej rdzeni przyspiesza głównie przetwarzanie długiego promptu. Tempo generowania kolejnych tokenów zależy w dużej mierze od tego, jak szybko procesor czyta wagi z pamięci, więc dokładanie vCPU w pewnym momencie przestaje pomagać. Na VPS-ie ze współdzielonymi rdzeniami wynik potrafi się zmieniać w ciągu dnia, bo te same rdzenie obciążają inni klienci. Plan z dedykowanymi vCPU daje stabilniejsze tempo. Jak rozpoznać jedne i drugie w ofercie, opisuje poradnik o specyfikacji VPS.
  • Dysk. Modele leżą na dysku (w Dockerze w wolumenie montowanym jako /root/.ollama), więc do rozmiarów z tabeli doliczasz miejsce na system i obrazy. NVMe skraca ładowanie modelu do pamięci po restarcie.
  • Swap nie zastąpi RAM. Model, który ląduje częściowo w swapie, odpowiada skrajnie wolno. Lepiej wziąć mniejszy model albo plan z większą pamięcią.

Plany z dużą ilością RAM porównasz w rankingu VPS – dla Ollamy liczy się przede wszystkim kolumna z pamięcią. Niżej są tylko oferty z co najmniej 16 GB RAM.

Krok 1. Ollama w Dockerze

Zakładamy serwer przygotowany jak w poradniku od zera: użytkownik deploy z sudo, ufw i Docker z wtyczką Compose. Ollama ma też instalator dla Linuksa uruchamiany przez curl -fsSL https://ollama.com/install.sh | sh. To wykonanie skryptu z internetu z uprawnieniami roota, więc jeśli wybierzesz tę drogę, najpierw pobierz plik i go przeczytaj. Tu używamy oficjalnego obrazu Dockera.

bash
sudo mkdir -p /opt/apps/ollama && sudo chown deploy:deploy /opt/apps/ollama
cd /opt/apps/ollama

Plik compose.yaml:

yaml
services:
  ollama:
    image: ollama/ollama:latest
    restart: unless-stopped
    ports:
      - "127.0.0.1:11434:11434"
    environment:
      OLLAMA_KEEP_ALIVE: 30m
      OLLAMA_CONTEXT_LENGTH: 8192
      OLLAMA_NUM_PARALLEL: 1
      OLLAMA_MAX_LOADED_MODELS: 1
    volumes:
      - ollama:/root/.ollama
    mem_limit: 14g

volumes:
  ollama:

Co tu jest ważne:

  • Port tylko na 127.0.0.1. Obraz Ollamy ustawia w kontenerze OLLAMA_HOST=0.0.0.0:11434, a lokalne API Ollamy według dokumentacji nie wymaga uwierzytelnienia. Gdybyś opublikował port jako 11434:11434, każdy w internecie mógłby używać Twojego serwera i pobierać na nim modele. Opublikowane porty Dockera omijają reguły ufw – tak opisuje to dokumentacja Dockera – więc sama zapora tu nie pomoże.
  • OLLAMA_KEEP_ALIVE. Domyślnie model zostaje w pamięci 5 minut po ostatnim zapytaniu. 30 minut oszczędza ponownego ładowania między pytaniami, ale przez ten czas RAM jest zajęty.
  • OLLAMA_MAX_LOADED_MODELS: 1. Na CPU Ollama domyślnie trzyma w pamięci do trzech modeli naraz. Na VPS-ie z 16 GB to prosta droga do zabicia procesu przez brak pamięci.
  • mem_limit. Ustaw ok. 2 GB mniej niż RAM serwera (tu dla planu 16 GB). Gdy model się nie zmieści, padnie kontener, a nie cały serwer z SSH i innymi usługami.
  • latest. Na serwerze, od którego coś zależy, przypnij numer wersji z listy wydań i aktualizuj świadomie.
bash
docker compose up -d
docker compose logs --tail 20 ollama
curl -s http://127.0.0.1:11434/api/version
sudo ss -tlnp | grep 11434

Ostatnie polecenie musi pokazać 127.0.0.1:11434, a nie 0.0.0.0:11434.

Krok 2. Pobranie modelu

bash
docker compose exec ollama ollama pull qwen3:8b
docker compose exec ollama ollama list
docker compose exec ollama ollama run qwen3:8b

run otwiera rozmowę w terminalu – wyjdziesz z niej przez /bye. Zacznij od modelu wyraźnie mniejszego niż RAM. Jeśli działa, a tempo Ci odpowiada, spróbuj następnego rozmiaru.

Krok 3. Ile pamięci zajmuje i jak szybko liczy

bash
docker compose exec ollama ollama ps

Kolumna SIZE pokazuje, ile pamięci zajmuje załadowany model razem z kontekstem, a PROCESSOR – czy liczy na CPU (na VPS-ie bez karty: 100% CPU). Szybkość zmierzysz na API. Odpowiedź bez strumieniowania zawiera liczbę tokenów i czasy w nanosekundach:

bash
sudo apt -y install jq
curl -s http://127.0.0.1:11434/api/generate -d '{
  "model": "qwen3:8b",
  "prompt": "Wyjaśnij w trzech zdaniach, czym jest rekord DNS typu A.",
  "stream": false
}' | jq '{
  ladowanie_s: (.load_duration / 1e9),
  prompt_tok_s: (.prompt_eval_count / (.prompt_eval_duration / 1e9)),
  generowanie_tok_s: (.eval_count / (.eval_duration / 1e9))
}'
  • generowanie_tok_s to tempo pisania odpowiedzi – liczba, którą porównujesz między planami i modelami.
  • prompt_tok_s to tempo czytania wejścia. Przy długich dokumentach albo długiej historii rozmowy od tego zależy, ile czekasz na pierwsze słowo.
  • ladowanie_s jest duże tylko przy pierwszym zapytaniu po starcie albo po wygaśnięciu OLLAMA_KEEP_ALIVE.

Wyniki z cudzych testów niewiele powiedzą o Twoim serwerze, bo tempo zależy od procesora, pamięci i obciążenia hosta. Najtaniej sprawdzić to na serwerze rozliczanym za godzinę: postaw go, zmierz dwa–trzy modele, usuń. Do zadań w tle (streszczanie, klasyfikacja, tagowanie w nocy) wolne tempo zwykle nie przeszkadza. Do rozmowy na żywo oceń sam, czy czekanie Ci odpowiada.

Krok 4. Dostęp z zewnątrz bez otwierania API

Najprościej: tunel SSH. Z własnego komputera:

bash
ssh -N -L 11434:127.0.0.1:11434 deploy@203.0.113.10

Dopóki tunel działa, aplikacje na Twoim komputerze widzą Ollamę pod http://localhost:11434, a na serwerze nic więcej nie trzeba otwierać.

Dla aplikacji na innym serwerze: nginx z tokenem i HTTPS. Ollama ma interfejs zgodny z API OpenAI (/v1/chat/completions, /v1/models i inne). Klient OpenAI wysyła klucz w nagłówku Authorization: Bearer …, a lokalna Ollama ten klucz ignoruje. Sprawdzanie zostawiamy więc nginx-owi. Wygeneruj token i wpisz go w edytorze – nie przez echo, żeby nie został w historii powłoki:

bash
openssl rand -hex 32
sudo install -m 600 /dev/null /etc/nginx/conf.d/ollama-token.conf
sudo nano /etc/nginx/conf.d/ollama-token.conf

Treść pliku (w miejsce WKLEJ-TOKEN wstaw wynik openssl):

nginx
map $http_authorization $ollama_auth_ok {
    default 0;
    "Bearer WKLEJ-TOKEN" 1;
}

Plik /etc/nginx/sites-available/ollama.example.pl:

nginx
server {
    listen 80;
    listen [::]:80;
    server_name ollama.example.pl;

    client_max_body_size 20m;

    location / {
        if ($ollama_auth_ok = 0) {
            return 401;
        }
        proxy_pass http://127.0.0.1:11434;
        proxy_http_version 1.1;
        proxy_set_header Host localhost:11434;
        proxy_set_header Authorization "";
        proxy_buffering off;
        proxy_read_timeout 600s;
    }
}
bash
sudo ln -s /etc/nginx/sites-available/ollama.example.pl /etc/nginx/sites-enabled/
sudo nginx -t && sudo systemctl reload nginx
sudo certbot --nginx -d ollama.example.pl
  • Host localhost:11434 to nagłówek z przykładu konfiguracji nginx w FAQ Ollamy.
  • proxy_buffering off sprawia, że odpowiedź strumieniowana przychodzi na bieżąco, a nie w całości na końcu.
  • proxy_read_timeout 600s daje wolnemu modelowi czas na dłuższą odpowiedź, zanim nginx zwróci 504.
  • Do czasu wystawienia certyfikatu token szedłby otwartym tekstem, więc nie używaj adresu, dopóki certbot nie skończy.

Sprawdź oba przypadki:

bash
curl -s -o /dev/null -w '%{http_code}\n' https://ollama.example.pl/api/tags
curl -s -H "Authorization: Bearer WKLEJ-TOKEN" https://ollama.example.pl/v1/models

Pierwsze polecenie musi zwrócić 401. W kliencie OpenAI ustawiasz adres https://ollama.example.pl/v1/ i token jako klucz API. Token trzymaj jak hasło: z nim każdy może obciążyć Twój serwer. W ufw nie otwierasz portu 11434 – ruch idzie przez 443.

Wygodny interfejs czatu dla kilku osób, z kontami użytkowników, opisuje osobny poradnik Open WebUI z Ollamą.

Najczęstsze problemy

  • Kontener znika w trakcie odpowiedzi, a w dmesg jest „Out of memory”. Model z kontekstem nie mieści się w mem_limit albo w RAM. Weź mniejszy model, zmniejsz OLLAMA_CONTEXT_LENGTH albo plan z większą pamięcią.
  • Pierwsza odpowiedź po przerwie trwa dużo dłużej. Model został wyładowany po czasie z OLLAMA_KEEP_ALIVE i ładuje się od nowa – widać to w ladowanie_s.
  • Odpowiedzi ucinają się albo model „zapomina” początek długiej rozmowy. Rozmowa przekroczyła okno kontekstu (domyślnie 4096 tokenów). Podnieś OLLAMA_CONTEXT_LENGTH i sprawdź w ollama ps, ile to kosztuje pamięci.
  • Tempo raz dobre, raz bardzo słabe. Typowe na współdzielonych vCPU. Zmierz o różnych porach albo przejdź na plan z dedykowanymi rdzeniami.
  • Dysk się zapełnia. Usuń nieużywane modele: docker compose exec ollama ollama rm nazwa:tag.

Kiedy CPU nie wystarczy

Gdy potrzebujesz modelu 70B, wielu użytkowników naraz albo szybkiej rozmowy z dużym modelem, VPS bez karty przestaje być rozsądny. Zostają dwie drogi: płacić za tokeny w API (rachunek liczy poradnik ile kosztuje API modeli AI) albo wynajmować kartę na godziny (GPU w chmurze).

Źródła

Sprawdzone 12.11.2026:

Powiązane poradniki