Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Exécutez des analyses de sécurité du code à partir de votre IDE
Exécutez des scans de sécurité du code AWS Security Agent directement depuis votre IDE à l'aide de Kiro ou Claude Code. L'intégration de l'IDE vous permet de scanner votre code source local pour détecter les failles de sécurité, d'exécuter des analyses différentielles uniquement sur le code modifié et de passer en revue les modèles de menaces sur les documents de conception, le tout sans quitter votre environnement de développement. Les résultats apparaissent à côté de votre code avec des conseils de correction, et vous pouvez appliquer des correctifs automatisés directement depuis l'IDE.
## Comment fonctionne l'intégration IDE
L'intégration IDE utilise le serveur AWS Security Agent MCP (Model Context Protocol) pour connecter votre IDE au service AWS Security Agent :
1. Le serveur MCP empaquète votre code source dans une archive ZIP.
1. L'archive est chargée dans un compartiment S3 que le serveur approvisionne automatiquement dans votre compte AWS.
1. Le serveur appelle l'API AWS Security Agent pour démarrer un scan.
1. L'agent de sécurité AWS analyse le code pour détecter les failles de sécurité et la conformité aux exigences de sécurité de votre organisation.
1. Les résultats sont renvoyés à l'IDE avec l'emplacement des codes, des descriptions, des indices de gravité et des suggestions de mesures correctives.
Le serveur MCP gère toute l'orchestration (provisionnement de l'espace agent, création du compartiment S3, configuration du rôle IAM, empaquetage du code et interrogation de scan). Vous n'avez donc besoin que des informations d'identification AWS configurées localement.
**Note**
La seule condition préalable est la configuration des informations d'identification AWS dans votre environnement local (par exemple`aws configure`, via AWS SSO ou des variables d'environnement). Le serveur MCP approvisionne automatiquement l'espace agent, le rôle de service IAM et le compartiment S3 lors de la première utilisation.
## Conditions préalables
Avant de commencer, assurez-vous de disposer des éléments suivants :
+ Informations d'identification AWS configurées localement avec les autorisations suivantes :
+ `iam:CreateRole`, `iam:PutRolePolicy` (pour une configuration unique du rôle de service)
+ `s3:CreateBucket`, `s3:PutObject`, `s3:PutPublicAccessBlock`, `s3:PutLifecycleConfiguration`
+ `securityagent:CreateAgentSpace`, `securityagent:UpdateAgentSpace`, `securityagent:ListAgentSpaces`, `securityagent:BatchGetAgentSpaces`
+ `securityagent:CreateCodeReview`, `securityagent:StartCodeReviewJob`, `securityagent:BatchGetCodeReviewJobs`
+ `securityagent:ListFindings`, `securityagent:BatchGetFindings`
+ `securityagent:StartCodeRemediation`(pour les corrections automatisées)
+ `sts:GetCallerIdentity`
+ [uv](https://docs.astral.sh/uv/getting-started/installation/) installé (exécuteur de paquets Python)
+ Python 3.10 ou version ultérieure
+ L'un des IDE suivants :
+ [Kiro](https://kiro.dev) (installation de l'AWS Security Agent Power)
+ Claude Code (installez le plug-in AWS Security Agent)
## Installation du serveur MCP
### Kiro
Installez **AWS Security Agent** Power depuis le Kiro Marketplace. Le Power regroupe la configuration du serveur MCP, les instructions de pilotage et les hooks du cycle de vie pour des suggestions d'analyse de sécurité automatiques.
Vous pouvez également configurer le serveur MCP manuellement dans le fichier de `.kiro/mcp.json` votre projet :
```
{
"mcpServers": {
"security-agent": {
"command": "uvx",
"args": ["awslabs.security-agent-mcp-server@latest"],
"env": {
"AWS_PROFILE": "default",
"AWS_REGION": "us-east-1",
"FASTMCP_LOG_LEVEL": "ERROR"
}
}
}
}
```
### Claude Code
Installez le plug-in AWS Security Agent, qui fournit des compétences en matière de configuration, d'analyses complètes, d'analyses différentielles, de révision des modèles de menaces et de correction.
Configurez le serveur MCP dans celui de `.mcp.json` votre projet :
```
{
"mcpServers": {
"awslabs.security-agent-mcp-server": {
"command": "uvx",
"args": ["awslabs.security-agent-mcp-server@latest"],
"env": {
"AWS_PROFILE": "default",
"AWS_REGION": "us-east-1",
"FASTMCP_LOG_LEVEL": "ERROR"
}
}
}
}
```
**Astuce**
Vous pouvez également exécuter le serveur MCP via Docker si vous préférez ne pas installer Python localement. Consultez la [documentation du serveur MCP pour la configuration](https://github.com/awslabs/mcp) de Docker.
## First-time configuration
Lors de la première utilisation, le serveur MCP met automatiquement en service les ressources AWS requises :
| Ressource | Convention de dénomination | Objectif |
| --- | --- | --- |
| Espace des agents | User-chosen ou créé automatiquement | Conteneur pour les scans, les révisions et les pentests |
| Rôle de service IAM | `SecurityAgentScanRole` | Supposé par `securityagent.amazonaws.com` pour lire le code téléchargé |
| compartiment S3 | `security-agent-scans-{account}-{region}` | Stocke le code source compressé (cycle de vie d'expiration automatique de 30 jours) |
Pour déclencher la configuration de manière explicite, demandez à votre IDE :
```
Set up the security agent
```
La configuration vérifie vos informations d'identification AWS, crée ou réutilise un espace d'agent, provisionne le rôle IAM et le compartiment S3, et confirme que vous êtes prêt. Si vous disposez déjà d'espaces d'agent depuis l'AWS Management Console, le programme d'installation les affiche et vous demande lequel utiliser.
**Note**
Le programme d'installation s'exécute automatiquement lors de votre première analyse s'il n'est pas déjà configuré. Il n'est pas nécessaire de l'exécuter séparément.
## Exécuter une analyse de sécurité complète
Analysez l'ensemble de votre projet pour détecter les failles de sécurité :
```
Scan this project for security issues
```
L'IDE :
1. Archive votre code source (à l'exception `.git` des artefacts de construction et des autres répertoires non essentiels) `node_modules`
1. Télécharge l'archive sur S3
1. Démarre une tâche de révision complète du code
1. Sondages à compléter (généralement environ 1 heure)
1. Présente les résultats regroupés par gravité
### Progression du scan
Les analyses complètes prennent généralement environ 1 heure selon la taille de la base de code. L'IDE vérifie la progression toutes les 5 minutes et vous avertit lorsque les résultats sont prêts. Vous pouvez demander le statut à tout moment :
```
How's the scan going?
```
## Exécuter un scan différentiel
Pour un feedback plus rapide pendant le développement, scannez uniquement le code qui a changé depuis une référence git :
```
Scan my changes against main for security issues
```
Par défaut, si vous ne spécifiez pas de référence de base, l'analyse compare vos modifications non validées avec celles-ci. `HEAD` Vous pouvez spécifier une base différente de manière explicite :
```
Diff scan my uncommitted changes
```
Les analyses différentielles téléchargent à la fois le contexte complet du référentiel et le correctif git diff, puis exécutent une analyse axée uniquement sur les lignes modifiées. Les résultats arrivent généralement en 5 à 15 minutes.
Pour plus d'informations sur l'API de scan différentiel S3, consultez[Exécuter un scan de code différentiel avec S3](run-diff-scan-s3.md).
## Exécuter un examen du modèle de menace
Analysez les documents de conception pour détecter les changements de posture de sécurité à l'aide de la méthodologie STRIDE :
```
Run a threat model review on my spec
```
L'IDE identifie vos `design.md` fichiers `requirements.md` et (généralement sous`.kiro/specs/`), les télécharge avec votre code source et exécute une analyse du modèle de menace. Les résultats identifient :
+ Menaces de sécurité classées par STRIDE (usurpation d'identité, falsification, répudiation, divulgation d'informations, déni de service, élévation de privilèges)
+ Cotes de gravité pour chaque menace
+ Impact sur des actifs spécifiques de votre base de code
+ Recommandations en matière d'atténuation
**Astuce**
Révisez le modèle de menace avant de générer des tâches de mise en œuvre à partir d'une spécification. Cela permet de détecter les problèmes de conception de sécurité avant que le code ne soit écrit.
## Examen des résultats
Une fois l'analyse terminée, les résultats apparaissent dans votre IDE regroupés par gravité :
```
🟣 CRITICAL: SQL Injection in user-service.ts
File: src/api/user-service.ts:45
User input flows directly into SQL query without parameterization
🔴 HIGH: Hardcoded credentials in config.ts
File: src/config/database.ts:12
Database password stored in source code
```
Un rapport détaillé est également rédigé `.security-agent/findings-{scan_id}.md` avec des informations complètes pour chaque constatation, notamment le type de risque, le score de confiance, l'emplacement des codes et le code de correction.
Pour consulter les résultats d'une analyse précédente, procédez comme suit :
```
Show my security findings
```
## Appliquer des correctifs automatisés
Après avoir examiné les résultats, appliquez des mesures correctives automatisées :
```
Fix the security findings
```
L'IDE analyse les résultats du haut vers le bas en fonction de leur gravité (Critique → Élevé → Moyen → Faible), en appliquant des corrections de code en utilisant les conseils de correction fournis pour chaque résultat. Une fois tous les correctifs appliqués, il exécute automatiquement un scan de vérification pour confirmer que les problèmes sont résolus.
Vous pouvez également corriger des résultats individuels :
```
Fix the SQL injection in user-service.ts
```
**Important**
Passez toujours en revue les correctifs automatisés avant de les valider. Vérifiez que les correctifs ne perturbent pas les fonctionnalités existantes et n'introduisent pas de régressions.
## Suggestions de numérisation automatique (Kiro)
Lorsque vous utilisez le Kiro Power, l'agent de sécurité AWS peut automatiquement suggérer des analyses différentielles une fois que vous avez apporté des modifications de code sensibles à la sécurité. The Power installe un crochet qui évalue chaque tour de codage terminé et suggère un scan lorsque les modifications affectent :
+ Logique d'authentification ou d'autorisation
+ Cryptographie ou gestion des secrets
+ Validation des entrées ou nettoyage des données
+ Demandes réseau ou intégrations externes
+ Configuration de sécurité (CORS, en-têtes, gestion de session)
Vous pouvez désactiver les suggestions automatiques à tout moment en les supprimant`.kiro/hooks/security-diff-scan-suggester.kiro.hook`.
## Types de scan disponibles
| Type d'analyse | Duration | Cas d’utilisation | Commande |
| --- | --- | --- | --- |
| Analyse complète | Environ 1 heure | Examen complet de l'ensemble de la base de code | « Scannez mon projet pour détecter des problèmes de sécurité » |
| Numérisation différentielle | 5 à 15 minutes | Code modifié uniquement (pré-commit, pré-PR) | « Analyser mes modifications » ou « Analyser différemment par rapport au fichier principal » |
| Modèle de la menace | 5 à 30 minutes | Documents de conception (requirements.md, design.md) | « Exécuter un examen du modèle de menace selon mes spécifications » |
## Variables d’environnement
| Variable | Description | Par défaut |
| --- | --- | --- |
| `AWS_REGION` | Région AWS pour les appels SecurityAgent d'API | `us-east-1` |
| `AWS_PROFILE` | Nom du profil d'identification AWS | Profil par défaut |
| `FASTMCP_LOG_LEVEL` | Niveau de journalisation du serveur MCP (DEBUG, INFO, WARNING, ERROR) | `WARNING` |
## Résolution des problèmes
### « Non configuré. Exécutez d'abord le programme d'installation. »
`.security-agent/config.json`Il vous manque ou l'espace agent n'existe plus. Demandez à l'IDE d'exécuter le programme d'installation :
```
Set up the security agent
```
### Le scan échoue avec AccessDenied
Assurez-vous que vos informations d'identification AWS disposent des autorisations IAM requises répertoriées dans la section Conditions préalables. L'autorisation manquante la plus courante est `iam:CreateRole` (nécessaire uniquement pour la première configuration).
### Le scan expire ou prend trop de temps
+ Les analyses complètes sur de grandes bases de code peuvent prendre plus d'une heure
+ Utilisez des scans différentiels pour le développement itératif : ils se terminent en quelques minutes
+ Vérifiez que votre archive source ne contient pas de répertoires inutiles (le serveur MCP exclut automatiquement les modèles courants)
### Différentiel vide : aucune modification à scanner
Si vous exécutez une analyse différentielle sans aucune modification non validée, le serveur MCP indique « Aucune modification par rapport à HEAD » et ne lance pas d'analyse. Commencez par valider ou organiser vos modifications, ou spécifiez une référence de base différente.
## Quotas et limites
+ Taille maximale de l'archive source : 2 Go
+ Cycle de vie du compartiment S3 : le code téléchargé est automatiquement supprimé au bout de 30 jours
## Étapes suivantes
Après avoir exécuté votre première analyse de sécurité IDE :
+ Activez les commentaires de révision du code pull request pour une GitHub intégration automatisée (voir[Activer la révision du code de pull request pour les GitHub référentiels](enable-code-review.md))
+ Configurer les exigences de sécurité pour la validation des politiques spécifiques à l'organisation (voir) [Gérer les exigences de sécurité](security-requirements.md)
+ Exécutez des analyses complètes périodiques pour détecter les problèmes dans l'ensemble de votre base de code (voir[Création d'une révision de code](perform-code-review-scan.md))
+ Utilisez les révisions des modèles de menace pour les nouvelles spécifications des fonctionnalités avant leur mise en œuvre