Installer llama.cpp sur un VPS avec systemd
Compilez llama.cpp au tag b10488, servez un modèle GGUF via l’API OpenAI, limitez l’écoute à localhost et gérez la mémoire avec systemd.
Ce que vous allez mettre en place
Exécuter le serveur llama.cpp sur un VPS revient à utiliser un seul binaire, llama-server, qui charge un fichier de modèle GGUF unique et répond aux requêtes HTTP via une API compatible avec OpenAI. Configurez un client compatible pour utiliser http://127.0.0.1:8080/v1, puis testez les fonctionnalités utilisées par votre application : la compatibilité est partielle. L’installation est la partie la plus simple.
Le reste relève de l’exploitation : figer une version, limiter le port à localhost, créer une unité systemd et décider du comportement lorsque la machine manque de mémoire. C’est ce que couvre ce guide. Si vous n’avez pas encore choisi entre les deux options évidentes, lisez d’abord la comparaison entre Ollama et llama.cpp, car ce guide pratique laisse volontairement de côté les éléments abordés dans cette comparaison.
Choisir un tag de release et le noter
llama.cpp utilise des tags correspondant au numéro de build, comme b10488, pour les builds de développement nightly, ainsi que des tags de version sémantique, vX.Y.Z, pour les releases officielles. b10488 est le build figé utilisé ici, publié le 18 August 2026. « Latest » évolue en permanence, et vous ne pouvez prendre en charge que la version que vous avez testée. Choisissez un tag, notez-le et utilisez exactement cette chaîne dans votre clone, dans le nom de votre binaire et dans vos notes.
Le tag b10488 fournit également des archives précompilées. Pour un VPS x86 sans support CPU, il s’agit de llama-b10488-bin-ubuntu-x64.tar.gz. Une archive arm64 se trouve à côté si vous utilisez un VPS ARM plutôt qu’un VPS x86.
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 | headListez l’archive avant de l’extraire afin de savoir où les fichiers seront installés. Ces binaires sont liés à la bibliothèque C de l’image qui les a compilés. Sur une distribution plus ancienne, ils échouent donc au démarrage avec une erreur mentionnant une version de GLIBC_ qui n’est pas installée. La compilation depuis les sources prend quelques minutes sur un petit VPS et élimine entièrement cette catégorie de problèmes. C’est donc la méthode présentée ci-dessous.
Compiler llama-server à partir d’un tag figé
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 sur un clone --depth 1 extrait ce tag et rien d’autre. La compilation ne peut donc pas dériver pendant que vous travaillez.
libssl-dev est important, car l’option LLAMA_OPENSSL est activée par défaut. Elle permet ensuite au binaire de télécharger des modèles via HTTPS. Sans les fichiers de développement OpenSSL, cette compilation figée avertit que la prise en charge de HTTPS est désactivée au lieu d’échouer pendant la configuration.
-DBUILD_SHARED_LIBS=OFF lie llama.cpp et GGML à l’exécutable. Les dépendances des bibliothèques système restent nécessaires. La compilation par défaut place les bibliothèques partagées à côté de l’exécutable. Copier uniquement l’exécutable vers /usr/local/bin échoue donc avec error while loading shared libraries: libllama.so.
-t llama-server compile uniquement la cible du serveur. La compilation par défaut compile aussi les autres outils et les tests. Sur un VPS à deux cœurs, cela ajoute plusieurs minutes pour des fichiers que vous n’exécuterez jamais.
-j 2 est volontaire. Chaque tâche de compilation parallèle conserve son propre jeu de travail. Ainsi, -j $(nproc) sur une petite offre finit par c++: fatal error: Killed signal terminated program cc1plus : c’est l’out-of-memory killer du kernel qui arrête le compilateur. Réduisez le nombre de tâches ou ajoutez du swap pour la compilation.
Vous pouvez modifier un flag : GGML_NATIVE est activé par défaut. Le compilateur cible donc exactement le CPU qui effectue la compilation. C’est ce qu’il faut lorsque vous compilez sur la machine qui exécutera le binaire. Si vous compilez une fois puis copiez le binaire vers un autre hôte, ajoutez -DGGML_NATIVE=OFF, car un binaire utilisant des instructions absentes de l’autre CPU s’arrête avec Illegal instruction (core dumped) dès la première inférence.
Installez-le sous un nom qui contient le tag.
./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 affiche le numéro de build et le commit. Ils doivent correspondre au tag extrait. Si ce n’est pas le cas, vous avez compilé autre chose. Conserver le numéro dans le nom du fichier et pointer un symlink vers celui-ci permet d’effectuer une mise à niveau avec un ln -sfn et un redémarrage. Pour revenir en arrière, utilisez la même commande avec l’ancien numéro.
Téléchargez un modèle GGUF et vérifiez d’abord l’espace disque
GGUF est le seul format de fichier chargé par llama.cpp. Un fichier contient les poids, le tokenizer et les métadonnées. Il n’y a donc rien d’autre à installer. Le suffixe du nom de fichier indique la quantification, c’est-à-dire la précision utilisée pour stocker les poids : Q4_K_M est un mélange en 4 bits, Q8_0 utilise 8 bits et f16 est le fichier non quantifié en demi-précision.
Créez un compte de service et un répertoire pour les modèles avant tout téléchargement.
sudo useradd --system --home /srv/llama --create-home --shell /usr/sbin/nologin llama
sudo install -d -o llama -g llama /srv/models
df -h /srvLe serveur peut télécharger lui-même un modèle avec -hf. C’est le moyen le plus rapide de vérifier que votre build fonctionne.
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 définit le répertoire de téléchargement. Sans cette option ou XDG_CACHE_HOME, le fichier est placé dans ~/.cache/llama.cpp sous le compte qui a exécuté la commande. L’unité ci-dessous rend /srv/llama accessible en lecture seule. Exécutez ensuite ls -lh /srv/models, car le nom du fichier en cache est dérivé du nom du repository et non du nom de fichier simple.
Pour un service, téléchargez le modèle vers le chemin de votre choix. Le fichier d’unité pourra ainsi utiliser un chemin stable.
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.ggufL’espace disque est la première limite rencontrée. Voici les tailles de fichiers publiées pour deux modèles, vérifiées le 18 août 2026.
Les données de ce graphique
[
{
"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
}
]Le fichier en 4 bits du modèle 1B fait 0.81 Go. Le même modèle sans quantification fait 2.01 Go. Le choix du format modifie donc la taille de plus d’un facteur deux. Un modèle 20B en MXFP4 fait 12.11 Go. Il doit ensuite être chargé en mémoire. Si vous ciblez une famille précise, le même calcul de taille pour GLM montre à quelle vitesse le modèle principal devient trop coûteux pour un VPS alors qu’un modèle plus petit reste compatible.
Vérifiez df -h avant chaque téléchargement. Un système de fichiers root qui se remplit pendant le transfert de 12 Go empêche toute autre écriture, notamment celle du journal.
Exécutez-le une fois manuellement, puis vérifiez-le
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-webuiDans une deuxième session, demandez au serveur s’il est prêt.
curl -s http://127.0.0.1:8080/healthPendant le chargement du fichier, vous obtenez une réponse HTTP 503 avec ce corps :
{"error":{"code":503,"message":"Loading model","type":"unavailable_error"}}Lorsqu’il est prêt, le corps est {"status": "ok" }. Envoyez ensuite une requête réelle.
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."}]}'Un objet JSON contenant un tableau choices indique que le serveur fonctionne. Le champ model est présent parce que les clients OpenAI l’envoient toujours. Ce serveur n’a chargé qu’un seul modèle ; cette valeur ne sert donc pas à en sélectionner un.
L’API compatible avec OpenAI et les autres éléments disponibles sur le port
POST /v1/chat/completions, POST /v1/completions, POST /v1/responses et POST /v1/embeddings sont des routes compatibles avec OpenAI, tandis que GET /v1/models indique le modèle chargé. Les embeddings nécessitent un modèle dont le pooling est différent de none. GET /health correspond au contrôle de disponibilité présenté plus haut, GET /props renvoie les paramètres actuels du serveur et GET /metrics expose les compteurs Prometheus lorsque vous démarrez avec --metrics.
Pour les appels effectués avec un SDK OpenAI compatible, définissez l’URL de base sur http://127.0.0.1:8080/v1 et fournissez une chaîne non vide comme clé API si le SDK l’exige. Cela ne garantit pas la compatibilité avec toutes les fonctionnalités du SDK. Aucune vérification ne porte sur cette clé tant que vous n’avez pas configuré vous-même --api-key ou --api-key-file.
Ne prenez pas la valeur de débit annoncée par quelqu’un d’autre comme référence pour votre propre configuration. La vitesse d’inférence sur CPU dépend du nombre de cœurs, de la bande passante mémoire et des autres utilisateurs avec lesquels vous partagez l’hôte. Mesurez donc le nombre de tokens par seconde sur votre propre machine et considérez ce résultat comme la référence. Le steal time causé par un voisin bruyant se manifeste ici par une vitesse de génération qui varie d’une heure à l’autre.
Conservez l’écoute sur 127.0.0.1 et placez un proxy en amont
--host utilise déjà 127.0.0.1 par défaut. Le serveur est donc inaccessible depuis l’extérieur tant que vous ne modifiez pas ce paramètre. Ne le modifiez pas. Utilisez le proxy pour les comptes utilisateur, les limites de débit des requêtes et la journalisation d’audit. L’authentification intégrée de l’API utilise des clés statiques : --api-key accepte une clé ou une liste de clés séparées par des virgules, et --api-key-file lit une clé par ligne. Un port d’inférence ouvert fournit gratuitement de la capacité de calcul à quiconque le découvre. La même erreur avec Ollama a la même forme : sécuriser une API de modèle auto-hébergée s’applique ici à l’identique.
Terminez TLS (transport layer security) dans nginx, puis transmettez les requêtes au port loopback.
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 transmet les réponses en streaming au client à mesure que nginx les reçoit. Lorsque la mise en tampon est activée, nginx met en tampon les données du serveur en amont au lieu de transmettre immédiatement chaque événement. proxy_read_timeout 600s laisse suffisamment de temps aux réponses lentes. Il s’agit du délai maximal entre deux lectures effectuées par nginx auprès du serveur, et non d’une limite sur la durée totale de la réponse. Avec la valeur par défaut de 60 secondes, une requête sans streaming qui n’envoie rien pendant cet intervalle expire. Dans b10488, les réponses en streaming envoient par défaut des pings SSE de maintien de connexion toutes les 30 secondes, y compris pendant le traitement prolongé du prompt. Obtenez le certificat avec Certbot et Let's Encrypt sur nginx.
L’unité systemd
Écrivez /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.targetLes paramètres se trouvent dans les lignes Environment=, car llama-server lit les variables LLAMA_ARG_* pour la plupart des options, et un argument de ligne de commande remplace la variable correspondante. Vous disposez ainsi d’un seul endroit où modifier la taille du contexte, et ExecStart reste assez court pour être lu d’un coup d’œil.
ProtectSystem=strict rend le système de fichiers accessible en lecture seule pour cette unité, à l’exception notamment des répertoires temporaires privés. Cela convient ici, car le serveur lit uniquement le modèle. Ajoutez ReadWritePaths=/srv/models et Environment=LLAMA_CACHE=/srv/models si vous voulez que le service télécharge lui-même les modèles avec -hf. ProtectHome=yes masque /home, /root et /run/user. Il ne masque pas le répertoire personnel de ce compte de service, situé dans /srv/llama, mais ProtectSystem=strict rend ce répertoire accessible en lecture seule.
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 est la moitié que beaucoup de personnes oublient. Sans enable, le serveur disparaît au prochain redémarrage. Si vous voulez planifier des tâches autour du service, par exemple vérifier chaque nuit la disponibilité d’une nouvelle version, un service systemd associé à un timer est le mécanisme prévu à cet effet.
Décider du comportement en cas d’OOM avant qu’il ne survienne
L’utilisation de la mémoire comporte deux parties, qui se comportent différemment sous une limite. Par défaut, le fichier du modèle est mappé en mémoire. Ses pages sont donc adossées à un fichier : le kernel peut les libérer, puis les relire depuis le disque. Le cache KV, qui contient l’état par token conservé par le serveur pour chaque conversation active, utilise de la mémoire anonyme. Il ne peut pas être libéré. C’est donc lui qui entraîne l’arrêt du processus.
C’est pourquoi les deux limites de l’unité ont des rôles différents. MemoryHigh=3G est une limite souple : au-delà, le kernel soumet le cgroup à une pression de reclaim. Les pages mappées du modèle sont alors évincées, puis relues depuis le disque au token suivant. Le service continue de fonctionner, mais il ralentit. MemoryMax=3500M est la limite stricte : le kernel récupère d’abord toute la mémoire possible. Si l’utilisation ne peut toujours pas rester sous cette limite, l’OOM killer s’exécute dans l’unité, et le journal l’indique clairement.
llama-server.service: A process of this unit has been killed by the OOM killer.Définissez vous-même --ctx-size. La valeur par défaut est 0. Elle correspond au contexte avec lequel le modèle a été entraîné. Sur un modèle moderne à long contexte, elle alloue un cache KV très volumineux au démarrage. Le service s’arrête alors avant de traiter une seule requête. --parallel ne multiplie pas directement cette consommation : --ctx-size définit la taille totale du cache KV, partagée entre tous les slots. Ainsi, --ctx-size 4096 --parallel 4 donne à chaque conversation environ 1,024 tokens, au lieu de multiplier la mémoire par quatre. Donner à chaque slot la taille complète du contexte revient à multiplier --ctx-size par le nombre de slots. La consommation mémoire augmente alors en conséquence. Laissez donc --parallel à 1 tant que la concurrence ne vous est pas nécessaire.
Avec Restart=on-failure, un service arrêté redémarre. Systemd cesse de le redémarrer avec start request repeated too quickly uniquement lorsque le nombre de démarrages dépasse la limite de débit configurée. Le délai de redémarrage de cinq secondes utilisé ici n’atteint pas la limite par défaut de cinq démarrages en dix secondes. Arrêtez une boucle persistante de redémarrage avec sudo systemctl stop llama-server, corrigez la limite ou la taille du contexte, puis effacez l’état d’échec avec sudo systemctl reset-failed llama-server et redémarrez le service.
Surveillez la valeur réelle avec systemctl show llama-server -p MemoryCurrent pendant l’exécution d’une requête. Limiter la mémoire et le CPU d’un processus avec systemd décrit ces directives plus en détail.
Évitez le swap pour cette charge de travail. Un modèle placé dans le swap transforme chaque token en lectures disque à des offsets aléatoires. Le memory mapping du fichier du modèle produit un effet similaire avec moins de conséquences, car le kernel lit directement dans le fichier les pages dont il a besoin.
Quand Ollama est le meilleur choix
C’est un choix d’architecture. Choisissez llama-server si vous voulez un seul processus, des flags définis par vos soins, une build figée et un fichier choisi par vos soins. Rien ne change en arrière-plan, car aucun autre composant ne s’exécute.
Choisissez Ollama si vous voulez gérer les modèles : télécharger les modèles par leur nom, en conserver plusieurs sur le disque, décharger un modèle inactif et effectuer une mise à niveau avec une seule commande au lieu de relancer une build. Ce sont des opérations concrètes que vous devriez sinon automatiser vous-même. Exécuter Ollama sur un VPS revient à effectuer la même tâche avec un autre compromis. Les deux exposent une API compatible avec OpenAI, mais testez les endpoints et les fonctionnalités utilisés par votre client avant de passer de l’un à l’autre.
Mettre à niveau une build épinglée
Remplacez bNNNNN par le tag de la build nightly vers lequel vous migrez ; les tags des versions officielles utilisent plutôt 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-serverL’ancien binaire reste sur le disque. Un rollback consiste donc à exécuter une seule ln -sfn vers llama-server-b10488, puis à redémarrer le service. Lisez les notes de version avant la migration. Les fichiers GGUF sont versionnés, mais la rétrocompatibilité n’est pas universelle : le loader actuel rejette GGUFv1. Les flags sont également renommés : dans b10488, --mlock et --no-mmap étaient déjà dépréciés au profit de --load-mode et, depuis le 11 octobre 2026, la documentation actuelle du serveur ne les mentionne plus. Une unit file qui transmet un flag supprimé échoue donc au démarrage avec un message indiquant un argument non reconnu. Les valeurs par défaut évoluent aussi : les builds actuelles écoutent par défaut sur le port 9931, alors que b10488 utilisait le port 8080. C’est pourquoi chaque commande et l’unité définissent explicitement le port.
Modes de défaillance et messages affichés
error while loading shared libraries: libllama.so après avoir copié le binaire ailleurs. La compilation par défaut produit des bibliothèques partagées à côté du binaire. Recompilez avec -DBUILD_SHARED_LIBS=OFF ou copiez tout le répertoire build/bin.
Illegal instruction (core dumped) au démarrage ou lors de la première requête. Le binaire a été compilé avec GGML_NATIVE activé, pour un CPU différent de celui qui l’exécute. Recompilez sur cette machine ou configurez avec -DGGML_NATIVE=OFF.
c++: fatal error: Killed signal terminated program cc1plus pendant la compilation. Le compilateur a été tué parce qu’il utilisait trop de mémoire. Réduisez -j ou ajoutez du swap pour la compilation, puis supprimez-le ensuite.
curl: (7) Failed to connect ... Connection refused depuis votre ordinateur portable. C’est normal : le serveur écoute sur l’adresse loopback du VPS. Effectuez le test directement sur le VPS ou ouvrez un tunnel avec ssh -L 8080:127.0.0.1:8080 user@your-vps, puis utilisez http://127.0.0.1:8080 localement.
HTTP 503 avec "message":"Loading model" pendant les premières secondes ou minutes après un redémarrage. La lecture d’un fichier de plusieurs gigaoctets prend du temps. systemd considère l’unité comme active dès le démarrage du processus, bien avant le chargement du modèle en mémoire.
Les requêtes restent bloquées, puis renvoient 504 Gateway Time-out. Le serveur n’a rien envoyé pendant plus de proxy_read_timeout. Cela peut se produire avec les requêtes qui n’utilisent pas le streaming. Les requêtes en streaming dans b10488 envoient par défaut des pings keepalive toutes les 30 secondes pendant le traitement prolongé du prompt. Augmentez proxy_read_timeout et désactivez proxy_buffering pour que les tokens soient transmis au client dès leur production.
L’unité redémarre en boucle, puis s’arrête avec start request repeated too quickly. Le nombre de démarrages a dépassé la limite de débit configurée. Vérifiez journalctl -u llama-server pour trouver la ligne de l’OOM killer, puis réduisez --ctx-size ou augmentez MemoryMax.
FAQ
Dois-je exécuter le serveur de llama.cpp ou Ollama sur mon VPS ?
Exécutez llama-server si vous voulez verrouiller une build précise, transmettre des flags exacts et conserver un modèle dans un seul fichier que rien ne met à jour à votre insu. Exécutez Ollama si vous voulez gérer les modèles et les mettre à niveau avec une seule commande, car récupérer les modèles par leur nom, en conserver plusieurs sur le disque et décharger ceux qui sont inactifs sont des tâches que vous devriez sinon automatiser vous-même. Les deux exposent une API compatible avec OpenAI, mais le changement nécessite de vérifier les endpoints et les fonctionnalités utilisés par votre client.
Quelle version de llama.cpp dois-je verrouiller ?
Utilisez n’importe quel tag que vous avez réellement compilé et testé. Les builds de développement nightly utilisent des tags correspondant au numéro de build, comme b10488, publié le 18 August 2026 ; les releases officielles utilisent des tags de version sémantique, vX.Y.Z. Clonez le dépôt avec --branch <tag>, installez le binaire sous un nom contenant ce tag et faites pointer un lien symbolique vers celui-ci. La mise à niveau et le rollback se font ainsi chacun avec une seule commande.
De combien de RAM llama-server a-t-il besoin ?
Commencez par la taille du fichier GGUF, puis ajoutez le cache KV, qui augmente avec --ctx-size. Cette valeur correspond au budget total de tokens partagé entre tous les slots --parallel. Un plus grand nombre de slots nécessite donc un --ctx-size plus grand si chacun doit conserver le même contexte. Les valeurs publiées ne remplacent pas les mesures réalisées sur votre propre configuration, car le total dépend du modèle, de la quantification et du contexte que vous autorisez. Exécutez systemctl show llama-server -p MemoryCurrent pendant le traitement d’une requête et utilisez la valeur affichée.
Pourquoi /health renvoie-t-il 503 avec « Loading model » ?
Le processus a démarré, mais le fichier du modèle n’est pas encore en mémoire. Le serveur renvoie donc {"error":{"code":503,"message":"Loading model","type":"unavailable_error"}}. Ce comportement est normal après chaque redémarrage et dure aussi longtemps que la lecture du fichier. Il devient problématique uniquement lorsqu’un client ou un proxy considère ce premier 503 comme un échec définitif. Interrogez /health jusqu’à ce qu’il renvoie {"status": "ok" }.
Puis-je exposer llama-server directement sur Internet ?
Ne le liez pas à 0.0.0.0 et n’ouvrez pas le port. Utilisez le proxy pour gérer les comptes, les limites de débit des requêtes et la journalisation d’audit. L’authentification intégrée de l’API utilise des clés statiques définies avec --api-key ou --api-key-file. Conservez la liaison 127.0.0.1 par défaut, placez nginx devant avec TLS et définissez également --api-key. Ainsi, une erreur de configuration du proxy ne laissera pas le modèle accessible à tout le monde.