# Déployer un modèle

Servez n’importe quel modèle Hugging Face (texte, image, vidéo ou voix) avec vLLM, SGLang, vLLM-Omni ou llama.cpp et vos propres options de moteur : un endpoint de type OpenAI avec sa propre clé d’API, et un accès SSH root.

## Dans la console

1. Ouvrez **Models** dans la [console](/console/#/models).
2. Indiquez le nom du modèle tel qu’il apparaît sur Hugging Face, par exemple `Qwen/Qwen3-8B`, ou collez son lien.
3. Choisissez le moteur : **vLLM** ou **SGLang** pour les modèles de texte, **vLLM-Omni** ou **SGLang** pour les modèles d’image et de vidéo, **vLLM-Omni** pour la voix et le son, **llama.cpp** pour un fichier GGUF. Avec llama.cpp, ajoutez la quantification après deux-points, par exemple `unsloth/Qwen3-8B-GGUF:Q4_K_M`.
4. Collez vos propres options de moteur si vous en avez (voir plus bas).
5. Pour un modèle à accès restreint ou privé, ajoutez un jeton Hugging Face avec un accès en lecture.
6. **Find GPUs** lit la taille du modèle sur Hugging Face, affiche la ligne de démarrage que la machine exécutera et liste tous les GPU sur lesquels il tient en ce moment, avec le prix. Choisissez-en un et louez-le.

Le moteur télécharge le modèle au démarrage de la machine, donc l’endpoint répond quelques minutes plus tard. **Models** indique quand il est prêt, son adresse, sa clé d’API, du code pour l’appeler, un essai pour les modèles de chat et d’image, et le journal du moteur.

## Vos options de moteur

Collez les options que vous avez réglées, sous la forme où vous les gardez :

```sh
VLLM_USE_DEEP_GEMM=1 vllm serve Qwen/Qwen3-8B \
  --max-model-len 32768 --enable-prefix-caching \
  --speculative-config '{"method": "eagle3", "num_speculative_tokens": 3}'
```

Des flags seuls, la commande complète ou une ligne `docker run` : tout fonctionne, avec des variables devant et des valeurs JSON entre guillemets. Vous les choisissez et les tenez à jour au fil des versions de votre moteur. Arrakis les lit sans shell et les transmet au moteur mot pour mot, donc :

- La syntaxe shell (`;`, `|`, `&&`, `$(...)`, `$VARIABLES`) est refusée : rien ne l’exécuterait.
- L’endroit où le moteur écoute (`--host`, `--port`), sa clé (`--api-key`) et le modèle restent gérés par Arrakis, si bien que l’endpoint garde son adresse et sa clé. `--served-model-name` (`--alias` pour llama.cpp) renomme le modèle utilisé par les requêtes.
- Votre parallélisme prime : avec `-tp`, `--tp` ou `-dp` dans vos options, Arrakis n’ajoute pas le sien.
- Les réglages qui choisissent les GPU (`NVIDIA_*`) et ceux du chargeur (`LD_*`) sont refusés : une machine utilise les GPU qu’elle loue.
- Votre jeton Hugging Face va dans son propre champ, jamais dans les options, pour ne pas être enregistré avec elles.

## Depuis l’API

```sh
curl -X POST $ARRAKIS_URL/v1/deploy \
  -H "Authorization: Bearer ark_..." \
  -H "Content-Type: application/json" \
  -d '{"model": "black-forest-labs/FLUX.1-schnell", "engine": "omni", "termination_hours": 4,
       "extra_args": "--enforce-eager"}'
```

Sans `node_id`, Arrakis loue la machine la mieux classée qui contient le modèle, sur aussi peu de GPU que possible. `POST /v1/deploy/plan` liste d’abord, gratuitement, tous les GPU sur lesquels il tient, et avec `extra_args` il vérifie vos options et renvoie la ligne de démarrage. La réponse contient l’endpoint et sa `api_key` ; `GET /v1/instances/{id}/endpoint` les redonne, avec `ready` dès que le modèle répond, et `GET /v1/instances/{id}/endpoint/log` la fin du journal du moteur. Les agents utilisent l’outil `deploy_model` via [MCP](/fr/docs/agents).

## Appeler le modèle

L’endpoint parle l’API OpenAI, donc n’importe quel client OpenAI fonctionne. Le nom du modèle dans une requête est son identifiant Hugging Face, sans la quantification, sauf si vous l’avez renommé.

```python
from openai import OpenAI

client = OpenAI(base_url="http://<address>/v1", api_key="sk-...")
reply = client.chat.completions.create(
    model="Qwen/Qwen3-8B",
    messages=[{"role": "user", "content": "Hello"}],
)
print(reply.choices[0].message.content)
```

| Le modèle produit | Où l’appeler |
|---|---|
| Texte | `POST /v1/chat/completions`, `/v1/completions`, `/v1/embeddings` |
| Images | `POST /v1/images/generations`, `/v1/images/edits` |
| Vidéo | `POST /v1/videos`, puis `GET /v1/videos/{id}` jusqu’à ce qu’elle soit terminée, et `GET /v1/videos/{id}/content` |
| Voix | `POST /v1/audio/speech` |
| Son et musique | `POST /v1/audio/generate` |
| Texte à partir de la voix | `POST /v1/audio/transcriptions` |

## La machine est à vous

- C’est une location ordinaire : facturée à l’heure, supprimée à son heure de suppression et listée dans **Instances**.
- Elle démarre sur une image Arrakis construite sur la version officielle du moteur, avec un accès SSH root. Lancez-y `arrakis-serve status`, `arrakis-serve logs` ou `arrakis-serve restart`.
- Pour essayer d’autres options sans nouvelle machine, éditez `/etc/arrakis/serve/command` (un mot par ligne) ou `/etc/arrakis/serve/env`, puis lancez `arrakis-serve restart`. Quand le moteur s’arrête, la machine reste allumée pour que vous puissiez corriger.
- L’endpoint est l’adresse de la machine en HTTP simple. Un contrôle d’accès sur le port 8000 vérifie sa clé d’API (`Authorization: Bearer <key>`) avant qu’une requête n’atteigne le moteur, qui n’écoute qu’à l’intérieur de la machine ; `/health` répond sans la clé et indique seulement si le moteur tourne. Pour un trafic privé, ouvrez un tunnel SSH (`ssh root@<host> -p <port> -N -L 8000:localhost:8000`) et utilisez `http://localhost:8000/v1`.
- Votre jeton Hugging Face est transmis à la machine sous la forme `HF_TOKEN`, et Arrakis ne le conserve pas. L’hôte de la machine peut lire ce qui s’y exécute : utilisez donc un jeton à permissions granulaires (fine-grained), en lecture seule.

Plus : [toute la documentation](/fr/docs.md) · [OpenAPI](/openapi.json) · [llms.txt](/fr/llms.txt)