Construire un agent d'Attack Surface Management prêt pour la production avec AWS Bedrock tout en maîtrisant…

Nous avons architecturé un système autour d'Amazon Bedrock et de Strands Agents, en associant modèles de raisonnement, automatisation de navigateur, retrieval-augmented generation et observabilité de niveau production.

Les principaux composants AWS retenus :

| Composant                  | Service                              | Rôle                                                       |
| -------------------------- | ------------------------------------ | ---------------------------------------------------------- |
| **Foundation Model**       | Amazon Bedrock avec Claude           | Accès serverless à des LLM de pointe via une API unifiée   |
| **Agent Framework**        | Strands Agents                       | SDK pour construire et orchestrer des agents               |
| **Couche d'outillage**     | Model Context Protocol (MCP)         | Interface entre l'agent et les outils externes             |
| **Retrieval**              | Bedrock Knowledge Bases + OpenSearch | Vector store pour le grounding et le RAG                   |
| **Runtime**                | AWS Fargate & Bedrock AgentCore      | Environnements d'exécution entièrement managés             |
| **Observabilité**          | CloudWatch & LangFuse                | Tracing, logging et métriques.                             |
| **Infrastructure as Code** | AWS CDK                              | Automatisation du déploiement                              |

Et la manière dont ils s'articulent :

Détaillons chacun d'eux dans les sections suivantes.

Commençons par les fondations : la manière dont l'agent raisonne. AWS Bedrock donne un accès simplifié à des modèles de raisonnement avancés, comme la famille Nova d'Amazon, les modèles Claude d'Anthropic, ainsi que de nombreux modèles open source tels que Mistral, DeepSeek ou Llama. Ces modèles prennent déjà en charge le raisonnement de type chain-of-thought, ce qui permet à l'agent de produire des étapes intermédiaires de réflexion avant de tirer ses conclusions et de passer à l'action. Cette capacité de raisonnement est essentielle, car chaque action de navigation et chaque observation s'appuient sur la précédente.

Côté orchestration, Strands Agents propose une abstraction élégante de la boucle d'agent : en son cœur, un cycle de raisonnement, d'utilisation d'outils et de génération de réponses. L'intégration avec les modèles Bedrock est transparente et ses primitives de niveau production couvrent la gestion d'état de session, la coordination multi-agents et le contrôle du contexte.

Voici un court extrait du code de l'agent qui illustre la simplicité avec laquelle Strands permet de développer un agent :

all_tools = [retrieve]

with playwright_mcp_client, filesystem_mcp_client:
    playwright_tools = playwright_mcp_client.list_tools_sync()
    filesystem_tools = filesystem_mcp_client.list_tools_sync()
    all_tools.extend(playwright_tools + filesystem_tools)

    agent = Agent(
        model=bedrock_model,
        system_prompt=system_prompt,
        tools=all_tools,
    )

Cette boucle permet à l'agent de naviguer de façon autonome, de raisonner sur ses observations et de conserver son état entre chaque étape.

Mais le raisonnement seul ne suffit pas : l'agent doit aussi interagir avec le monde extérieur.

L'outillage repose sur le Model Context Protocol (MCP), un standard ouvert qui connecte les LLM à des systèmes externes. Chaque serveur MCP expose un catalogue d'outils avec définitions et schémas explicites, que l'agent peut appeler dynamiquement à l'exécution.

Pour ce cas d'usage, nous avons combiné trois sources d'outils :

1. retrieve : pour interroger sémantiquement la base de vulnérabilités.
2. Playwright MCP : pour la navigation web et les interactions avec les sites.
3. Filesystem MCP : pour un stockage persistant simple et la journalisation.

En cours de développement, en août 2025, AWS a annoncé AgentCore, qui s'accompagne de son propre Browser Tool et nous évite d'avoir à gérer notre propre infrastructure Playwright. Il fournit un environnement de navigateur entièrement managé et isolé, avec intégration IAM et observabilité CloudTrail, et s'insère proprement dans le code existant :

from strands_tools.browser.agent_core_browser import AgentCoreBrowser
all_tools = [retrieve, AgentCoreBrowser().browser]

Grâce à la modularité de Strands, le passage d'un outillage de navigation auto-hébergé à un service managé plus sûr et plus scalable s'est fait sans difficulté.

Pour permettre à l'agent de raisonner à partir de données réelles, nous l'avons ancré dans la base du programme CVE™, un référentiel de vulnérabilités connues.

Avec Amazon Bedrock Knowledge Bases, nous avons importé le jeu de données CVE, qu'AWS a automatiquement découpé en chunks, vectorisé et indexé dans OpenSearch Serverless, prêt à être interrogé.

L'outil retrieve permet ensuite à l'agent d'interroger ce vector store à l'exécution, en lui donnant accès à des connaissances à jour sur les vulnérabilités pertinentes pour chaque actif client rencontré. Le pipeline managé d'ingestion et de retrieval de Bedrock Knowledge Bases nous a fait gagner un temps d'ingénierie considérable par rapport à un flux RAG développé sur mesure.

Après avoir validé le prototype en local, nous avons mis la solution en production via deux runtimes managés :

1. AWS Fargate

Un déploiement conteneurisé empaqueté avec Docker et orchestré via AWS CDK. Cette configuration offre un contrôle complet sur le scaling et le réseau, et s'avère idéale lorsqu'on a besoin de plus de maîtrise ou que l'on doit gérer des dépendances spécifiques (comme les serveurs MCP).

2. Amazon Bedrock AgentCore

AgentCore propose une abstraction de plus haut niveau encore : vous définissez l'agent et sa configuration, AWS se charge de l'exécuter pour vous.

Avec quelques ajustements de code, principalement le passage du stockage sur système de fichiers au système d'état de Strands, le même agent s'est exécuté en mode entièrement managé, sans configuration CDK ni VPC, simplement via agentcore configure et agentcore launch depuis le starter kit Agentcore. Pour itérer rapidement avec un minimum de charge opérationnelle, l'approche est imbattable.

Surveiller le comportement de l'agent est aussi important que de le concevoir.

Pour les équipes qui préfèrent une analytique externe, LangFuse s'intègre sans effort via OpenTelemetry et fournit une chronologie fine des boucles, des appels au modèle et des invocations d'outils. Vous obtenez ainsi une vision étape par étape de ce que votre agent pense et des outils qu'il choisit, ce qui s'avère essentiel pour le débogage et l'amélioration continue.

Depuis le lancement d'AgentCore, AgentCore Observability est également disponible, avec une intégration native à CloudWatch, qui dispose désormais d'un dashboard GenAI Observability capturant traces, métriques et logs à chaque invocation. Les Engineers peuvent visualiser la consommation de tokens et les taux d'erreur, et inspecter les sessions, transformant la boîte noire du raisonnement des LLM en données mesurables.

Dans le prolongement de l'observabilité, comprendre l'impact financier avant un déploiement en production doit également rester une priorité.

Chez DoiT, nous avons lancé le GenAI Lens, intégré à notre plateforme DoiT Cloud Intelligence™, pour vous aider à analyser les schémas de dépense des workloads d'IA générative.

Il s'intègre directement à Amazon Bedrock, ainsi qu'à Anthropic et OpenAI, et vous offre une visibilité sur les modèles et les workloads qui pèsent le plus dans vos coûts.

Pour aller plus loin dans l'analyse, DataHub vous permet d'embarquer l'ingestion de données directement dans votre application. Avec le labeling et des dashboards personnalisés, vous pouvez suivre les coûts par domaine ou par client, et même calculer un coût par vulnérabilité détectée, transformant ainsi vos insights de sécurité en ROI mesurable.

De l'ingestion des données au raisonnement et à l'observabilité, l'écosystème AWS a fourni tous les blocs nécessaires pour donner vie à cet agent ASM autonome, de manière sécurisée, scalable et avec une gestion d'infrastructure réduite au minimum, en particulier depuis qu'AgentCore est passé en GA.

Nos tests sur testphp.vulnweb.com ont montré que le système est capable de détecter des scénarios d'injection SQL, de XSS réfléchi et stocké, de contournement d'authentification, et même de compromission active de site. Ces résultats valident la capacité de l'agent à parcourir des flux web de manière autonome, à injecter des payloads, à interpréter les preuves d'exécution et à corréler les résultats avec la base CVE, le tout avec une supervision humaine minimale. Au-delà de la précision technique, l'expérience démontre tout l'intérêt de coupler raisonnement autonome, retrieval en temps réel et observabilité, pour transformer des scans de vulnérabilités bruts en intelligence structurée et explicable.

Les pistes d'évolution sont nombreuses : affiner les capacités de reporting, évaluer les performances sur des benchmarks reconnus ou intégrer d'autres bases de vulnérabilités. Mais même dans sa forme actuelle, ce projet montre comment AWS Bedrock + Strands Agents peuvent traduire la promesse de l'IA générative en valeur opérationnelle pour la cybersécurité.

L'intégralité du code source et les détails d'implémentation sont disponibles sur GitHub, et une version longue est accessible ici.

—

Simplifiez votre démarche FinOps avec nous : échangez avec nos équipes via doit.com/services !