llama.cpp server draaien op een VPS: handleiding
Leer hoe u llama.cpp compileert vanaf een specifieke tag, GGUF-modellen serveert via de OpenAI API en de server beheert met systemd inclusief strikte geheugenlimieten.
Wat u bouwt
Het draaien van de llama.cpp server op een VPS betekent één binary, llama-server, die een enkel GGUF-modelbestand laadt en HTTP-verzoeken beantwoordt via een OpenAI-compatibele API. Wijs een compatibele client naar http://127.0.0.1:8080/v1 en test vervolgens de functies die uw applicatie gebruikt: de compatibiliteit is gedeeltelijk. De installatie is het eenvoudige deel.
Het overige werk betreft beheer: zet een versie vast, houd de poort op localhost, schrijf een systemd-unit en bepaal wat er gebeurt wanneer het geheugen van de server opraakt. Dat is wat deze handleiding behandelt. Als u nog niet heeft gekozen tussen de twee voor de hand liggende opties, lees dan eerst de afwegingen tussen Ollama en llama.cpp, omdat dit de handleiding is die die vergelijking bewust weglaat.
Kies een release-tag en noteer deze
llama.cpp gebruikt build-nummer-tags zoals b10488 voor nightly development-builds en semantische versietags, vX.Y.Z, voor officiële releases. b10488 is de vastgezette build die hier wordt gebruikt, uitgebracht op 18 augustus 2026. "Latest" is een bewegend doel en de versie die u heeft getest is de enige versie die u kunt ondersteunen. Kies een tag, noteer deze en gebruik diezelfde string in uw clone, in uw binairienaam en in uw notities.
De b10488-tag bevat ook vooraf gebouwde archieven. Voor een CPU-only x86 VPS is dat llama-b10488-bin-ubuntu-x64.tar.gz, en een arm64-archief staat daarnaast als u zich op een ARM VPS in plaats van x86 bevindt.
curl -LO https://github.com/ggml-org/llama.cpp/releases/download/b10488/llama-b10488-bin-ubuntu-x64.tar.gz
tar tf llama-b10488-bin-ubuntu-x64.tar.gz | headBekijk de inhoud van het archief voordat u het uitpakt, zodat u weet waar de bestanden terechtkomen. Deze binaries zijn gelinkt aan de C-library van de image waarmee ze zijn gebouwd. Op een oudere distributie falen ze daarom bij het opstarten met een foutmelding die een GLIBC_-versie noemt die niet is geïnstalleerd. Bouwen vanuit de broncode duurt enkele minuten op een kleine VPS en elimineert die hele categorie problemen; daarom wordt hieronder die methode gevolgd.
llama-server bouwen vanaf een vastgezette tag
sudo apt update
sudo apt install -y build-essential cmake git libssl-dev
git clone --depth 1 --branch b10488 https://github.com/ggml-org/llama.cpp
cd llama.cpp
cmake -B build -DCMAKE_BUILD_TYPE=Release -DBUILD_SHARED_LIBS=OFF -DLLAMA_BUILD_TESTS=OFF -DLLAMA_BUILD_EXAMPLES=OFF
cmake --build build --config Release -t llama-server -j 2--branch b10488 op een --depth 1-kloon checkt uitsluitend die tag uit, waardoor de build niet kan afwijken terwijl u eraan werkt.
libssl-dev is van belang omdat de optie LLAMA_OPENSSL standaard is ingeschakeld; hiermee kan het binaire bestand later modellen downloaden via HTTPS. Zonder OpenSSL-ontwikkelbestanden waarschuwt deze vastgezette build dat HTTPS-ondersteuning is uitgeschakeld, in plaats van dat de configuratie faalt.
-DBUILD_SHARED_LIBS=OFF linkt llama.cpp en GGML in het uitvoerbare bestand; afhankelijkheden van systeembibliotheken blijven bestaan. De standaard build plaatst gedeelde bibliotheken naast het uitvoerbare bestand, dus het kopiëren van alleen het uitvoerbare bestand naar /usr/local/bin resulteert vervolgens in error while loading shared libraries: libllama.so.
-t llama-server bouwt alleen het server-doel. De standaard build compileert ook de overige tools en tests, wat op een VPS met twee cores enkele extra minuten kost voor bestanden die u nooit zult uitvoeren.
-j 2 is een bewuste keuze. Elke parallelle compileer-taak houdt zijn eigen werkset vast, waardoor -j $(nproc) op een klein abonnement eindigt met c++: fatal error: Killed signal terminated program cc1plus; dit is de out-of-memory killer van de kernel die de compiler stopt. Verlaag het aantal taken of voeg swap toe voor de build.
Een vlag die u wellicht wilt wijzigen: GGML_NATIVE staat standaard aan, waardoor de compiler zich richt op de specifieke CPU die de build uitvoert. Dat is gewenst wanneer u bouwt op de machine die de software ook gaat draaien. Als u eenmalig bouwt en het binaire bestand naar een andere host kopieert, voeg dan -DGGML_NATIVE=OFF toe, omdat een binair bestand dat instructies gebruikt die de andere CPU niet ondersteunt, crasht met Illegal instruction (core dumped) bij de eerste inferentie.
Installeer het onder een naam die de tag bevat.
./build/bin/llama-server --version
sudo install -m 755 build/bin/llama-server /usr/local/bin/llama-server-b10488
sudo ln -sfn /usr/local/bin/llama-server-b10488 /usr/local/bin/llama-server--version toont het buildnummer en de commit. Dit moet overeenkomen met de tag die u heeft uitgecheckt. Als dit niet het geval is, heeft u iets anders gebouwd. Door het nummer in de bestandsnaam te behouden en er met een symlink naar te verwijzen, is een upgrade slechts één ln -sfn plus een herstart, en een rollback is hetzelfde commando met het oude nummer.
Een GGUF-model ophalen en eerst de schijfruimte controleren
GGUF is het bestandsformaat dat door llama.cpp wordt geladen. Eén bestand bevat de gewichten, de tokenizer en de metadata, waardoor er geen verdere installatie nodig is. Het achtervoegsel in de bestandsnaam duidt de kwantisatie aan, oftewel de precisie waarin de gewichten zijn opgeslagen: Q4_K_M is een 4-bit mix, Q8_0 is 8-bit en f16 is het ongekwantiseerde half-precisiebestand.
Maak een service-account en een modelmap aan voordat u iets downloadt.
sudo useradd --system --home /srv/llama --create-home --shell /usr/sbin/nologin llama
sudo install -d -o llama -g llama /srv/models
df -h /srvDe server kan zelf een model ophalen met -hf; dit is de snelste manier om te verifiëren of uw build correct werkt.
sudo -u llama env LLAMA_CACHE=/srv/models /usr/local/bin/llama-server \
-hf ggml-org/gemma-3-1b-it-GGUF:Q4_K_M --host 127.0.0.1 --port 8080LLAMA_CACHE stelt de downloadmap in. Zonder deze vlag of XDG_CACHE_HOME wordt het bestand opgeslagen in ~/.cache/llama.cpp onder het account dat het commando uitvoerde; de onderstaande unit maakt /srv/llama alleen-lezen. Voer daarna ls -lh /srv/models uit, omdat de gecachte bestandsnaam is afgeleid van de repositorynaam in plaats van de oorspronkelijke bestandsnaam.
Voor een service downloadt u naar een pad naar keuze, zodat het unit-bestand naar een stabiele locatie kan verwijzen.
sudo -u llama curl -L --output-dir /srv/models -O \
https://huggingface.co/ggml-org/gemma-3-1b-it-GGUF/resolve/main/gemma-3-1b-it-Q4_K_M.ggufSchijfruimte is de beperking waar men het eerst tegenaan loopt. Dit zijn de gepubliceerde bestandsgroottes voor twee modellen, gecontroleerd op 18 augustus 2026.
De gegevens achter deze grafiek
[
{
"label": "gemma-3-1b-it Q4_K_M",
"size_gb": 0.81
},
{
"label": "gemma-3-1b-it Q8_0",
"size_gb": 1.07
},
{
"label": "gemma-3-1b-it f16",
"size_gb": 2.01
},
{
"label": "gpt-oss-20b MXFP4",
"size_gb": 12.11
}
]Het 4-bit bestand voor het 1B-model is 0.81 GB. Hetzelfde model zonder kwantisatie is 2.01 GB; de keuze voor het formaat zorgt dus voor een verschil van meer dan een factor twee. Een 20B-model in MXFP4 is 12.11 GB, en dit moet daarna nog in het geheugen worden geladen. Als u een specifieke familie op het oog heeft, laat dezelfde omvangsberekening voor GLM zien hoe snel het topmodel te duur wordt voor een VPS, terwijl een kleiner model wel past.
Controleer df -h vóór elke download. Een root-bestandssysteem dat volloopt tijdens een overdracht van 12 GB verstoort alle andere processen die naar de schijf moeten schrijven, inclusief de journal.
Voer het handmatig eenmaal uit en controleer het
sudo -u llama /usr/local/bin/llama-server \
--model /srv/models/gemma-3-1b-it-Q4_K_M.gguf \
--host 127.0.0.1 --port 8080 \
--ctx-size 4096 --parallel 1 --threads 2 --no-webuiVraag in een tweede sessie aan de server of deze gereed is.
curl -s http://127.0.0.1:8080/healthTerwijl het bestand wordt geladen, ontvangt u een HTTP 503-foutmelding met de volgende body:
{"error":{"code":503,"message":"Loading model","type":"unavailable_error"}}Wanneer de server gereed is, is de body {"status": "ok" }. Verstuur daarna een daadwerkelijk verzoek.
curl -s http://127.0.0.1:8080/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{"model":"local","messages":[{"role":"user","content":"Say hello in five words."}]}'Een JSON-object met een choices-array duidt op een werkende server. Het model-veld is aanwezig omdat OpenAI-clients dit altijd meesturen. Deze server heeft één model geladen, dus de waarde wordt niet gebruikt voor selectiedoeleinden.
De OpenAI-compatibele API en wat er nog meer op de poort draait
POST /v1/chat/completions, POST /v1/completions, POST /v1/responses en POST /v1/embeddings zijn OpenAI-compatibele routes, en GET /v1/models rapporteert het geladen model. Embeddings vereisen een model met een andere pooling dan none. GET /health is de hierboven genoemde readiness-check, GET /props geeft de huidige instellingen van de server terug, en GET /metrics stelt Prometheus-tellers beschikbaar wanneer u start met --metrics.
Voor compatibele OpenAI SDK-aanroepen stelt u de base URL in op http://127.0.0.1:8080/v1 en verstrekt u een niet-lege API-key string als de SDK dit vereist. Dit garandeert geen compatibiliteit met elke SDK-functie. Niets controleert die key totdat u zelf --api-key of --api-key-file instelt.
Neem de doorvoersnelheid van anderen niet over als maatstaf voor uw eigen plan. De snelheid van CPU-inferentie hangt af van het aantal cores, de geheugenbandbreedte en de buren waarmee u de host deelt. Meet daarom zelf het aantal tokens per seconde op uw eigen machine en beschouw dat resultaat als de waarheid. Steal time van een luidruchtige buur uit zich hier als generatiesnelheid die van uur tot uur varieert.
Houd het op 127.0.0.1 en plaats een proxy ervoor
--host staat standaard al op 127.0.0.1, waardoor de server van buitenaf onbereikbaar is totdat u dit wijzigt. Laat dit ongewijzigd. Gebruik de proxy voor gebruikersaccounts, het beperken van de aanvraagsnelheid (rate limiting) en audit-logging; ingebouwde API-authenticatie maakt gebruik van statische sleutels: --api-key accepteert één sleutel of een door komma's gescheiden lijst, en --api-key-file leest één sleutel per regel. Een open inference-poort is gratis rekenkracht voor iedereen die deze vindt, en dezelfde fout bij Ollama heeft dezelfde gevolgen: het beveiligen van een zelfgehoste model-API is hier regel voor regel van toepassing.
Beëindig TLS (transport layer security) in nginx en proxy naar de loopback-poort.
server {
listen 443 ssl;
server_name llm.example.com;
location /v1/ {
proxy_pass http://127.0.0.1:8080;
proxy_http_version 1.1;
proxy_set_header Connection "";
proxy_buffering off;
proxy_read_timeout 600s;
}
}proxy_buffering off geeft streaming-antwoorden door aan de client zodra nginx deze ontvangt. Met buffering ingeschakeld buffert nginx upstream-data in plaats van elk event direct door te sturen. proxy_read_timeout 600s biedt ruimte voor trage antwoorden. Dit is de maximale tijd die nginx wacht tussen twee leesacties vanaf de server, niet een limiet voor het gehele antwoord. Bij de standaardwaarde van 60 seconden treedt er een time-out op voor een niet-streaming verzoek dat gedurende dat interval niets verstuurt. In b10488 sturen streaming-antwoorden standaard elke 30 seconden SSE keepalive-pings, ook tijdens het verwerken van lange prompts. Verkrijg het certificaat via Certbot en Let's Encrypt op nginx.
De systemd unit
Schrijf /etc/systemd/system/llama-server.service.
[Unit]
Description=llama.cpp server
After=network-online.target
Wants=network-online.target
[Service]
User=llama
Group=llama
Environment=LLAMA_ARG_MODEL=/srv/models/gemma-3-1b-it-Q4_K_M.gguf
Environment=LLAMA_ARG_HOST=127.0.0.1
Environment=LLAMA_ARG_PORT=8080
Environment=LLAMA_ARG_CTX_SIZE=4096
Environment=LLAMA_ARG_N_PARALLEL=1
Environment=LLAMA_ARG_THREADS=2
ExecStart=/usr/local/bin/llama-server --no-webui
Restart=on-failure
RestartSec=5
TimeoutStopSec=30
MemoryHigh=3G
MemoryMax=3500M
OOMPolicy=stop
NoNewPrivileges=yes
PrivateTmp=yes
ProtectSystem=strict
ProtectHome=yes
[Install]
WantedBy=multi-user.targetDe instellingen staan in Environment=-regels omdat llama-server voor de meeste vlaggen LLAMA_ARG_*-variabelen inleest, waarbij een opdrachtregelargument de overeenkomstige variabele overschrijft. Dit biedt één centrale plek om de contextgrootte aan te passen en houdt ExecStart kort genoeg om in één oogopslag te kunnen lezen.
ProtectSystem=strict maakt het bestandssysteem voor deze unit alleen-lezen, met uitzonderingen zoals de private tijdelijke mappen, wat acceptabel is omdat de server het model alleen leest. Voeg ReadWritePaths=/srv/models en Environment=LLAMA_CACHE=/srv/models toe als u wilt dat de service zelf modellen downloadt met -hf. ProtectHome=yes verbergt /home, /root en /run/user; het verbergt niet de home-map van dit service-account op /srv/llama, maar ProtectSystem=strict maakt die map alleen-lezen.
sudo systemctl daemon-reload
sudo systemctl enable --now llama-server
systemctl status llama-server
curl -s http://127.0.0.1:8080/health
journalctl -u llama-server -n 50 --no-pagerenable --now is het onderdeel dat mensen vaak overslaan. Zonder enable is de server na de volgende herstart verdwenen. Als u geplande taken rondom de service wilt uitvoeren, zoals een dagelijkse controle op een nieuwe release, is een systemd service plus timer het juiste mechanisme daarvoor.
Bepaal wat er bij OOM gebeurt voordat het zover is
Geheugengebruik bestaat uit twee delen die verschillend reageren onder een limiet. Het modelbestand wordt standaard via memory-mapping geladen, waardoor de pagina's file-backed zijn: de kernel kan deze verwijderen en opnieuw inlezen vanaf de schijf. De KV cache, de per-token status die de server bijhoudt voor elke actieve conversatie, is anoniem geheugen. Dit kan niet worden verwijderd, waardoor dit de reden is dat het proces wordt beëindigd.
Daarom hebben de twee limieten in de unit verschillende functies. MemoryHigh=3G is een soft limit: daarboven zet de kernel de cgroup onder reclaim-druk, waardoor gemapte modelpagina's worden verwijderd en bij het volgende token vanaf de schijf worden ingelezen. De service blijft werken, maar wordt trager. MemoryMax=3500M is het harde plafond: de kernel probeert eerst alles te reclaimen wat mogelijk is, en als het gebruik dan nog steeds niet onder de limiet kan worden gehouden, voert de OOM killer de actie uit binnen de unit, wat duidelijk in de journal wordt vermeld.
llama-server.service: A process of this unit has been killed by the OOM killer.Stel --ctx-size zelf in. De standaardwaarde is 0, wat staat voor de context waarmee het model is getraind; bij een modern long-context model resulteert dit bij het opstarten in een zeer grote KV cache. De service sterft vervolgens voordat deze een enkel verzoek kan verwerken. --parallel vermenigvuldigt die kosten niet uit zichzelf: --ctx-size stelt de totale grootte van de KV cache in, gedeeld door alle slots, dus --ctx-size 4096 --parallel 4 geeft elke conversatie ongeveer 1.024 tokens in plaats van vier keer het geheugen. Elk slot de volledige context geven betekent --ctx-size vermenigvuldigen met het aantal slots, waardoor het geheugengebruik toeneemt. Laat --parallel daarom op 1 staan totdat u zeker weet dat u concurrency nodig heeft.
Met Restart=on-failure komt een beëindigde service weer terug. Systemd stopt met herstarten via start request repeated too quickly alleen wanneer het aantal starts de geconfigureerde limiet overschrijdt; de herstartvertraging van vijf seconden bereikt hier niet de standaardlimiet van vijf starts in tien seconden. Stop een aanhoudende herstartlus met sudo systemctl stop llama-server, corrigeer de limiet of de contextgrootte, wis daarna de foutstatus met sudo systemctl reset-failed llama-server en start de service opnieuw.
Monitor het werkelijke getal met systemctl show llama-server -p MemoryCurrent terwijl een verzoek wordt verwerkt. Geheugen- en CPU-limieten voor processen instellen met systemd behandelt deze richtlijnen in meer detail.
Vermijd swap voor deze workload. Een geswapt model verandert elk token in willekeurige schijf-reads. Memory-mapping van het modelbestand bereikt hetzelfde effect met minder schade, omdat de kernel de benodigde pagina's direct uit het bestand leest.
Wanneer Ollama de betere keuze is
Dit is een keuze tussen twee paden. Kies llama-server wanneer u één proces wilt met door u ingestelde flags, een build die u heeft vastgezet en een bestand dat u heeft gekozen, waarbij niets onverwacht verandert omdat er niets anders op de achtergrond draait.
Kies Ollama wanneer u modelbeheer wilt: modellen ophalen op naam, er meerdere op schijf bewaren, een inactief model ontladen en upgraden met één enkel commando in plaats van een herbouw. Dit is echt werk dat u anders zelf zou moeten scripten. Ollama draaien op een VPS is dezelfde taak met de afweging in de andere richting gemaakt. Beide bieden een OpenAI-compatibele API, maar test de endpoints en functies die uw client gebruikt voordat u in een van beide richtingen overstapt.
Upgraden van een vastgezette build
Vervang bNNNNN door de nightly build-tag waarnaar u overstapt; officiële release-tags gebruiken in plaats daarvan vX.Y.Z.
cd llama.cpp
git fetch --tags
git checkout bNNNNN
cmake -B build -DCMAKE_BUILD_TYPE=Release -DBUILD_SHARED_LIBS=OFF -DLLAMA_BUILD_TESTS=OFF -DLLAMA_BUILD_EXAMPLES=OFF
cmake --build build --config Release -t llama-server -j 2
sudo install -m 755 build/bin/llama-server /usr/local/bin/llama-server-bNNNNN
sudo ln -sfn /usr/local/bin/llama-server-bNNNNN /usr/local/bin/llama-server
sudo systemctl restart llama-serverHet oude binaire bestand blijft op de schijf staan, waardoor een rollback slechts één ln -sfn naar llama-server-b10488 en één herstart vereist. Lees de release notes voordat u de overstap maakt. GGUF-bestanden zijn voorzien van versienummers, maar achterwaartse compatibiliteit is niet universeel: de huidige loader weigert GGUFv1. Flags worden ook hernoemd: in b10488 waren --mlock en --no-mmap al verouderd ten gunste van --load-mode, en sinds 11 oktober 2026 vermeldt de huidige serverdocumentatie deze niet meer. Een unit-bestand dat een verwijderde flag doorgeeft, zal daarom bij het opstarten falen met een melding over een niet-herkend argument. Standaardinstellingen wijzigen ook: huidige builds luisteren standaard op poort 9931, waar b10488 poort 8080 gebruikte. Daarom stellen elk commando en de unit in dit document de poort expliciet in.
Foutmodi en de meldingen die u zult zien
error while loading shared libraries: libllama.so nadat u het binaire bestand naar een andere locatie hebt gekopieerd. De standaard build genereert gedeelde bibliotheken naast het bestand. Bouw opnieuw met -DBUILD_SHARED_LIBS=OFF, of kopieer de volledige build/bin-directory.
Illegal instruction (core dumped) bij het opstarten of bij het eerste verzoek. Het binaire bestand is gecompileerd met GGML_NATIVE ingeschakeld, voor een andere CPU dan de huidige machine. Bouw opnieuw op deze machine, of configureer met -DGGML_NATIVE=OFF.
c++: fatal error: Killed signal terminated program cc1plus tijdens het build-proces. De compiler is beëindigd omdat deze te veel geheugen verbruikte. Verlaag -j, of voeg tijdelijk swap toe voor de build en verwijder deze daarna weer.
curl: (7) Failed to connect ... Connection refused vanaf uw laptop. Dit is correct: de server luistert op het loopback-adres van de VPS. Test op de VPS zelf, of open een tunnel met ssh -L 8080:127.0.0.1:8080 user@your-vps en gebruik http://127.0.0.1:8080 lokaal.
HTTP 503 met "message":"Loading model" gedurende de eerste seconden of minuten na een herstart. Het inlezen van een bestand van meerdere gigabytes kost tijd, en systemd rapporteert de unit als actief zodra het proces start, nog voordat het model in het geheugen is geladen.
Verzoeken blijven hangen en retourneren vervolgens 504 Gateway Time-out. De server heeft gedurende langere tijd dan proxy_read_timeout niets verzonden, wat kan gebeuren bij niet-streaming verzoeken. Streaming verzoeken in b10488 sturen standaard elke 30 seconden keepalive-pings tijdens het verwerken van lange prompts. Verhoog proxy_read_timeout en schakel proxy_buffering uit zodat tokens de client bereiken zodra ze worden gegenereerd.
De unit flappert en stopt vervolgens met start request repeated too quickly. Het aantal starts heeft de geconfigureerde limiet overschreden. Controleer journalctl -u llama-server op de OOM-killer-regel, verlaag daarna --ctx-size of verhoog MemoryMax.
FAQ
Moet ik de server van llama.cpp of Ollama draaien op mijn VPS?
Draai llama-server wanneer u een specifieke build wilt vastzetten, exacte flags wilt meegeven en één model in één bestand wilt behouden dat niet ongemerkt wordt bijgewerkt. Draai Ollama wanneer u behoefte heeft aan modelbeheer en upgrades met één commando; het ophalen van modellen op naam, het opslaan van meerdere modellen op schijf en het ontladen van inactieve modellen is werk dat u anders zelf zou moeten scripten. Beide bieden een OpenAI-compatibele API, maar overstappen vereist dat u controleert welke endpoints en functies uw client gebruikt.
Aan welke versie van llama.cpp moet ik mijn installatie vastzetten?
Aan elke tag die u daadwerkelijk heeft gebouwd en getest. Nightly development-builds gebruiken build-nummer-tags zoals b10488, uitgebracht op 18 augustus 2026; officiële releases gebruiken semantische versietags, vX.Y.Z. Kloon met --branch <tag>, installeer het binaire bestand onder een bestandsnaam die die tag bevat en laat een symlink daarnaar verwijzen, zodat een upgrade en een rollback elk slechts één commando kosten.
Hoeveel RAM heeft llama-server nodig?
Begin bij de grootte van het GGUF-bestand en voeg daar de KV-cache aan toe, die groeit met --ctx-size. Dat cijfer is het totale tokenbudget dat wordt gedeeld door alle --parallel slots; meer slots vereisen dus een grotere --ctx-size als elk slot dezelfde context moet behouden. Gepubliceerde cijfers zijn geen vervanging voor het meten van uw eigen configuratie, omdat het totaal afhangt van het model, de kwantisatie en de context die u toestaat. Voer systemctl show llama-server -p MemoryCurrent uit terwijl een verzoek wordt verwerkt en gebruik het getal dat u ziet.
Waarom geeft /health een 503-fout met "Loading model"?
Het proces is gestart, maar het modelbestand staat nog niet in het geheugen, dus de server antwoordt met {"error":{"code":503,"message":"Loading model","type":"unavailable_error"}}. Dit is normaal na elke herstart en duurt zolang als het inlezen van het bestand in beslag neemt. Het wordt pas een probleem wanneer een client of proxy die eerste 503 als een definitieve fout beschouwt. Pols /health totdat deze {"status": "ok" } teruggeeft.
Kan ik llama-server rechtstreeks blootstellen aan het internet?
Bind de server niet aan 0.0.0.0 en open de poort niet. Gebruik de proxy voor accounts, rate limiting voor verzoeken en audit-logging; ingebouwde API-authenticatie gebruikt statische sleutels die worden ingesteld met --api-key of --api-key-file. Houd de standaard 127.0.0.1 bind aan, plaats nginx ervoor met TLS en stel ook --api-key in, zodat een fout in de proxy-configuratie het model niet voor iedereen toegankelijk maakt.