Guardrino devant n’importe quel serveur de modèles

Le principe

Guardrino est conçu pour se placer entre vos applications et tout serveur de modèles doté d’une API compatible OpenAI. Votre application remplace son URL de base par celle de Guardrino ; le fichier de politique de Guardrino fait pointer upstream vers le serveur de modèles. Le serveur de modèles, ses modèles et ses GPU restent exactement tels quels.

# Before: your app talks to the model server
base_url = "http://<model-server>/v1"

# After: your app talks to Guardrino, and Guardrino talks to the model server
base_url = "http://guardrino.internal:8080/v1"     # in your app
url      = "http://<model-server>/v1"              # [upstream] in guardrino.toml

Ne rendez le serveur de modèles accessible qu’à Guardrino, pour que chaque requête passe par la politique.

Docker Compose

Deux services sur une machine avec GPU : vLLM sert le modèle, Guardrino est le seul port que voient vos applications.

services:
  vllm:
    image: vllm/vllm-openai:latest
    command: ["--model", "<your-model>"]
    ipc: host
    volumes:
      - ~/.cache/huggingface:/root/.cache/huggingface
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
    # No published port: only Guardrino reaches the model server.

  guardrino:
    image: guardrino:<version>          # loaded from the offline package (docker load -i ...)
    depends_on: [vllm]
    ports:
      - "8080:8080"                     # the only port your apps see
    volumes:
      - ./guardrino:/etc/guardrino      # guardrino.toml lives here
    env_file: ./guardrino/guardrino.env

# ./guardrino/guardrino.toml
mode = "observe"

[upstream]
url = "http://vllm:8000/v1"             # the vllm service, by its Compose name

docker compose up -d

vLLM sur un serveur

Sans conteneurs : le serveur compatible OpenAI de vLLM écoute par défaut sur le port 8000, sous /v1. Liez-le à une adresse que Guardrino peut joindre et faites pointer upstream vers lui.

# On the model server
vllm serve <your-model> --host <vllm-host> --port 8000

# guardrino.toml on the Guardrino server
[upstream]
url = "http://<vllm-host>:8000/v1"

Installer Guardrino lui-même sous Linux ou Windows

Kubernetes

Un chart Helm est prévu. Le paquet hors ligne contient le chart et les images : un cluster isolé s’installe depuis votre registre interne. La politique est fournie sous forme de ConfigMap et la clé du serveur de modèles vient d’un Secret que vous gérez déjà.

# The offline package carries the chart and the images: push the images to your internal registry first.
helm install guardrino ./guardrino-<version>.tgz -n guardrino --create-namespace -f values.yaml

image:
  repository: <your-registry>/guardrino
  tag: "<version>"

replicaCount: 2

resources:
  requests:
    cpu: "4"
    memory: 8Gi
  limits:
    memory: 16Gi

# Rendered into a ConfigMap as guardrino.toml
policy: |
  mode = "observe"

  [upstream]
  url = "http://vllm.models.svc.cluster.local:8000/v1"

# The provider or model-server key, from a Secret you already have (leave out if the server needs none)
upstreamKeySecret:
  name: upstream-credentials
  key: api-key

service:
  port: 8080

Les requests et limits suivent les exigences prévues : 4 vCPU et 8 Go pour commencer, jusqu’à 16 Go.

Red Hat OpenShift et OpenShift AI

La plateforme de service à modèle unique d’OpenShift AI repose sur KServe et inclut le vLLM ServingRuntime for KServe, dont les modèles répondent sur des points d’accès compatibles OpenAI. Faites pointer upstream vers le point d’accès interne du modèle, affiché dans le tableau de bord d’OpenShift AI.

# In values.yaml, policy: the model's internal endpoint from the OpenShift AI dashboard
[upstream]
url = "https://<model-name>-predictor.<model-project>.svc.cluster.local:8443/v1"

Installez le même chart Helm dans son propre projet et donnez à vos applications une Route OpenShift vers lui.

oc new-project guardrino
helm install guardrino ./guardrino-<version>.tgz -n guardrino -f values.yaml
oc expose service guardrino            # an OpenShift Route for your apps

Guardrino est conçu pour tourner avec un utilisateur non root sous la contrainte de contexte de sécurité restricted-v2, celle d’OpenShift par défaut. C’est l’intention de conception, pas une certification.

Autres serveurs et fournisseurs

Guardrino est conçu pour fonctionner avec tout serveur compatible OpenAI, par exemple :

Les ports sont les valeurs par défaut documentées par chaque projet ; utilisez l’adresse sur laquelle votre serveur écoute réellement.

Fournisseurs hébergés

Sidecar

Les équipes qui veulent Guardrino juste à côté d’une application peuvent le lancer dans le même pod ; l’application lui parle sur localhost.

containers:
  - name: app
    image: <your-app-image>
    env:
      - name: OPENAI_BASE_URL           # read by OpenAI's Python SDK
        value: http://localhost:8080/v1
  - name: guardrino
    image: <your-registry>/guardrino:<version>
    ports:
      - containerPort: 8080
    volumeMounts:
      - name: guardrino-policy
        mountPath: /etc/guardrino

Les noms de produits appartiennent à leurs propriétaires. Ils ne sont cités ici que pour montrer la place de Guardrino ; aucun partenariat, aucune certification ni aucun soutien n’est sous-entendu.