LiteLLM Proxy Server : gateway LLM pour l'entreprise

LiteLLM Proxy Server est une passerelle API qui unifie l’accès à plus de 100 LLM (OpenAI, Anthropic, Ollama, Azure…) via une interface compatible OpenAI. En entreprise, il résout trois problèmes majeurs : centraliser les clés API, contrôler les coûts (budgets par équipe), et restreindre l’accès (modèles autorisés, rate limits).

Ce guide vous accompagne de l’installation jusqu’à la mise en production. À la fin, vous saurez :

• Déployer un proxy local avec Docker et Ollama
• Créer des utilisateurs, équipes et clés virtuelles
• Limiter l’accès par modèle, budget et rate limit
• Monitorer la consommation en temps réel

Version actuelle

Ce guide utilise LiteLLM v1.82.x (mars 2026). Principales nouveautés : amélioration du routing, support MCP, et métriques Prometheus enrichies.

Ce que vous allez apprendre

• Architecture : comment LiteLLM s’insère entre vos applications et les LLM
• Lab Docker : proxy fonctionnel avec Ollama (gratuit, local)
• Gestion des accès : utilisateurs, équipes, clés virtuelles
• Restrictions : modèles autorisés, budgets, rate limits (RPM/TPM)
• Production : Docker Compose avec PostgreSQL et persistance

Pourquoi LiteLLM Proxy ?

Le problème du multi-provider

Sans proxy, chaque application gère ses propres clés API :

Sans proxy	Avec LiteLLM Proxy
Clés API éparpillées dans le code	Une seule clé par équipe
Impossible de suivre les coûts	Budget par user/team/clé
Dépendance à un fournisseur	Fallback automatique
Pas de rate limiting centralisé	RPM/TPM par clé

Glissez pour voir

Open Source vs Enterprise

Fonctionnalité	Open Source	Enterprise (250$/mois)
100+ LLM supportés	✅	✅
Clés virtuelles	✅	✅
Budgets & rate limits	✅	✅
Interface web	✅	✅
SSO/OIDC	❌	✅
Métriques Prometheus	❌	✅
Support SLA	❌	✅

Glissez pour voir

Ce guide = Open Source

Nous utilisons la version open source qui couvre 90% des besoins. Les fonctionnalités enterprise (SSO, Prometheus) sont mentionnées mais non détaillées.

Lab : proxy local avec Ollama

Nous allons créer un lab complet sans clé API payante. Ollama exécute les modèles localement, LiteLLM Proxy les expose via une API compatible OpenAI.

Architecture du lab

Prérequis

• Docker installé
• Ollama installé (ollama.ai)
• 4 Go de RAM disponibles pour les modèles

Étape 1 : Démarrer Ollama

Ollama doit écouter sur toutes les interfaces pour être accessible depuis Docker :

# Arrêter Ollama s'il tourne
pkill ollama

# Redémarrer en écoutant sur toutes les interfaces
OLLAMA_HOST=0.0.0.0 ollama serve &

# Vérifier
curl -s http://localhost:11434/api/tags | jq '.models[].name'

Étape 2 : Télécharger des modèles

# Modèle léger pour les tests (352 Mo)
ollama pull qwen2:0.5b

# Modèle plus capable (1.3 Go)
ollama pull llama3.2:1b

# Vérifier les modèles disponibles
ollama list

Sortie attendue :

NAME            ID              SIZE    MODIFIED
llama3.2:1b     baf6a787fdff    1.3 GB  2 minutes ago
qwen2:0.5b      6f48b936a09f    352 MB  3 minutes ago

Étape 3 : Créer le fichier de configuration

Créez un dossier pour le lab :

mkdir -p ~/Projets/litellm-lab/config
cd ~/Projets/litellm-lab

Créez le fichier config/proxy-config.yaml :

# LiteLLM Proxy Server - Configuration Lab
model_list:
  # Modèle principal
  - model_name: llama
    litellm_params:
      model: ollama/llama3.2:1b
      api_base: http://host.docker.internal:11434

  # Modèle secondaire (plus rapide)
  - model_name: qwen
    litellm_params:
      model: ollama/qwen2:0.5b
      api_base: http://host.docker.internal:11434

  # Alias pour compatibilité OpenAI
  - model_name: gpt-3.5-turbo
    litellm_params:
      model: ollama/qwen2:0.5b
      api_base: http://host.docker.internal:11434

  - model_name: gpt-4
    litellm_params:
      model: ollama/llama3.2:1b
      api_base: http://host.docker.internal:11434

general_settings:
  master_key: os.environ/LITELLM_MASTER_KEY
  json_logs: true

router_settings:
  routing_strategy: simple-shuffle
  num_retries: 2
  timeout: 120

host.docker.internal

host.docker.internal permet au conteneur Docker d’atteindre Ollama sur la machine hôte. Sur Linux, ajoutez --add-host=host.docker.internal:host-gateway au docker run.

Étape 4 : Lancer PostgreSQL

PostgreSQL stocke les utilisateurs, clés et métriques :

docker run -d --name litellm-postgres \
  -e POSTGRES_USER=litellm \
  -e POSTGRES_PASSWORD=litellm_secure_pwd \
  -e POSTGRES_DB=litellm \
  -p 5432:5432 \
  postgres:16-alpine

Vérification :

docker ps | grep litellm-postgres
# Doit afficher le conteneur en cours d'exécution

Étape 5 : Lancer LiteLLM Proxy

docker run -d --name litellm-proxy \
  -p 4000:4000 \
  -v $(pwd)/config/proxy-config.yaml:/app/config.yaml \
  -e LITELLM_MASTER_KEY=sk-litellm-lab-2026-demo \
  -e DATABASE_URL="postgresql://litellm:litellm_secure_pwd@172.17.0.1:5432/litellm" \
  -e UI_USERNAME=admin \
  -e UI_PASSWORD=AdminSecure2026 \
  --add-host=host.docker.internal:host-gateway \
  ghcr.io/berriai/litellm:main-latest \
  --config /app/config.yaml --port 4000

Adresse PostgreSQL

172.17.0.1 est l’IP du bridge Docker par défaut. Si ça ne fonctionne pas, utilisez host.docker.internal ou l’IP de votre machine.

Vérifier les logs :

docker logs litellm-proxy --tail 20

Sortie attendue :

   ██╗     ██╗████████╗███████╗██╗     ██╗     ███╗   ███╗
   ██║     ██║╚══██╔══╝██╔════╝██║     ██║     ████╗ ████║
   ...
INFO:     Application startup complete.
INFO:     Uvicorn running on http://0.0.0.0:4000

Étape 6 : Tester le proxy

# Lister les modèles disponibles
curl -s http://localhost:4000/v1/models \
  -H "Authorization: Bearer sk-litellm-lab-2026-demo" | jq '.data[].id'

Sortie attendue :

"llama"
"qwen"
"gpt-3.5-turbo"
"gpt-4"

# Tester une complétion
curl -s http://localhost:4000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk-litellm-lab-2026-demo" \
  -d '{
    "model": "qwen",
    "messages": [{"role": "user", "content": "Dis bonjour en une phrase"}],
    "max_tokens": 30
  }' | jq '.choices[0].message.content'

Sortie attendue :

"Bonjour! Comment puis-je vous aider aujourd'hui?"

Interface web

Accédez à l’interface d’administration : http://localhost:4000/ui

Identifiants : admin / AdminSecure2026

Gestion des utilisateurs et équipes

LiteLLM propose une hiérarchie à 3 niveaux : Utilisateurs → Équipes → Clés. Chaque niveau peut avoir ses propres restrictions.

Créer un utilisateur

curl -s http://localhost:4000/user/new \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk-litellm-lab-2026-demo" \
  -d '{
    "user_id": "alice@example.com",
    "user_email": "alice@example.com",
    "max_budget": 5.0,
    "budget_duration": "30d",
    "models": ["qwen"],
    "metadata": {"role": "developer", "department": "engineering"}
  }' | jq '{user_id, max_budget, models}'

Sortie :

{
  "user_id": "alice@example.com",
  "max_budget": 5.0,
  "models": ["qwen"]
}

Créer une équipe

curl -s http://localhost:4000/team/new \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk-litellm-lab-2026-demo" \
  -d '{
    "team_alias": "ml-team",
    "max_budget": 50.0,
    "budget_duration": "30d",
    "models": ["qwen", "llama"],
    "tpm_limit": 100000,
    "rpm_limit": 60,
    "metadata": {"project": "ml-pipeline"}
  }' | jq '{team_id, team_alias, max_budget, rpm_limit}'

Sortie :

{
  "team_id": "0b71f785-5fec-48c0-a76d-87d3289fafb4",
  "team_alias": "ml-team",
  "max_budget": 50.0,
  "rpm_limit": 60
}

Hiérarchie des limites

Les limites s’appliquent en cascade : si l’équipe a un budget de 50$ et l’utilisateur de 5$, l’utilisateur est limité à 5$. Si l’équipe atteint 50$, tous ses membres sont bloqués.

Gestion des clés virtuelles

Les clés virtuelles permettent de distribuer des accès sans partager la master key.

Créer une clé avec restrictions

curl -s http://localhost:4000/key/generate \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk-litellm-lab-2026-demo" \
  -d '{
    "key_alias": "dev-team-key",
    "max_budget": 10.0,
    "budget_duration": "30d",
    "models": ["qwen", "llama"],
    "metadata": {"team": "dev", "project": "demo"}
  }' | jq '{key, max_budget, models}'

Sortie :

{
  "key": "sk-Li3j_hWPrxs5MY3m0DBAJg",
  "max_budget": 10.0,
  "models": ["qwen", "llama"]
}

Tester les restrictions de modèle

Cette clé est limitée à qwen et llama. Testons l’accès à gpt-4 :

curl -s http://localhost:4000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk-Li3j_hWPrxs5MY3m0DBAJg" \
  -d '{"model": "gpt-4", "messages": [{"role": "user", "content": "test"}]}' \
  | jq '.error'

Sortie (accès refusé) :

{
  "message": "key not allowed to access model. This key can only access models=['qwen', 'llama']. Tried to access gpt-4",
  "type": "key_model_access_denied",
  "code": "401"
}

Créer une clé liée à un utilisateur et une équipe

curl -s http://localhost:4000/key/generate \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk-litellm-lab-2026-demo" \
  -d '{
    "key_alias": "alice-personal-key",
    "user_id": "alice@example.com",
    "team_id": "0b71f785-5fec-48c0-a76d-87d3289fafb4",
    "max_budget": 2.0
  }' | jq '{key, user_id, team_id, max_budget}'

Rate limiting (RPM/TPM)

Le rate limiting protège contre les abus et contrôle la consommation.

Créer une clé avec rate limit strict

curl -s http://localhost:4000/key/generate \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk-litellm-lab-2026-demo" \
  -d '{
    "key_alias": "rate-limited-key",
    "rpm_limit": 2,
    "tpm_limit": 100,
    "models": ["qwen"]
  }' | jq '{key, rpm_limit, tpm_limit}'

Sortie :

{
  "key": "sk-9MwdeGpwsUJ9z0NPftXz4A",
  "rpm_limit": 2,
  "tpm_limit": 100
}

Tester le rate limiting

Envoyez 3 requêtes rapides (la limite est de 2/minute) :

KEY="sk-9MwdeGpwsUJ9z0NPftXz4A"
for i in 1 2 3; do
  echo "=== Requête $i ==="
  curl -s http://localhost:4000/v1/chat/completions \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer $KEY" \
    -d '{"model": "qwen", "messages": [{"role": "user", "content": "1"}], "max_tokens": 5}' \
    | jq -c '{ok: .choices[0].message.content, error: .error.message}'
done

Sortie :

=== Requête 1 ===
{"ok":"Hello! It seems like","error":null}
=== Requête 2 ===
{"ok":"Hello! How can I","error":null}
=== Requête 3 ===
{"ok":null,"error":"Rate limit exceeded... Current limit: 2, Remaining: 0. Limit resets at: ..."}

Types de rate limits

Limite	Description	Cas d’usage
rpm_limit	Requêtes par minute	Protéger contre les bots
tpm_limit	Tokens par minute	Contrôler la consommation
max_parallel_requests	Requêtes simultanées	Éviter la saturation

Glissez pour voir

Monitoring de la consommation

Consulter les dépenses par tag

curl -s http://localhost:4000/spend/tags \
  -H "Authorization: Bearer sk-litellm-lab-2026-demo" | jq .

Voir les statistiques globales

Accédez à l’interface web http://localhost:4000/ui pour visualiser :

• Dépenses par modèle, utilisateur, équipe
• Graphiques de consommation dans le temps
• Alertes de dépassement de budget

Production : Docker Compose

Pour un déploiement production, utilisez Docker Compose avec persistance :

docker-compose.yml

version: '3.8'

services:
  postgres:
    image: postgres:16-alpine
    container_name: litellm-db
    environment:
      POSTGRES_USER: litellm
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-changeme}
      POSTGRES_DB: litellm
    volumes:
      - postgres_data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U litellm"]
      interval: 5s
      timeout: 5s
      retries: 5

  litellm:
    image: ghcr.io/berriai/litellm:main-latest
    container_name: litellm-proxy
    ports:
      - "4000:4000"
    environment:
      LITELLM_MASTER_KEY: ${LITELLM_MASTER_KEY}
      DATABASE_URL: postgresql://litellm:${POSTGRES_PASSWORD:-changeme}@postgres:5432/litellm
      UI_USERNAME: ${UI_USERNAME:-admin}
      UI_PASSWORD: ${UI_PASSWORD}
      OPENAI_API_KEY: ${OPENAI_API_KEY:-}
      ANTHROPIC_API_KEY: ${ANTHROPIC_API_KEY:-}
    volumes:
      - ./config/proxy-config.yaml:/app/config.yaml:ro
    depends_on:
      postgres:
        condition: service_healthy
    command: ["--config", "/app/config.yaml", "--port", "4000"]
    restart: unless-stopped

volumes:
  postgres_data:

Fichier .env :

LITELLM_MASTER_KEY=sk-your-secure-master-key-here
POSTGRES_PASSWORD=your-secure-db-password
UI_USERNAME=admin
UI_PASSWORD=YourSecureUIPassword!
OPENAI_API_KEY=sk-...
ANTHROPIC_API_KEY=sk-ant-...

Lancement :

docker compose up -d
docker compose logs -f litellm

Sécurité production

• HTTPS obligatoire : placez un reverse proxy (Traefik, Nginx) devant LiteLLM
• Master key : générez-la avec openssl rand -hex 32
• Secrets : utilisez un gestionnaire de secrets (Vault, AWS Secrets Manager)
• Backup : sauvegardez régulièrement PostgreSQL

Dépannage

Problèmes courants

Symptôme	Cause probable	Solution
Cannot connect to host localhost:11434	Ollama écoute sur 127.0.0.1	Lancer avec OLLAMA_HOST=0.0.0.0
Unable to find Prisma binaries	Installation pip sans Docker	Utiliser l’image Docker officielle
Rate limit exceeded	Limite atteinte	Attendre le reset ou augmenter la limite
key not allowed to access model	Modèle non autorisé	Ajouter le modèle à la clé
Authentication Error	Master key incorrecte	Vérifier LITELLM_MASTER_KEY

Glissez pour voir

Commandes de diagnostic

# Logs du proxy
docker logs litellm-proxy --tail 100

# Vérifier la connexion PostgreSQL
docker exec litellm-proxy psql $DATABASE_URL -c "SELECT 1"

# Lister toutes les clés (tokens hachés)
curl -s http://localhost:4000/key/list \
  -H "Authorization: Bearer sk-litellm-lab-2026-demo" | jq .

# Health check
curl -s http://localhost:4000/health | jq .

À retenir

1. LiteLLM Proxy unifie l’accès à 100+ LLM via une API compatible OpenAI
2. Hiérarchie 3 niveaux : User → Team → Key, chacun avec ses restrictions
3. Restrictions par clé : modèles autorisés, budget, rate limits (RPM/TPM)
4. Docker recommandé pour éviter les problèmes de dépendances (Prisma)
5. PostgreSQL requis pour la persistance des clés, users et métriques
6. Production : HTTPS obligatoire, master key sécurisée, backups

Prochaines étapes

LiteLLM SDK Utiliser LiteLLM côté client Python

Ollama Exécuter des LLM en local

HAProxy Reverse proxy pour la production

Traefik Ingress controller avec HTTPS automatique

Ressources

• Documentation officielle : docs.litellm.ai
• GitHub : github.com/BerriAI/litellm
• Swagger API : http://localhost:4000 (après démarrage du proxy)
• Communauté Discord : Support communautaire actif

×

📖 Voir la documentation →