Résumé Conditions préalables et limitations Architecture Outils Bonnes pratiques Épopées Résolution des problèmes Ressources connexes Informations supplémentaires

Déployez la validation de la sécurité du codage en temps réel à l'aide d'un serveur MCP avec Kiro et d'autres assistants de codage

Ivan Girardi et Iker Reina Fuente, Amazon Web Services

Résumé

Ce modèle décrit comment implémenter un serveur MCP (Model Context Protocol) qui intègre trois outils d'analyse de sécurité conformes aux normes du secteur afin de fournir une analyse complète de la sécurité du code. Le serveur permet aux assistants de codage basés sur l'IA (tels que Kiro, Amazon Q Developer et Cline) de scanner automatiquement les extraits de code et les configurations d'infrastructure en tant que code (iAc). Grâce à ces scans, les assistants de codage peuvent aider à identifier les failles de sécurité, les erreurs de configuration et les violations de conformité.

Les générateurs de code basés sur l'IA entraînés sur des millions d'extraits de code créent un angle mort en matière de sécurité. Dans quelle mesure ces données d'entraînement étaient-elles sécurisées ? Ce modèle fournit une validation de sécurité en temps réel lors de la génération du code, aidant ainsi les développeurs à identifier et à comprendre les problèmes de sécurité potentiels lors du codage. Cette approche aide les développeurs à remédier à la fois aux vulnérabilités directes et aux risques hérités des dépendances. En comblant le fossé entre l'efficacité de l'IA et la conformité en matière de sécurité, ce modèle permet d'adopter en toute sécurité les outils de développement basés sur l'IA.

Ce modèle aide les entreprises à améliorer leurs pratiques de sécurité du développement grâce à des outils de codage assistés par l'IA, fournissant des fonctionnalités d'analyse de sécurité continue dans plusieurs langages de programmation et définitions d'infrastructure. La solution combine les fonctionnalités des outils suivants :

Vérifiez si vous scannez les fichiers iAC, y compris Terraform et les manifestes AWS CloudFormation Kubernetes
Semgrep pour analyser plusieurs langages de programmation tels que Python JavaScript, Java et autres
Bandit pour l'analyse de sécurité spécialisée en Python

Les principales fonctionnalités de cette solution sont les suivantes :

Scan delta de nouveaux segments de code, réduisant ainsi les frais de calcul
Environnements d'outils de sécurité isolés, empêchant la contamination entre outils
Intégration parfaite avec les assistants de codage basés sur l'IA (Kiro, Amazon Q Developer, Cline, etc.)
Feedback de sécurité en temps réel pendant la génération du code
Règles de numérisation personnalisables pour garantir la conformité de l'organisation

Le modèle fournit une interface unifiée pour l'analyse de sécurité avec des formats de réponse standardisés, ce qui facilite l'intégration des contrôles de sécurité dans les flux de travail de développement. Le modèle utilise Python et le framework MCP pour fournir des informations de sécurité automatisées. Cette approche aide les développeurs à identifier et à résoudre les problèmes de sécurité dès le début du processus de développement tout en découvrant les meilleures pratiques en matière de sécurité grâce à des résultats détaillés.

Conditions préalables et limitations

Conditions préalables

Un développeur actif Compte AWS ayant accès à Kiro ou Amazon Q Developer, si vous souhaitez utiliser l'un de ces assistants de codage
Python version 3.10 ou ultérieure installée
uvgestionnaire de paquets installé
Connaissance des outils et des concepts d'analyse de sécurité
Compréhension de base de l'IAC et de la sécurité des applications

Limites

L'analyse des bandits est limitée aux fichiers Python uniquement.
L'analyse en temps réel peut avoir un impact sur les performances des bases de code volumineuses.
Les limitations spécifiques à l'outil sont basées sur les formats de fichiers et les langues pris en charge.
Un examen manuel est nécessaire pour valider les résultats de sécurité.
Les résultats des analyses de sécurité nécessitent une expertise en matière de sécurité pour une interprétation correcte.
Certains Services AWS ne sont pas disponibles du tout Régions AWS. Pour connaître la disponibilité par région, consultez la section AWS Services par région. Pour des points de terminaison spécifiques, consultez Points de terminaison de service et quotas, puis choisissez le lien correspondant au service.

Versions du produit

Python version 3.10 ou ultérieure
Checkov version 3.0.0 ou ultérieure
Semgrep version 1.45.0 ou ultérieure
Bandit version 1.7.5 ou ultérieure
MCP [cli] version 1.11.0 ou ultérieure
Pydantic version 1.10.0 ou ultérieure
Loguru version 0.6.0 ou ultérieure

Architecture

Le schéma suivant montre l'architecture de cette solution.

Les assistants IA envoient du code au serveur du scanner de sécurité MCP pour le rediriger vers des scanners spécialisés ; les résultats du scan sont envoyés au développeur.

Le schéma suivant illustre le flux de travail suivant :

Le développeur utilise des assistants d'intelligence artificielle (par exemple, Kiro, Cline, Amazon Q Developer ou Roo Code) pour générer ou analyser du code. L'assistant AI envoie le code pour le scan de sécurité.
Le serveur du scanner de sécurité MCP traite la demande en l'acheminant vers le scanner spécialisé approprié : Checkov pour les fichiers IaC, Semgrep pour l'analyse de plusieurs langages de programmation ou Bandit pour le scan de sécurité spécifique à Python.
Les résultats du scanner contenant les résultats de sécurité, les niveaux de gravité, les descriptions détaillées et les solutions suggérées sont renvoyés au développeur via l'assistant AI.
Une boucle de feedback continue est établie dans le cadre de laquelle le développeur reçoit une validation de sécurité en temps réel, permettant des corrections automatisées par le biais d'assistants IA et promouvant les meilleures pratiques de sécurité pendant le développement.

L'architecture atténue les risques de sécurité courants suivants :

Injection de commandes
Injection rapide
Traversée du chemin
Attaques de dépendance
Épuisement des ressources

L'architecture atténue ces risques de sécurité courants en mettant en œuvre les meilleures pratiques suivantes :

Toutes les entrées des utilisateurs et des modèles d'IA sont écrites dans des fichiers temporaires.
Aucune entrée directe n'est fournie aux commandes de l'interface de ligne de commande (CLI).
L'accès au système de fichiers est limité aux répertoires et fichiers temporaires uniquement.
Les fichiers temporaires sont automatiquement nettoyés.
Les réponses de numérisation sont nettoyées.
L'isolation des processus qui limite les capacités des processus est appliquée.
Toutes les activités de numérisation sont enregistrées.

Automatisation et mise à l'échelle

Le modèle prend en charge l'automatisation grâce aux fonctionnalités suivantes :

Intégration avec les assistants de codage AI pour la numérisation automatique du code
Réponses d'API standardisées pour un traitement automatisé
Configuration via les fichiers de configuration MCP
Support pour le traitement par lots de plusieurs fichiers
Numérisation évolutive dans plusieurs langages de programmation et formats iAc

Le processus de numérisation peut être automatisé via les points de terminaison de l'API fournis :

scan_with_checkovpour la numérisation iAc
scan_with_semgreppour la numérisation de codes multilingues
scan_with_banditpour un scan spécifique à Python
get_supported_formatspour la validation du format

Lorsque vous étendez les outils de numérisation, suivez les principes de conception et les meilleures pratiques décrits plus haut dans cette section. Voir également Bonnes pratiques.

Outils

Services AWS

Kiro est un service de codage agentique qui travaille aux côtés des développeurs pour transformer les instructions en spécifications détaillées, puis en code fonctionnel, en documents et en tests. Les agents Kiro aident les développeurs à résoudre des problèmes complexes et à automatiser des tâches telles que la génération de documentation et les tests unitaires.
Amazon Q Developer est un assistant conversationnel génératif alimenté par l'IA qui peut vous aider à comprendre, créer, étendre et exploiter des applications. AWS

Autres outils

Bandit est un outil de scanner de sécurité Python spécialisé. Il détecte les problèmes de sécurité courants liés à Python, tels que les fonctions non sécurisées, les secrets codés en dur et les vulnérabilités d'injection. Bandit fournit des cotes de confiance et de gravité détaillées.
Checkov est un outil d'analyse de code statique qui vérifie les erreurs de configuration liées à la sécurité et à la conformité dans iAc. En outre, Checkov détecte les violations de conformité et les meilleures pratiques de sécurité.
Cline est un assistant de codage alimenté par l'IA qui fonctionne dans VS Code.
Loguru est une bibliothèque de validation de données pour Python.
Le Model Context Protocol (MCP) est un framework open source permettant de créer des outils de développement assistés par l'IA.
Pydantic est une bibliothèque de validation de données pour Python.
Semgrep analyse le code source pour détecter les failles de sécurité et les bogues. Il prend en charge plusieurs langages de programmation. Semgrep utilise des ensembles de règles axés sur la sécurité pour une analyse complète. Il fournit des cotes de confiance et de gravité détaillées.

Référentiel de code

Le code de ce modèle est disponible dans le référentiel GitHub MCP Security Scanner : Real-Time Protection for AI Code Assistants. Le référentiel inclut l'implémentation du serveur MCP, des détails sur la configuration MCP pour Kiro, Amazon Q Developer, Cline et d'autres, des exemples de configuration et des utilitaires de test.

La structure du référentiel inclut :

security_scanner_mcp_server/- Implémentation du serveur principal
docs/- Documentation et matériel de démonstration
tests/- Fichiers de test
mcp-config-example.json- Exemple de configuration MCP
requirements.txt- Dépendances du projet

Bonnes pratiques

Mise en œuvre du scan de sécurité

Passez en revue les résultats de sécurité pour valider et hiérarchiser les problèmes.
Maintenez les outils de numérisation (Checkov, Semgrep et Bandit) à jour avec les dernières versions.
Utilisez l'outil de sécurité MCP de ce modèle en conjonction avec d'autres mesures et outils de sécurité.
Mettez régulièrement à jour les ensembles de règles et les politiques de sécurité.

Gestion de configuration

Utilisez les fichiers de configuration MCP dans la source de contrôle de version officielle.
Documentez les règles et les configurations personnalisées.

Integration

Intégrez l'analyse de sécurité dès le début du cycle de développement.
Configurez le scan automatique dans les hooks de pré-validation ou dans les pipelines d'intégration et de déploiement continus (CI/CD).
Configurez des seuils de gravité adaptés à votre environnement.
Établissez des procédures claires pour traiter les résultats de sécurité.

Considérations opérationnelles

Surveillez les performances de numérisation et l'utilisation des ressources.
Mettez en œuvre une gestion et une journalisation appropriées des erreurs.
Tenez à jour la documentation des configurations personnalisées.
Établissez un processus de révision et de mise à jour des règles de sécurité.

Gardez également à l'esprit les meilleures pratiques suivantes :

Validez toujours les résultats de sécurité dans votre contexte spécifique.
Maintenez les outils de sécurité et les dépendances à jour.
Utilisez plusieurs outils de sécurité pour une couverture complète.
Suivez les meilleures pratiques de sécurité dans votre processus de développement.

Épopées

Sous-tâche Description Compétences requises

Sous-tâche	Description	Compétences requises
Configurez les paramètres MCP.	Vous pouvez modifier les fichiers de configuration dans Kiro soit en (Option 1) en localisant manuellement les fichiers de configuration, soit (Option 2) en utilisant l'IDE Kiro. (Option 1) Localisez et modifiez les fichiers de configuration manuellement comme suit : Chemin : `.kiro/settings/mcp.json` (local) ou `~/.kiro/settings/mcp.json` (global) (Option 2) Modifiez les fichiers de configuration à l'aide de l'IDE Kiro comme suit : Choisissez le symbole Kiro dans le menu de navigation de gauche. Accédez à la section « SERVEURS MCP ». Modifiez les paramètres de configuration. Les modifications apportées avec l'IDE Kiro seront enregistrées dans l'un des fichiers de configuration suivants : `.kiro/settings/mcp.json` (local) ou `~/.kiro/settings/mcp.json` (global) (Les deux options) Après avoir terminé l'option 1 ou l'option 2, ajoutez la configuration du scanner de sécurité `.kiro/settings/mcp.json` (locale) ou `~/.kiro/settings/mcp.json` (globale) : `{ "mcpServers": { "security-scanner": { "command": "uvx", "args": [ "--from", "git+https://github.com/aws-samples/sample-mcp-security-scanner.git@main", "security_scanner_mcp_server" ], "env": { "FASTMCP_LOG_LEVEL": "ERROR" }, "disabled": false, "autoApprove": [] } } }`	Développeur d’applications

Configurez les paramètres MCP.

Vous pouvez modifier les fichiers de configuration dans Kiro soit en (Option 1) en localisant manuellement les fichiers de configuration, soit (Option 2) en utilisant l'IDE Kiro.

(Option 1) Localisez et modifiez les fichiers de configuration manuellement comme suit :
- Chemin : .kiro/settings/mcp.json (local) ou ~/.kiro/settings/mcp.json (global)
(Option 2) Modifiez les fichiers de configuration à l'aide de l'IDE Kiro comme suit :
- Choisissez le symbole Kiro dans le menu de navigation de gauche.
- Accédez à la section « SERVEURS MCP ».
- Modifiez les paramètres de configuration. Les modifications apportées avec l'IDE Kiro seront enregistrées dans l'un des fichiers de configuration suivants : .kiro/settings/mcp.json (local) ou ~/.kiro/settings/mcp.json (global)
(Les deux options) Après avoir terminé l'option 1 ou l'option 2, ajoutez la configuration du scanner de sécurité .kiro/settings/mcp.json (locale) ou ~/.kiro/settings/mcp.json (globale) :


{
  "mcpServers": {
    "security-scanner": {
      "command": "uvx",
      "args": [
        "--from",
        "git+https://github.com/aws-samples/sample-mcp-security-scanner.git@main",
        "security_scanner_mcp_server"
      ],
      "env": {
        "FASTMCP_LOG_LEVEL": "ERROR"
      },
      "disabled": false,
      "autoApprove": []
    }
  }
}

Développeur d’applications

Sous-tâche Description Compétences requises

Sous-tâche	Description	Compétences requises
Configurez les paramètres MCP.	Pour configurer les paramètres MCP manuellement, procédez comme suit : Modifiez le fichier de configuration MCP au niveau `~/.aws/amazonq/mcp.json` (global) ou `.amazonq/mcp.json` (local). Ajoutez la configuration du scanner de sécurité suivante `~/.aws/amazonq/mcp.json` (globale) ou `.amazonq/mcp.json` (locale) : `{ "mcpServers": { "security-scanner": { "command": "uvx", "args": [ "--from", "git+https://github.com/aws-samples/sample-mcp-security-scanner.git@main", "security_scanner_mcp_server" ], "env": { "FASTMCP_LOG_LEVEL": "ERROR" } } } }`	Développeur d’applications

Configurez les paramètres MCP.

Pour configurer les paramètres MCP manuellement, procédez comme suit :

Modifiez le fichier de configuration MCP au niveau ~/.aws/amazonq/mcp.json (global) ou .amazonq/mcp.json (local).
Ajoutez la configuration du scanner de sécurité suivante ~/.aws/amazonq/mcp.json (globale) ou .amazonq/mcp.json (locale) :


{
  "mcpServers": {
    "security-scanner": {
      "command": "uvx",
      "args": [
        "--from",
        "git+https://github.com/aws-samples/sample-mcp-security-scanner.git@main",
        "security_scanner_mcp_server"
      ],
      "env": {
        "FASTMCP_LOG_LEVEL": "ERROR"
      }
    }
  }
}

Développeur d’applications

Sous-tâche Description Compétences requises

Sous-tâche	Description	Compétences requises
Configurez les paramètres MCP.	Pour configurer les paramètres MCP manuellement, procédez comme suit : Choisissez l'extension pour l'ouvrir, puis sélectionnez Serveurs MCP. Choisissez l'onglet Installé, puis sélectionnez Configurer les serveurs MCP pour ouvrir le `cline_mcp_settings.json` fichier. Ajoutez la configuration du scanner de sécurité suivante : `cline_mcp_settings.json` `{ "mcpServers": { "security-scanner": { "command": "uvx", "args": [ "--from", "git+https://github.com/aws-samples/sample-mcp-security-scanner.git@main", "security_scanner_mcp_server" ], "env": { "FASTMCP_LOG_LEVEL": "ERROR" }, "disabled": false, "autoApprove": [] } } }`	Développeur d’applications

Configurez les paramètres MCP.

Pour configurer les paramètres MCP manuellement, procédez comme suit :

Choisissez l'extension pour l'ouvrir, puis sélectionnez Serveurs MCP.
Choisissez l'onglet Installé, puis sélectionnez Configurer les serveurs MCP pour ouvrir le cline_mcp_settings.json fichier.
Ajoutez la configuration du scanner de sécurité suivante : cline_mcp_settings.json


{
  "mcpServers": {
    "security-scanner": {
      "command": "uvx",
      "args": [
        "--from",
        "git+https://github.com/aws-samples/sample-mcp-security-scanner.git@main",
        "security_scanner_mcp_server"
      ],
      "env": {
        "FASTMCP_LOG_LEVEL": "ERROR"
      },
      "disabled": false,
      "autoApprove": []
    }
  }
}

Développeur d’applications

Sous-tâche Description Compétences requises

Sous-tâche	Description	Compétences requises
Effectuez une analyse de code.	Pour effectuer une analyse de code à l'aide de Python et de Bandit, procédez comme suit : Créez un nouveau fichier Python nommé `bandit_test.py` avec le contenu suivant : import pickle import yaml import subprocess from flask import Flask, request import hashlib app = Flask(__name__) @app.route("/unsafe_pickle", methods=["POST"]) def unsafe_pickle_usage(): data = request.get_data() return pickle.loads(data) @app.route("/command_injection", methods=["GET"]) def command_injection(): command = request.args.get("cmd") return subprocess.Popen(command, shell=True) def weak_crypto(): password = "secret_password" return hashlib.md5(password.encode()).hexdigest() PASSWORD = "super_secret_password123" Ouvrez l'assistant de codage. Demandez les actions suivantes dans le chat : Scannez le script actuel et donnez-moi les résultats.	Développeur d’applications

Effectuez une analyse de code.

Pour effectuer une analyse de code à l'aide de Python et de Bandit, procédez comme suit :

Créez un nouveau fichier Python nommé bandit_test.py avec le contenu suivant :


import pickle
import yaml
import subprocess
from flask import Flask, request
import hashlib

app = Flask(__name__)

@app.route("/unsafe_pickle", methods=["POST"])
def unsafe_pickle_usage():
    data = request.get_data()
    return pickle.loads(data)

@app.route("/command_injection", methods=["GET"])
def command_injection():
    command = request.args.get("cmd")
    return subprocess.Popen(command, shell=True)

def weak_crypto():
    password = "secret_password"
    return hashlib.md5(password.encode()).hexdigest()

PASSWORD = "super_secret_password123"

Ouvrez l'assistant de codage. Demandez les actions suivantes dans le chat : Scannez le script actuel et donnez-moi les résultats.

Développeur d’applications

Sous-tâche	Description	Compétences requises
Effectuez une analyse de code.	Pour effectuer une analyse de code à l'aide de Terraform et Checkov, procédez comme suit : Créez un nouveau fichier Terraform nommé `terraform_test.tf` avec le contenu suivant : `resource "aws_s3_bucket" "insecure_bucket" { bucket = "my-insecure-bucket" acl = "public-read" } resource "aws_security_group" "wide_open" { name = "allow_all" description = "Allow all inbound traffic" ingress { from_port = 0 to_port = 0 protocol = "-1" cidr_blocks = ["0.0.0.0/0"] } }` Ouvrez l'assistant de codage. Demandez les actions suivantes dans le chat : Scannez le script actuel et donnez-moi les résultats.	Développeur d’applications

Sous-tâche	Description	Compétences requises
Effectuez une analyse ciblée.	Voici des exemples de demandes que vous pouvez utiliser pour effectuer une analyse ciblée : Scannez le projet en cours et dites-moi les résultats. Scannez les lignes 6 à 10 dans le script en cours.	Développeur d’applications
Utilisez le scan de sécurité avec la génération de code.	Pour résoudre les problèmes de sécurité à l'aide de boucles de génération de code, procédez comme suit (cet exemple utilise Kiro comme assistant de codage) : Dans Kiro, demandez : créez une table DynamoDB dans Terraform et scannez le code avec le scanner de sécurité. Dans Kiro, demandez : Passez en revue le code généré et les résultats du scan de sécurité, puis suivez les boucles de génération de code résolvant les problèmes de sécurité.	Développeur d’applications

Résolution des problèmes

Problème	Solution
Problèmes de configuration de l'environnement	Vérifiez que la version 3.10 ou ultérieure de Python est installée. Assurez-vous que le gestionnaire de `uv` packages est installé.
Problèmes liés au scanner	Vérifiez que les formats de fichiers sont pris en charge. Vérifiez que la syntaxe du fichier est correcte. Assurez-vous que les extensions de fichier utilisées sont appropriées. Vérifiez les paramètres de délai d'expiration du scan.
Problèmes d'intégration	Vérifiez que le serveur MCP est en cours d'exécution. Vérifiez que le fichier de configuration est correct. Validez les points de terminaison d'API. Assurez-vous que le format de réponse est valide.
Support supplémentaire	Consultez les journaux pour voir s'ils contiennent des messages d'erreur détaillés. Consultez la documentation spécifique à l'outil. Créez un problème dans le référentiel.

Ressources connexes

AWS documentation

L'infrastructure en tant que code (AWS livre blanc, introduction à DevOps on) AWS

Autres AWS ressources

Bonnes pratiques en matière de sécurité, d'identité et de conformité

Autres ressources

Documentation sur les bandits
Consultez la documentation
Documentation du protocole MCP (Model Context Protocol)
Pratiques de codage sécurisé de l'OWASP (site Web de la Fondation OWASP)
Documentation Semgrep

Informations supplémentaires

Exemple de configuration MCP avec approbation automatique activée

Sans autoApprove configuration, l'utilisateur doit autoriser l'envoi du code au serveur de sécurité MCP pour analyse. Lorsqu'il autoApprove est configuré, l'assistant de code est autorisé à appeler les outils sans l'approbation de l'utilisateur. Ces outils s'exécutent localement sur la machine, aucune donnée n'est envoyée et seul un scan de code est effectué.

La configuration suivante permet l'exécution automatique de toutes les fonctions d'analyse de sécurité :


{
  "mcpServers": {
    "security-scanner": {
      "command": "uvx",
      "args": [
        "--from",
        "git+https://github.com/aws-samples/sample-mcp-security-scanner.git@main",
        "security_scanner_mcp_server"
      ],
      "env": {
        "FASTMCP_LOG_LEVEL": "ERROR"
      },
      "disabled": false,
      "autoApprove": [
        "scan_with_checkov",
        "scan_with_semgrep", 
        "scan_with_bandit",
        "get_supported_formats"
      ]
    }
  }
}

Pour activer la journalisation du débogage, définissez sur"FASTMCP_LOG_LEVEL". "DEBUG"

Formats de fichiers pris en charge par les outils d'analyse de sécurité

Chaque outil d'analyse de sécurité de cette solution prend en charge les formats de fichiers suivants :

Checkov (IaC)

Terraforme — .tf, .tfvars, .tfstate
CloudFormation — .yaml, .yml, .json, .modèle
Kubernetes — .yaml, .yml
Dockerfile — Dockerfile
ARM — .json (gestionnaire de ressources Azure)
Biceps — .biceps
Sans serveur : .yml, .yaml
Casque — .yaml, .yml, .tpl
GitHub Actions : .yml, .yaml
GitLab_ci — .yml, .yaml
Ansible — .yml, .yaml

Semgrep (Code source)

Python — .py
JavaScript — .js
TypeScript — .ts
Java — .java
Allez — .go
C — c
C++ — .cpp
C# — .cs
Ruby — .rb
PHP — .php
Scala — .scala
Kotlin — .kt
Rouille — .rs

Bandit (Python uniquement)

Python — .py

Démos

Pour scanner le code, essayez les exemples d'instructions suivants avec votre assistant AI :

« Scannez le script actuel et donnez-moi les résultats. »
« Scannez les lignes 20 à 60 et donnez-moi les résultats. »
« Scannez cette ressource de table Amazon DynamoDB et indiquez-moi le résultat. »

Pour plus d'informations, consultez cette démonstration de numérisation de code dans le GitHub référentiel de ce modèle.

Pour générer un code sécurisé, essayez les exemples d'instructions suivants :

« Générez une configuration Terraform pour créer une table DynamoDB avec le chiffrement activé et analysez-la pour détecter les problèmes de sécurité. »
« Créez une fonction Lambda Python qui écrit dans DynamoDB et scannez-la pour détecter les vulnérabilités. »
« Générez un CloudFormation modèle pour un compartiment S3 avec les paramètres de sécurité appropriés et vérifiez qu'il passe les contrôles de sécurité. »
« Écrivez un script Python pour interroger DynamoDB à l'aide de la pagination et recherchez les meilleures pratiques en matière de sécurité. »
« Créez un manifeste de déploiement Kubernetes pour un microservice avec renforcement de la sécurité et validez-le. »

Pour plus d'informations, consultez cette démonstration de génération de code avec analyse de sécurité dans le GitHub référentiel de ce modèle.

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Déployez plusieurs objets de modèle de pipeline sur un seul SageMaker point de terminaison

Développez des assistants basés sur le chat basé sur l'IA en utilisant RAG et des instructions ReAct