Bedrock Guardrails est une couche de protection au sein d'Amazon Bedrock que tu configures une fois et que tu attaches aux appels de modèle. Elle contrôle l'entrée et la sortie selon six types de politiques, de la modération classique jusqu'à la vérification formelle qu'une réponse respecte des règles que tu as écrites toi-même.
Ce dernier point distingue le service des filtres de contenu habituels. La plupart des concurrents jugent si un texte est nuisible. Ce service peut en plus vérifier si une réponse contredit les règles de ton entreprise, et le faire en prouvant plutôt qu'en devinant.
Six types de politiques
Il vaut la peine de les connaître séparément, car elles diffèrent par leur but, leur prix et leur qualité, et tout activer d'un coup est l'erreur la plus courante.
Les filtres de contenu détectent le contenu nuisible dans des catégories qui couvrent la haine, les insultes, le contenu sexuel, la violence, la mauvaise conduite et les attaques par prompt. Tu règles la force du filtre pour chaque catégorie indépendamment.
Les attaques par prompt forment une sous-catégorie des filtres de contenu et couvrent les jailbreaks, les injections d'instructions et la fuite du prompt système.
Les sujets interdits te permettent de lister des domaines que l'application doit éviter, décrits en langage naturel. Un assistant bancaire peut ainsi refuser de parler de conseil en investissement, même si une telle conversation n'est pas nuisible au sens de la modération.
Les filtres de mots travaillent sur des correspondances exactes et servent à supprimer des expressions précises : des grossièretés issues d'une liste toute faite ou de tes propres entrées, des noms de concurrents par exemple.
Les filtres d'informations sensibles détectent les données personnelles dans des formats standard ainsi que des motifs personnalisés, et peuvent les bloquer ou les masquer. Ils reposent sur un modèle entraîné, donc ils tiennent compte du contexte et pas seulement de la forme d'une chaîne de caractères.
Les contrôles d'ancrage contextuel (contextual grounding) détectent les réponses qui ne découlent pas des sources fournies ou qui ne répondent pas à la question. Ce contrôle vise les applications construites sur la recherche dans des documents.
La vérification formelle, la partie la plus intéressante
Les contrôles par raisonnement automatisé forment une catégorie à part, et leur avantage mérite d'être compris.
Tu écris une politique en langage naturel : quelles règles doivent tenir, ce qui est permis, ce qui est mutuellement exclusif. Le service la traduit en une représentation formelle, puis vérifie pour chaque réponse du modèle si elle peut être conciliée avec ces règles.
La différence avec un classifieur est fondamentale. Un classifieur renvoie une probabilité, donc la réponse se lit « ceci enfreint probablement les règles ». La vérification formelle renvoie une décision avec une justification, donc la réponse se lit « ceci contredit la règle trois ». Le fournisseur annonce une précision de détection des réponses correctes qui atteint quatre-vingt-dix-neuf pour cent, et ce chiffre mérite d'être traité comme une affirmation à vérifier avec tes propres règles.
Les applications sont plus étroites que la description ne le suggère. Cela fonctionne là où les règles peuvent s'exprimer logiquement : disponibilité des produits, conditions tarifaires, conformité aux conditions d'utilisation, critères d'éligibilité. Cela ne fonctionne pas là où le jugement dépend du contexte social ou du ton.
La fonctionnalité est devenue généralement disponible en août 2025, après une préversion annoncée en décembre 2024.
Niveaux de traitement et prise en charge du code
Le service distingue deux niveaux de traitement, et cette distinction a des conséquences faciles à manquer.
Le niveau supérieur étend la détection aux éléments de code : commentaires, noms de variables et de fonctions, et littéraux de chaîne. Au niveau de base, ces endroits ne sont pas examinés.
Cela compte pour les assistants de programmation et partout où un modèle génère du code. Une instruction cachée dans un commentaire, ou un contenu indésirable écrit sous forme de nom de variable, passe un filtre qui ne regarde que la prose.
La détection de fuite du prompt système fonctionne au même niveau et n'existe pas au niveau de base. Si ton prompt système contient quoi que ce soit qu'un utilisateur ne doit pas voir, c'est l'argument décisif.
Le piège de la journalisation
C'est un détail qui peut annuler tout l'intérêt d'un déploiement, et il n'apparaît pas dans les documents commerciaux.
Le contenu bloqué par n'importe quelle politique atterrit en clair dans les journaux d'invocation du modèle, à condition que tu les aies activés. Cela signifie que les données personnelles que le filtre a détectées et masquées dans la réponse à l'utilisateur se trouvent intégralement dans le journal.
Deux conséquences en découlent. Au regard des exigences de traitement des données personnelles, le journal devient un endroit de plus qui demande rétention, contrôle d'accès et chiffrement. Et : si tu as déployé le filtre précisément pour que des données ne soient pas stockées quelque part, activer les journaux sape l'objectif.
Il existe deux réponses, toutes deux gênantes. Tu peux désactiver les journaux d'invocation, en perdant du matériel de diagnostic. Tu peux les garder et les placer sous le même régime que les données de production. Il n'y a pas de troisième voie, et la décision mérite d'être prise délibérément, avant que quelqu'un d'extérieur ne pose la question.
Tarifs et comment les calculer
La facturation suit des unités de texte, où une unité représente jusqu'à mille caractères, et le tarif est indiqué pour mille unités.
Les filtres de contenu et les sujets interdits coûtent quinze cents pour mille unités chacun, le même prix aux deux niveaux de traitement, tandis que le filtrage d'images est facturé séparément à 0,00075 $ par image. Les filtres de mots et les motifs d'informations sensibles basés sur des expressions régulières sont gratuits. Les filtres d'informations sensibles basés sur un modèle coûtent dix cents pour mille unités, comme les contrôles d'ancrage contextuel. La vérification formelle coûte dix-sept cents pour mille unités par politique.
Cette dernière phrase cache un piège arithmétique. Le tarif s'applique par politique, donc trois politiques de vérification formelle coûtent trois fois ce montant pour le même texte. Avec plusieurs règles métier décrites séparément, la facture grandit plus vite que le nombre de requêtes ne le laisse penser.
Chaque type de filtre est facturé indépendamment, et tu ne paies que ceux que tu as activés. C'est une invitation à la discipline : tout activer parce que cela semble plus sûr multiplie le coût par le nombre de mécanismes, dont la plupart ne s'appliquent pas à ton cas.
Chiffre un appel sur tes propres données avant de l'inscrire dans un budget. Prends dix vraies interactions, compte les caractères qui entrent dans chaque filtre activé, divise par mille et multiplie par le volume quotidien. Les contrôles d'ancrage ajoutent la taille des sources, qui dépasse généralement celle de la réponse elle-même.
Versionnage et pratique d'équipe
Une configuration de guardrail est une ressource distincte avec ses propres versions, et c'est une propriété qu'il vaut mieux utiliser délibérément que découvrir par accident.
La version brouillon existe pour les expériences, et les versions numérotées sont immuables. L'application pointe vers une version précise, donc quelqu'un qui change des seuils dans la console n'atteint pas immédiatement la production. C'est le seul arrangement sensé, car un filtre modifié sans prévenir peut bloquer du trafic qui passait auparavant, et personne ne fera le lien avec un changement qu'il n'a jamais vu.
La configuration pratique ressemble à ceci : une configuration séparée pour le staging, une autre pour la production, avec le numéro de version conservé dans les variables d'environnement de l'application plutôt que dans le code. Monter la version devient alors un déploiement qu'on peut annuler.
Décide aussi qui est responsable de cette configuration. Les seuils des filtres sont une décision de produit plutôt qu'une décision technique, puisqu'ils déterminent quelle part des vrais utilisateurs est arrêtée. Une équipe où personne n'est responsable de ce chiffre finit tôt ou tard par faire tourner des réglages choisis par celui qui avait accès à ce moment-là.
Le dernier point est l'observation des événements. La réponse indique quelle politique s'est déclenchée, donc l'enregistrer avec un identifiant de session donne du matériel pour juger si le filtre fonctionne et s'il bloque les bonnes choses. Sans ces données, modifier les seuils revient à deviner.
Latence et ressenti pour l'utilisateur
Chaque contrôle ajoute du temps, et avec des réponses en streaming cela devient un problème de conception plutôt qu'une simple question de performance.
Contrôler l'entrée est simple : tu l'ajoutes avant l'appel du modèle et l'utilisateur attend un peu plus longtemps le premier caractère. Contrôler la sortie est plus difficile, car soit tu retiens tout jusqu'à la fin de la génération, en perdant tout l'intérêt du streaming, soit tu contrôles par fragments et tu risques de retirer du texte que l'utilisateur a déjà lu.
Une troisième voie contrôle par fragments tout en retardant l'affichage d'un fragment. L'utilisateur voit un flux fluide pendant que tu gardes toujours un morceau en réserve pour pouvoir s'arrêter. Cela coûte un petit délai au démarrage et c'est généralement le meilleur compromis.
Les contrôles d'ancrage ne rentrent pas dans cet arrangement, car ils ont besoin de la réponse complète avec les sources. Dans une application construite sur la recherche documentaire, tu choisis donc : le streaming sans ce contrôle, ou ce contrôle sans streaming.
Bedrock Guardrails face aux alternatives
| Option | Point fort | Point faible | À choisir quand |
|---|---|---|---|
| Bedrock Guardrails | Vérification formelle et sujets interdits | La facturation par unités se multiplie selon les politiques | Tu tournes déjà dans ce cloud |
| Azure AI Content Safety | Modération mature et détection d'injections | Quatre catégories de nuisance fixes | L'application est dans le cloud de Microsoft |
| Lakera Guard | Indépendance vis-à-vis d'un fournisseur cloud | Pas de vérification des règles métier | Tu veux un filtre interchangeable |
| Guardrails AI | Règles sous forme de code, exécution locale | L'entretien est à ta charge | Les données ne peuvent pas quitter ton infrastructure |
Deux choses distinguent la première ligne et les autres ne les égalent pas : les sujets interdits décrits en langage naturel, et la vérification formelle des règles. Si ton problème se formule « le modèle ne doit pas promettre des choses que nos conditions interdisent », c'est la seule entrée de cette liste qui y répond directement.
L'argument contre est connu et identique à celui de tout service cloud natif : une couche facile à garder indépendante finit liée à un seul fournisseur. Il existe pourtant un moyen de contourner cela, qu'il vaut la peine de connaître.
Utilisation en dehors d'un appel de modèle
Les guardrails peuvent être invoqués seuls, sans passer par un appel de modèle dans ce service. Tu fournis le texte et un identifiant de configuration et tu reçois un verdict.
Cela change la donne, car tu peux appliquer ces politiques à un modèle qui tourne ailleurs : chez un autre fournisseur, dans ta propre infrastructure ou en local. La couche de protection cesse de dicter le choix du modèle.
En pratique, cela signifie trois appels par interaction si tu contrôles l'entrée, le contenu récupéré de l'extérieur et la sortie. Chacun est facturé séparément et ajoute de la latence, donc décide dès le départ quels contrôles sont nécessaires au lieu de tous les activer par prudence.
Prévois aussi le comportement en cas d'échec. Un appel externe finira par répondre lentement ou pas du tout, et la décision de laisser passer ou de bloquer le trafic doit être prise délibérément et écrite dans le code avec un timeout.
Déploiement et choix de la force des filtres
La force des filtres se règle par catégorie, et c'est la bonne approche à condition de l'utiliser.
Commence en mode observation. Enregistre les verdicts, ne bloque rien, collecte quelques milliers de vraies interactions. C'est sur ces données seulement que tu verras combien de travail ordinaire chaque catégorie arrêterait à chaque réglage.
Adapte les seuils au domaine. Un service médical doit laisser passer les descriptions de symptômes, un service juridique cite des dossiers d'affaires, et un outil pour les équipes de sécurité des comptes rendus de vulnérabilités. Les trois sont bloqués avec des réglages généraux, et les trois sont du contenu de fond.
Décris les sujets interdits de façon étroite. Un sujet formulé largement, « finance » par exemple, tue la moitié des conversations que tu veux servir. Un sujet formulé précisément, « recommander des instruments d'investissement particuliers », fait exactement ce pour quoi il a été conçu.
Écris des messages de blocage génériques. Dire à un utilisateur quelle règle il a enfreinte et comment exactement transforme le filtre en outil d'expérimentation et facilite la recherche d'une formulation qui passe.
Erreurs courantes
La première est d'activer toutes les politiques à la fois. Le coût se multiplie par le nombre de mécanismes, la latence grimpe, et la plupart ne s'appliquent pas à ton cas.
La deuxième est d'ignorer la question de la journalisation. Le contenu bloqué atterrit en entier dans le journal, donc un filtre qui protège les données personnelles échoue à les protéger à cet endroit précis.
La troisième est de chiffrer la vérification formelle sans compter le nombre de politiques. Le tarif est par politique, donc trois règles décrites séparément coûtent trois fois.
La quatrième est de ne contrôler que ce que l'utilisateur a tapé. L'injection indirecte arrive par les documents et le contenu récupéré sur le web.
La cinquième est des sujets interdits trop larges. Un mot dans une description peut désactiver toute une catégorie de conversations que l'application devait servir.
La sixième est de s'appuyer sur le niveau de base avec un assistant qui génère du code. Sans l'extension aux éléments de code, le contenu des commentaires et des noms de variables passe sans contrôle.
FAQ
Quelles politiques Bedrock Guardrails propose-t-il ?
Six types : des filtres de contenu avec des catégories de nuisance et des attaques par prompt, des sujets interdits décrits en langage naturel, des filtres de mots à correspondance exacte, des filtres d'informations sensibles, des contrôles d'ancrage par rapport aux sources fournies, et la vérification formelle de règles que tu écris toi-même.
Que sont les contrôles par raisonnement automatisé ?
Vérifier si la réponse d'un modèle peut être conciliée avec des règles écrites en langage naturel, de façon formelle plutôt que par classification. Cela renvoie une décision avec une justification plutôt qu'une probabilité, et c'est devenu généralement disponible en août 2025.
Combien ça coûte ?
La facturation suit des unités de texte de mille caractères, indiquées pour mille unités. Les filtres de mots et les motifs d'expressions régulières sont gratuits, les filtres de contenu et les sujets interdits coûtent quinze cents chacun, les filtres d'informations sensibles et les contrôles d'ancrage dix cents chacun, et la vérification formelle dix-sept cents par politique, séparément.
Ces guardrails peuvent-ils fonctionner avec un modèle extérieur à ce service ?
Oui, les guardrails peuvent être invoqués seuls en fournissant le texte et un identifiant de configuration. Cela permet de filtrer du contenu pour un modèle qui tourne chez un autre fournisseur ou dans ta propre infrastructure, au prix d'un appel réseau supplémentaire.
Est-ce suffisant pour protéger les données personnelles ?
Les filtres détectent et masquent les données personnelles dans le contenu, alors que le contenu bloqué atterrit intégralement dans les journaux d'invocation. Avec des exigences sérieuses, il vaut la peine d'ajouter quelque chose qui tourne en local, Presidio par exemple, et de placer les journaux sous le même régime que les données de production.
Les descriptions des politiques se trouvent dans la documentation du service, et la sortie de la vérification formelle dans l'annonce d'AWS.