← Retour aux guides
InsightFace ServerAPI RESTSDK PythonReconnaissance facialeRTSP

Intégrer l’API REST du Server

Intégrez InsightFace Server via API REST et SDK Python : créez des Collections, enrôlez, lancez des recherches 1:N exactes et ajoutez le suivi RTSP.

16 min de lecture
Écran Collections d’InsightFace Server présentant des bases d’identités faciales isolées
Chaque Collection fige son contrat de modèle, détection, seuil et recherche exacte.

Ce que vous allez mettre en place

InsightFace Server est un service auto-hébergé d’analyse et de reconnaissance faciales. La Web UI, l’API REST versionnée /v1 et le SDK Python léger manipulent les mêmes Collections, personnes, FaceSamples et Monitors de caméra persistants.

Ce guide suit une intégration complète depuis la frontière API : vérifier l’authentification et la disponibilité, créer une Collection, enrôler puis rechercher une personne, appeler Detect et Compare sans état, et connecter un Monitor RTSP. Il précise aussi les règles de reprise, de données biométriques, de licence modèle et de réseau indispensables hors d’un environnement d’évaluation isolé.

Avant de commencer

  • Un serveur CPU actif sur http://127.0.0.1:18097, ou l’adresse configurée d’un serveur CUDA ; l’exemple CUDA fourni utilise le port 18098.
  • Des images de test JPEG, PNG ou WebP obtenues avec consentement et contenant un visage net ; la limite par défaut d’image compressée est de 10 MiB.
  • L’API key si l’authentification est activée, un shell avec curl et Python 3 pour le parcours SDK facultatif.
  • Un model package licencié et vérifié. Les modèles publics préentraînés InsightFace sont réservés à la recherche non commerciale sauf licence commerciale distincte.

1. Vérifier l’authentification et le contrat de réponse

Appelez d’abord GET /v1/health. Cet endpoint reste public et indique readiness ainsi que auth_enabled. Quand auth_enabled vaut true, tous les autres endpoints exigent Authorization: Bearer <api_key>. Lorsque l’authentification est désactivée, omettez entièrement le header Authorization : n’envoyez pas un header vide. Le premier bloc montre exactement cette forme sans authentification, le second concerne les déploiements authentifiés.

L’API utilise du JSON snake_case et multipart/form-data pour les images. Chaque réponse porte un header UUID x-request-id, repris comme request_id dans les bodies JSON. Les signaux de détection et de qualité vont de 0.0 à 1.0, mais recognition similarity est le cosinus brut dans [-1.0, 1.0], pas une probabilité. threshold accepte l’intervalle inclusif [0.0, 1.0], vaut 0.4 par défaut, et il y a correspondance si similarity >= threshold.

  • Un DELETE réussi renvoie HTTP 204 sans body.
  • L’absence de visage peut être un résultat Detect vide valide ; l’absence de correspondance Search est un matches: [] valide.
  • OpenAPI est disponible sur /openapi.json et le viewer interactif same-origin sur /docs.
Authentification désactivée : omettre entièrement Authorization
BASE_URL=http://127.0.0.1:18097
curl -fsS "${BASE_URL}/v1/health"
curl -sS "${BASE_URL}/v1/system"
Authentification activée : envoyer un token Bearer
export INSIGHTFACE_API_KEY='replace-with-a-long-random-secret'
BASE_URL=http://127.0.0.1:18097
AUTH_HEADER="Authorization: Bearer ${INSIGHTFACE_API_KEY}"

curl -fsS "${BASE_URL}/v1/health"
curl -sS "${BASE_URL}/v1/system" -H "${AUTH_HEADER}"

2. Créer une Collection et figer le contrat

Une Collection est à la fois une base d’identités isolée et un contrat de déploiement. À sa création, elle fixe model ID, version, bundle digest, embedding dimension, preprocessing version, detection profile et exact-search profile du modèle actif. L’embedding_contract_id renvoyé est opaque : copiez-le pour trusted external enrollment, ne le fabriquez jamais.

Commencez avec threshold 0.4, puis calibrez-le sur des données de validation représentatives. Les réponses Collection exposent detection_revision et les paramètres de recherche résolus. Les modifications ultérieures du detection profile s’appliquent aux nouvelles requêtes sans réextraire les FaceSamples existants. Les profils effectuent une recherche exhaustive à plat ; les faibles précisions approchent les cosinus FP32 mais ne sont pas des index ANN.

  • Le search profile général par défaut est fp32_v1 ; fp16_v1 est réservé à CUDA et BF16 dépend du CPU ou de CUDA SM80+.
  • La capacité par défaut est de 100 000 lignes actives et max_faces_per_person vaut 20 ; dimensionnez selon un budget réel de mémoire et de conservation.
  • Le stockage des face crops est désactivé par défaut. Activé, il conserve des bounding-box crops JPEG 112×112, jamais les uploads originaux ni les aligned recognition inputs.
Créer la Collection employees
curl -sS "${BASE_URL}/v1/collections" -H "${AUTH_HEADER}" \
  -H 'Content-Type: application/json' \
  -d '{"id":"employees","name":"Employees","threshold":0.4}'

3. Enrôler une personne, puis la rechercher

L’enrôlement est multipart et accepte plusieurs images par requête. review_mode=off suit la stratégie de sélection de la Collection ; standard exige exactement un visage exploitable et applique les contrôles configurés de taille, confiance, qualité et pose ; strict ajoute les comparaisons de similarité intra- et extra-personne. Un lot peut réussir partiellement avec HTTP 201 : vérifiez toujours faces et rejected_images.

Search choisit un query face avec le profil de la Collection, le compare à chaque FaceSample actif et attribue à chaque personne le meilleur score de ses échantillons. Seuls les résultats au-dessus ou égaux au threshold effectif sont renvoyés par similarity décroissante. Validez avec une image différente de celles d’enrôlement.

  • Sans visage de requête exploitable, la réponse est 422 face_not_found ; une requête valide sans identité au seuil renvoie matches: [].
  • Les échantillons acceptés sont commit dans SQLite et ajoutés à l’index actif en mémoire avant la réponse de succès.
  • external_trusted exige toujours l’image associée et l’exact embedding_contract_id ; les vecteurs doivent être finis, non nuls, de bonne dimension et normalisés L2 à 1.0 ± 0.0002.
Enrôler Alice avec deux images
curl -sS "${BASE_URL}/v1/collections/employees/persons" \
  -H "${AUTH_HEADER}" \
  -F 'id=employee-001' \
  -F 'name=Alice' \
  -F 'external_id=HR-1001' \
  -F 'metadata={"department":"sales"}' \
  -F 'review_mode=standard' \
  -F 'images=@alice1.jpg' \
  -F 'images=@alice2.jpg'
Rechercher avec une autre image
curl -sS "${BASE_URL}/v1/collections/employees/search" \
  -H "${AUTH_HEADER}" \
  -F 'image=@alice-query.jpg' \
  -F 'limit=5'

4. Utiliser Detect et Compare sans état

Detect renvoie tous les visages exploitables par aire décroissante, avec boîtes pixel/normalisées, cinq landmarks, confiance du détecteur et signaux locaux de qualité. Il ne renvoie pas d’embedding et ne persiste rien. Passez collection_id pour employer le detection profile d’une Collection plutôt que le profil système immuable.

Compare sélectionne un visage dans source et target, calcule la similarity cosinus brute et renvoie matched selon le threshold effectif. La similarity peut être négative et ne doit jamais devenir un pourcentage de confiance. Si l’une des images ne contient aucun visage exploitable, la réponse est 422 face_not_found.

  • max_faces accepte 1–100. JPEG, PNG et WebP sont pris en charge, et l’orientation EXIF est appliquée avant inférence.
  • La limite par défaut est de 64 MiB pour la requête entière et 40 millions de pixels après décodage.
  • Detect, Compare, enrôlement, Search, embeddings et reconnaissance RTSP partagent le budget global de concurrence d’inférence.
Détecter les visages sans persistance
curl -sS "${BASE_URL}/v1/detect" \
  -H "${AUTH_HEADER}" \
  -F 'image=@group.jpg' \
  -F 'max_faces=10' \
  -F 'collection_id=employees'
Comparer deux visages sélectionnés
curl -sS "${BASE_URL}/v1/compare" \
  -H "${AUTH_HEADER}" \
  -F 'source=@source.jpg' \
  -F 'target=@target.jpg' \
  -F 'threshold=0.4'

5. Utiliser le SDK Python léger

Installez le client directement depuis ce checkout. Fondé sur httpx, il n’embarque aucun runtime d’inférence et accepte chemins d’image, bytes ou objets fichier binaires. Son timeout par défaut de 65 secondes dépasse légèrement la deadline serveur de 60 secondes.

L’exemple utilise l’adresse CPU du User Guide sur le port 18097 et un serveur authentifié. Si l’authentification est désactivée, construisez Client("http://localhost:18097") sans api_key afin de ne transmettre aucun Authorization header. Le client expose aussi create_monitor, update_monitor, monitor_state et monitor_events avec cursor.

  • Gardez le timeout client supérieur au timeout serveur configuré, sauf si l’application doit volontairement échouer plus tôt.
  • Passez collection= à Detect ou Compare pour utiliser le detection profile d’une Collection.
  • Fermez le client ou employez-le comme context manager pour libérer les connexions du pool.
Installer le SDK Python local
python -m pip install ./server/sdk/python
Créer, enrôler, détecter, comparer et rechercher en Python
from insightface_server import Client

# Authenticated deployment. When authentication is disabled, omit api_key:
# with Client("http://localhost:18097") as client:
with Client("http://localhost:18097", api_key="your-key") as client:
    client.create_collection(
        collection_id="employees",
        name="Employees",
        threshold=0.4,
    )
    client.add_person(
        "employees",
        person_id="employee-001",
        name="Alice",
        images=["alice1.jpg", "alice2.jpg"],
        review_mode="standard",
    )

    faces = client.detect("group.jpg", max_faces=10, collection="employees")
    comparison = client.compare(
        "source.jpg", "target.jpg", threshold=0.4, collection="employees"
    )
    matches = client.search("employees", "alice-query.jpg", limit=5)

    print(faces.faces)
    print(comparison.similarity, comparison.matched)
    print(matches.matches)

6. Gérer erreurs et reprises sans dupliquer les écritures biométriques

Les erreurs suivent un envelope JSON commun avec error.code, error.message, details optionnels et request_id. Les correspondances usuelles sont 400 paramètres invalides, 401 key absente/invalide, 404 ressource absente, 409 conflit d’état ou de modèle, 413 limite de taille, 422 image invalide ou visage inutilisable, 500 erreur inattendue et 503 timeout ou runtime/index indisponible.

GET peut être repris sans risque. Réessayez 429 et les 503 transitoires avec exponential backoff borné et jitter ; un 4xx de validation exige de corriger la requête. Après une panne transport, la création Person/FaceSample est ambiguë : lisez d’abord l’ID fourni par le client. Si un 503 d’enrôlement contient write_committed: true, l’écriture existe déjà dans SQLite. Ne réessayez pas aveuglément ; lisez la personne avant de décider.

  • Journalisez x-request-id, endpoint, status et timings sûrs, jamais images, embeddings, API keys ou identifiants RTSP.
  • Ne réessayez DELETE qu’après lecture de l’état courant.
  • Réutilisez les cursors opaques inchangés avec le même endpoint et les mêmes filtres ; ne les analysez ni ne les fabriquez.

7. Ajouter un Monitor RTSP persistant

Écran de surveillance caméra d’InsightFace Server avec une tâche RTSP persistante
Un Monitor RTSP persistant reste actif côté serveur lorsque le navigateur est fermé.

Un Monitor est une tâche serveur de reconnaissance RTSP dont la configuration est stockée dans SQLite. Une tâche enabled reprend après redémarrage du Server et continue quand le navigateur se ferme. Le decoder ne garde que la dernière frame : une inférence lente réduit le débit effectif au lieu d’accumuler du retard. match_threshold: null hérite du threshold de la Collection.

La preview est volontairement désactivée par défaut et la reconnaissance n’en dépend pas. Activé, /preview.mjpeg transmet des frames JPEG brutes sans annotation ; le client dessine les boîtes avec /state. Ne placez jamais l’API key dans l’URL de preview. Interrogez /events avec son cursor opaque pour les événements enter, exit, error et recovery, et traitez explicitement truncated et stream_reset.

  • Les identifiants RTSP sont chiffrés AES-GCM sous /data et l’API ne renvoie qu’une source masquée.
  • Les frames vidéo ne sont jamais sauvegardées. Les événements récents vivent uniquement dans un ring mémoire borné et disparaissent au redémarrage du processus.
  • Réservez l’administration des Monitors aux opérateurs de confiance ; la phase un possède une API key unique sans rôles, pas une autorisation par tenant.
monitor.json
{
  "id": "front-gate",
  "name": "Front gate",
  "description": "Main entrance",
  "enabled": true,
  "source": {
    "type": "rtsp",
    "url": "rtsp://viewer:secret@camera.example/live"
  },
  "collection_id": "employees",
  "inference_fps": 2.0,
  "match_threshold": null,
  "event_buffer_size": 1000,
  "event_policy": {
    "confirm_frames": 3,
    "absence_timeout_seconds": 3.0,
    "cooldown_seconds": 10.0,
    "emit_unknown": true
  },
  "preview_enabled": false
}
Créer un Monitor et interroger état et événements
curl -sS "${BASE_URL}/v1/monitors" -H "${AUTH_HEADER}" \
  -H 'Content-Type: application/json' \
  -d @monitor.json

curl -sS "${BASE_URL}/v1/monitors/front-gate/state" \
  -H "${AUTH_HEADER}"

curl -sS "${BASE_URL}/v1/monitors/front-gate/events?limit=100" \
  -H "${AUTH_HEADER}"

8. Protéger données, réseau, sauvegardes et droits modèle

Persistez /data, montez /models en lecture seule et sauvegardez SQLite avec le crop storage configuré, écritures arrêtées ou via un snapshot sûr pour SQLite. Traitez volume et sauvegardes comme données biométriques. Terminez HTTPS sur un reverse proxy de confiance, n’autorisez que les origins CORS nécessaires et ajoutez des limites edge de débit, body et temps. N’exposez jamais une évaluation sans authentification.

Le code source du Server et le SDK Python sont sous licence MIT ; les modèles en sont expressément exclus. L’image du conteneur ne contient aucun modèle. L’installateur affiche la licence modèle et verify contrôle identité du package, licence signée, validité et autorisation. Les packages publics InsightFace, dont buffalo_l, sont généralement réservés à la recherche académique non commerciale sans licence commerciale séparée.

  • Les API keys sont stockées sous forme de hash ; changer INSIGHTFACE_API_KEY à un démarrage ultérieur effectue volontairement la rotation de la key active du volume.
  • Utilisez docker compose down sans -v ; -v supprime définitivement le named data volume.
  • Définissez consentement, conservation, suppression, réponse aux incidents et usages autorisés avant de traiter des identités réelles.
Installer et vérifier un package modèle licencié
docker compose -f server/deploy/compose.cpu.yml \
  run --rm models install buffalo_l --accept-license
docker compose -f server/deploy/compose.cpu.yml \
  run --rm models verify buffalo_l

Besoin d’aide pour le déploiement en production ?

Contactez InsightFace pour les licences de modèles, l’optimisation runtime et le support de déploiement sur votre matériel cible.

Envoyer une demande entreprise