Dans cet article, vous découvrirez :
- Qu’est-ce que le kit de développement cloud AWS (CDK) et comment il peut être utilisé pour définir et déployer une infrastructure cloud.
- Pourquoi vous devriez donner aux agents AWS Bedrock IA, créés avec AWS CDK, accès aux résultats de recherche Web à l’aide d’un outil compatible avec l’IA tel que l’API SERP de Bright Data.
- Comment créer un agent AWS Bedrock intégré à l’API SERP à l’aide d’AWS CDK en Python.
C’est parti !
Qu’est-ce que le kit de développement cloud AWS (CDK) ?
Le kit de développement cloud AWS, également connu sous le nom d’AWS CDK, est un framework open source permettant de créer une infrastructure cloud sous forme de code à l’aide de langages de programmation modernes. Il vous fournit tout ce dont vous avez besoin pour provisionner des ressources AWS et déployer des applications via AWS CloudFormation à l’aide de langages de programmation tels que TypeScript, Python, Java, C# et Go.
Grâce à AWS CDK, vous pouvez également créer des agents IA pour Amazon Bedrock par programmation, ce que vous allez faire dans ce tutoriel !
Pourquoi les agents IA Amazon Bedrock créés avec AWS CDK ont besoin d’une recherche sur le Web
Les grands modèles linguistiques sont entraînés sur des jeux de données représentant des connaissances valables uniquement jusqu’à un certain moment. Par conséquent, ils ont tendance à produire des réponses inexactes ou fantaisistes. Cela pose particulièrement problème pour les agents IA qui ont besoin d’informations à jour.
Ce problème peut être résolu en donnant à votre agent IA la possibilité de récupérer des données récentes et fiables dans une configuration RAG (Retrieval-Augmented Generation). Par exemple, l’agent IA pourrait effectuer des recherches sur le Web pour recueillir des informations vérifiables, élargissant ainsi ses connaissances et améliorant sa précision.
Il est possible de créer une fonction AWS Lambda personnalisée pour scraper les moteurs de recherche, mais cela représente un défi de taille. Vous devrez gérer le rendu JavaScript, les CAPTCHA, les changements de structure des sites et les blocages d’IP.
Une meilleure approche consiste à utiliser une API SERP riche en fonctionnalités, comme l’API SERP de Bright Data. Celle-ci gère pour vous les proxys, le déblocage, l’évolutivité, le formatage des données et bien plus encore. En l’intégrant à AWS Bedrock à l’aide d’une fonction Lambda, votre agent IA créé via AWS CDK pourra accéder aux résultats de recherche en temps réel pour fournir des réponses plus fiables.
Comment développer un agent IA avec l’intégration de l’API SERP à l’aide d’AWS CDK en Python
Dans cette section étape par étape, vous apprendrez à utiliser AWS CDK avec Python pour créer un agent IA AWS Bedrock. Celui-ci sera capable de récupérer des données à partir de moteurs de recherche via l’API SERP de Bright Data.
L’intégration sera mise en œuvre via une fonction Lambda (qui appelle l’API SERP) que l’agent peut invoquer comme un outil. Plus précisément, pour créer un agent Amazon Bedrock, les principaux composants sont les suivants :
- Groupe d’actions: définit les fonctions que l’agent peut voir et appeler.
- Fonction Lambda: implémente la logique pour interroger l’API SERP de Bright Data.
- Agent IA: orchestre les interactions entre les modèles de base, les fonctions et les demandes des utilisateurs.
Cette configuration sera entièrement mise en œuvre avec AWS CDK en Python. Pour obtenir les mêmes résultats à l’aide de la console visuelle AWS Bedrock, consultez notre guide Amazon Bedrock + Bright Data.
Suivez les étapes ci-dessous pour créer un agent AWS Bedrock IA à l’aide d’AWS CDK, amélioré avec des capacités de recherche Web en temps réel via l’API SERP !
Prérequis
Pour suivre ce tutoriel, vous devez disposer des éléments suivants :
- Node.js 22.x+ installé localement pour utiliser l’interface CLI AWS CDK.
- Python 3.11+ installé localement pour utiliser AWS CDK en Python.
- Un compte AWS actif (même en version d’essai gratuite).
- Configurer les prérequis Amazon Bedrock Agents. (Amazon Bedrock Agents n’est actuellement disponible que dans certaines régions AWS.)
- Un compte Bright Data avec une clé API prête à l’emploi.
- Compétences de base en programmation Python.
Étape n° 1 : installer et autoriser l’interface CLI AWS
Avant de passer à AWS CDK, vous devez installer l’interface CLI AWS et la configurer afin que votre terminal puisse s’authentifier auprès de votre compte AWS.
Remarque: si vous avez déjà installé et configuré l’interface CLI AWS pour l’authentification, passez cette étape et passez à la suivante.
Installez l’interface CLI AWS en suivant le guide d’installation officiel correspondant à votre système d’exploitation. Une fois l’installation terminée, vérifiez-la en exécutant :
aws --versionVous devriez obtenir un résultat similaire à celui-ci :
aws-cli/2.31.32 Python/3.13.9 Windows/11 exe/AMD64Ensuite, exécutez la commande configure pour configurer vos informations d’identification :
aws configureVous serez invité à saisir :
- ID de clé d’accès AWS
- Clé d’accès secrète AWS
- Nom de la région par défaut (par exemple,
us-east-1) - Format de sortie par défaut (facultatif, par exemple
json)
Remplissez les trois premiers champs, car ils sont nécessaires pour le développement et le déploiement CDK. Si vous vous demandez où trouver ces informations :
- Rendez-vous sur AWS et connectez-vous.
- Dans le coin supérieur droit, cliquez sur le nom de votre compte pour ouvrir le menu du compte et sélectionnez l’option « Security Credentials » (Informations d’identification de sécurité).
- Dans la section « Clés d’accès », créez une nouvelle clé. Enregistrez l’« ID de clé d’accès » et la « Clé d’accès secrète » dans un endroit sûr.
C’est fait ! Votre machine peut se connecter à votre compte AWS via l’interface CLI. Vous êtes prêt à poursuivre le développement AWS CDK.
Étape n° 2 : installer AWS CDK
Installez AWS CDK globalement sur votre système à l’aide du package npm aws-cdk:
npm install -g aws-cdkVérifiez ensuite la version installée en exécutant :
cdk --versionVous devriez obtenir un résultat similaire à :
2.1031.2 (build 779352d)Remarque: la version 2.174.3 ou ultérieure est requise pour le développement et le déploiement d’agents IA à l’aide d’AWS CDK avec Python.
Parfait ! Vous avez maintenant installé AWS CDK CLI localement.
Étape n° 3 : Configurer votre projet AWS CDK Python
Commencez par créer un nouveau dossier de projet pour votre agent IA AWS CDK + Bright Data API SERP.
Vous pouvez par exemple le nommer aws-cdk-bright-data-web-search-agent:
mkdir aws-cdk-bright-data-web-search-agentAccédez au dossier :
cd aws-cdk-bright-data-web-search-agentEnsuite, initialisez une nouvelle application AWS CDK basée sur Python à l’aide de la commande init:
cdk init app --language pythonCela peut prendre un certain temps, alors soyez patient pendant que l’interface CLI CDK configure la structure de votre projet.
Une fois initialisé, votre dossier de projet devrait ressembler à ceci :
aws-cdk-bright-data-web-search-agent
├── .git/
├── venv/
├── aws_cdk_bright_data_web_search_agent/
│ ├── __init__.py
│ └── aws_cdk_bright_data_web_search_agent_stack.py
├── tests/
│ ├── __init__.py
│ └── unit/
│ ├── __init__.py
│ └── test_aws_cdk_bright_data_web_search_agent_stack.py
├── .gitignore
├── app.py
├── cdk.json
├── README.md
├── requirements.txt
├── requirements-dev.txt
└── source.batVous devez vous concentrer sur ces deux fichiers :
app.py: contient la définition de niveau supérieur de l’application AWS CDK.aws_cdk_bright_data_web_search_agent/aws_cdk_bright_data_web_search_agent_stack.py: définit la pile pour l’agent de recherche Web (c’est là que vous implémenterez votre logique d’agent IA).
Pour plus de détails, consultez le guide officiel AWS sur l’utilisation de CDK en Python.
Chargez maintenant votre projet dans votre IDE Python préféré, tel que PyCharm ou Visual Studio Code avec l’extension Python.
Notez que la commande cdk init crée automatiquement un environnement virtuel Python dans le projet. Sous Linux ou macOS, activez-le avec :
source .venv/bin/activateOu, de manière équivalente, sous Windows, exécutez :
.venvScriptsactivateEnsuite, dans l’environnement virtuel activé, installez toutes les dépendances requises :
python -m pip install -r requirements.txtFantastique ! Vous disposez désormais d’un environnement Python AWS CDK configuré pour le développement d’agents IA.
Étape n° 4 : exécuter le bootstrapping AWS CDK
Le bootstrapping est le processus qui consiste à préparer votre environnement AWS pour l’utiliser avec le kit de développement cloud AWS. Avant de déployer une pile CDK, votre environnement doit être bootstrappé.
En termes plus simples, ce processus configure les ressources suivantes dans votre compte AWS :
- Un compartiment Amazon S3: stocke vos fichiers de projet CDK, tels que le code de fonction AWS Lambda et d’autres ressources.
- Un référentiel Amazon ECR: stocke les images Docker.
- Rôles AWS IAM: accorde les autorisations nécessaires à AWS CDK pour effectuer des déploiements. (Pour plus de détails, consultez la documentation AWS sur les rôles IAM créés pendant le bootstrapping.)
Pour lancer le processus de démarrage CDK, exécutez la commande suivante dans le dossier de votre projet :
cdk bootstrapDans le service AWS CloudFormation, cette commande crée une pile appelée « CDKToolkit » qui contient toutes les ressources nécessaires au déploiement des applications CDK.
Vérifiez cela en accédant à la console CloudFormation et en consultant la page « Stacks » :
Vous verrez une pile « CDKToolkit ». Suivez son lien et vous devriez voir quelque chose comme ceci :
Pour plus d’informations sur le fonctionnement du processus de démarrage, les raisons pour lesquelles il est nécessaire et ce qui se passe en arrière-plan, consultez la documentation officielle AWS CDK.
Étape n° 5 : préparez-vous avec l’API SERP de Bright Data
Maintenant que votre environnement AWS CDK est configuré pour le développement et le déploiement, terminez les étapes préliminaires en préparant votre compte Bright Data et en configurant le service API SERP. Vous pouvez soit suivre la documentation officielle de Bright Data, soit suivre les étapes ci-dessous.
Si vous n’avez pas encore de compte, créez un compte Bright Data. Sinon, connectez-vous simplement. Dans votre compte Bright Data, accédez à la page « Proxies & Scraping » (Proxys et scraping). Dans la section « My Zones » (Mes zones), recherchez la ligne « API SERP » dans le tableau :
Si vous ne voyez pas de ligne avec l’étiquette « API SERP », cela signifie que vous n’avez pas encore configuré de zone. Faites défiler vers le bas jusqu’à la section « API SERP » et cliquez sur « Create zone » (Créer une zone) pour en ajouter une :
Créez une zone API SERP et donnez-lui un nom tel que serp_api (ou tout autre nom de votre choix). Notez le nom de la zone que vous avez choisi, car vous en aurez besoin pour accéder au service via l’API.
Sur la page du produit API SERP, activez le bouton « Activer » pour activer la zone :
Enfin, suivez le guide officiel pour générer votre clé API Bright Data. Conservez-la dans un endroit sûr, car vous en aurez besoin sous peu.
Parfait ! Vous avez maintenant tout ce qu’il faut pour utiliser l’API SERP de Bright Data dans votre agent AWS Bedrock IA développé avec AWS CDK.
Étape n° 6 : stockez les secrets de votre application CDK dans AWS Secrets Manager
Vous venez d’obtenir des informations sensibles (par exemple, votre clé API Bright Data et le nom de la zone API SERP). Au lieu d’intégrer ces valeurs dans le code de votre fonction Lambda, vous devez les lire en toute sécurité à partir d’AWS Secrets Manager.
Exécutez la commande Bash suivante pour créer un secret nommé BRIGHT_DATA contenant votre clé API Bright Data et votre zone API SERP :
aws secretsmanager create-secret --name "BRIGHT_DATA" --description "API credentials for Bright Data API SERP integration" --secret-string '{
"BRIGHT_DATA_API_KEY": "<VOTRE_CLÉ_API_BRIGHT_DATA>",
"BRIGHT_DATA_SERP_API_ZONE": "<VOTRE_ZONE_API_SERP_BRIGHT_DATA>"
}'Ou, de manière équivalente, dans PowerShell :
aws secretsmanager create-secret `
--name "BRIGHT_DATA" `
--description « Identifiants API pour l'intégration de l'API SERP de Bright Data » `
--secret-string '{"BRIGHT_DATA_API_KEY":"<VOTRE_CLÉ_API_BRIGHT_DATA>","BRIGHT_DATA_SERP_API_ZONE":"<VOTRE_ZONE_API_SERP_BRIGHT_DATA>"}'Veillez à remplacer <VOTRE_CLÉ_API_BRIGHT_DATA> et <VOTRE_ZONE_API_SERP_BRIGHT_DATA> par les valeurs réelles que vous avez récupérées précédemment.
Cette commande configurera le secret BRIGHT_DATA, comme vous pouvez le vérifier dans la console AWS Secrets Manager sous la page « Secrets » :
Si vous cliquez sur le bouton « Récupérer la valeur secrète », vous devriez voir les secrets BRIGHT_DATA_API_KEY et BRIGHT_DATA_SERP_API_ZONE:
Génial ! Ces secrets seront utilisés pour authentifier les requêtes adressées à l’API SERP dans une fonction Lambda que vous définirez bientôt.
Étape n° 7 : implémenter votre pile AWS CDK
Maintenant que vous avez configuré tout ce dont vous avez besoin pour créer votre agent IA, l’étape suivante consiste à implémenter la pile AWS CDK en Python. Tout d’abord, il est important de comprendre ce qu’est une pile AWS CDK.
Une pile est la plus petite unité déployable dans CDK. Elle représente un ensemble de ressources AWS définies à l’aide de constructions CDK. Lorsque vous déployez une application CDK, toutes les ressources de la pile sont déployées ensemble sous la forme d’une seule pile CloudFormation.
Le fichier de pile par défaut se trouve à l’emplacement suivant :
aws_cdk_bright_data_web_search_agent/aws_cdk_bright_data_web_search_agent_stack.pyInspectez-le dans Visual Studio Code :
Il contient un modèle de pile générique dans lequel vous définirez votre logique. Votre tâche consiste à implémenter la pile AWS CDK complète pour créer l’agent IA avec l’intégration de l’API SERP de Bright Data, y compris les fonctions Lambda, les rôles IAM, les groupes d’actions et l’agent IA Bedrock.
Réalisez tout cela avec :
import aws_cdk.aws_iam as iam
from aws_cdk import (
Aws,
CfnOutput,
Duration,
Stack)
from aws_cdk import aws_bedrock as bedrock
from aws_cdk import aws_lambda as _lambda
from constructs import Construct
# Définir les constantes requises
AI_MODEL_ID = "amazon.nova-lite-v1:0" # Le nom du LLM utilisé pour alimenter l'agent
ACTION_GROUP_NAME = "action_group_web_search"
LAMBDA_FUNCTION_NAME = "serp_api_lambda"
AGENT_NAME = "web_search_agent"
# Définir la pile CDK pour déployer l'agent de recherche Web alimenté par Bright Data
class AwsCdkBrightDataWebSearchAgentStack(Stack):
def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
super().__init__(scope, construct_id, **kwargs)
# Accorde les autorisations Lambda pour la journalisation et la lecture des secrets
lambda_policy = iam.Policy(
self,
"LambdaPolicy",
statements=[
# Autorisation de créer des groupes de journaux CloudWatch
iam.PolicyStatement(
sid="CreateLogGroup",
effect=iam.Effect.ALLOW,
actions=["logs:CreateLogGroup"],
resources=[f"arn:aws:logs:{Aws.REGION}:{Aws.ACCOUNT_ID}:*"],
),
# Autorisation de créer des flux de journaux et d'y placer des événements de journalisation
iam.PolicyStatement(
sid="CreateLogStreamAndPutLogEvents",
effect=iam.Effect.ALLOW,
actions=["logs:CreateLogStream", "logs:PutLogEvents"],
resources=[
f"arn:aws:logs:{Aws.REGION}:{Aws.ACCOUNT_ID}:log-group:/aws/lambda/{LAMBDA_FUNCTION_NAME}",
f"arn:aws:logs:{Aws.REGION}:{Aws.ACCOUNT_ID}:log-group:/aws/lambda/{LAMBDA_FUNCTION_NAME}:log-stream:*",
],
),
# Autorisation de lire les secrets BRIGHT_DATA à partir de Secrets Manager
iam.PolicyStatement(
sid="GetSecretsManagerSecret",
effect=iam.Effect.ALLOW,
actions=["secretsmanager:GetSecretValue"],
resources=[
f"arn:aws:secretsmanager:{Aws.REGION}:{Aws.ACCOUNT_ID}:secret:BRIGHT_DATA*",
],
),
],
)
# Définir le rôle IAM pour les fonctions Lambda
lambda_role = iam.Role(
self,
"LambdaRole",
role_name=f"{LAMBDA_FUNCTION_NAME}_role",
assumed_by=iam.ServicePrincipal("lambda.amazonaws.com"),
)
# Joindre la politique au rôle Lambda
lambda_role.attach_inline_policy(lambda_policy)
# Définition de la fonction Lambda
lambda_function = _lambda.Function(
self,
LAMBDA_FUNCTION_NAME,
function_name=LAMBDA_FUNCTION_NAME,
runtime=_lambda.Runtime.PYTHON_3_12, # Runtime Python
architecture=_lambda.Architecture.ARM_64,
code=_lambda.Code.from_asset("lambda"), # Lire le code Lambda à partir du dossier « lambda/ »
handler=f"{LAMBDA_FUNCTION_NAME}.lambda_handler",
timeout=Duration.seconds(120),
role=lambda_role, # Joindre le rôle IAM
environment={"LOG_LEVEL": "DEBUG", "ACTION_GROUP": f"{ACTION_GROUP_NAME}"},
)
# Autoriser le service Bedrock à invoquer les fonctions Lambda
bedrock_account_principal = iam.PrincipalWithConditions(
iam.ServicePrincipal("bedrock.amazonaws.com"),
conditions={
"StringEquals": {"aws:SourceAccount": f"{Aws.ACCOUNT_ID}"},
},
)
lambda_function.add_permission(
id="LambdaResourcePolicyAgentsInvokeFunction",
principal=bedrock_account_principal,
action="lambda:invokeFunction",
)
# Définir la politique IAM pour l'agent Bedrock
agent_policy = iam.Policy(
self,
"AgentPolicy",
statements=[
iam.PolicyStatement(
sid="AmazonBedrockAgentBedrockFoundationModelPolicy",
effect=iam.Effect.ALLOW,
actions=["bedrock:InvokeModel"], # Lui donner l'autorisation d'appeler le modèle de base
resources=[f"arn:aws:bedrock:{Aws.REGION}::foundation-model/{AI_MODEL_ID}"],
),
],
)
# Relation de confiance pour le rôle d'agent afin de permettre à Bedrock de l'assumer
agent_role_trust = iam.PrincipalWithConditions(
iam.ServicePrincipal("bedrock.amazonaws.com"),
conditions={
"StringLike": {"aws:SourceAccount": f"{Aws.ACCOUNT_ID}"},
"ArnLike": {"aws:SourceArn": f"arn:aws:bedrock:{Aws.REGION}:{Aws.ACCOUNT_ID}:agent/*"},
},
)
# Définir le rôle IAM pour l'agent Bedrock
agent_role = iam.Role(
self,
"AmazonBedrockExecutionRoleForAgents",
role_name=f"AmazonBedrockExecutionRoleForAgents_{AGENT_NAME}",
assumed_by=agent_role_trust,
)
agent_role.attach_inline_policy(agent_policy)
# Définir le groupe d'actions pour l'agent IA
action_group = bedrock.CfnAgent.AgentActionGroupProperty(
action_group_name=ACTION_GROUP_NAME,
description="Appeler l'API SERP de Bright Data pour effectuer des recherches sur le Web et récupérer des informations à jour à partir des moteurs de recherche.",
action_group_executor=bedrock.CfnAgent.ActionGroupExecutorProperty(lambda_=lambda_function.function_arn),
function_schema=bedrock.CfnAgent.FunctionSchemaProperty(
functions=[
bedrock.CfnAgent.FunctionProperty(
name=LAMBDA_FUNCTION_NAME,
description="S'intègre à l'API SERP de Bright Data pour effectuer des recherches sur le Web.",
parameters={
"search_query": bedrock.CfnAgent.ParameterDetailProperty(
type="string",
description="La requête de recherche pour la recherche Web Google.",
required=True,
)
},
),
]
),
)
# Créer et spécifier l'agent Bedrock AI
agent_description = """
Un agent IA capable de se connecter à l'API SERP de Bright Data pour récupérer le contexte de recherche Web actualisé à partir des moteurs de recherche.
"""
agent_instruction = """
Vous êtes un agent conçu pour gérer les cas d'utilisation qui nécessitent la récupération et le traitement d'informations actualisées.
Vous pouvez accéder aux données actuelles, y compris aux actualités et aux résultats des moteurs de recherche, grâce aux recherches Web alimentées par l'API SERP de Bright Data.
"""
agent = bedrock.CfnAgent(
self,
AGENT_NAME,
description=agent_description,
agent_name=AGENT_NAME,
foundation_model=AI_MODEL_ID,
action_groups=[action_group],
auto_prepare=True,
instruction=agent_instruction,
agent_resource_role_arn=agent_role.role_arn,
)
# Exporter les sorties clés pour le déploiement
CfnOutput(self, "agent_id", value=agent.attr_agent_id)
CfnOutput(self, "agent_version", value=agent.attr_agent_version)Le code ci-dessus est une version modifiée de l’implémentation officielle de la pile AWS CDK pour un agent IA de recherche Web.
Ce qui se passe dans ces plus de 150 lignes de code reflète les étapes décrites précédemment dans le guide : Étape n° 1, Étape n° 2 et Étape n° 3 de notre article «Comment intégrer l’API SERP de Bright Data aux agents AWS Bedrock IA».
Pour mieux comprendre ce qui se passe dans ce fichier, décomposons le code en cinq blocs fonctionnels :
- Politique et rôle IAM Lambda: définit les autorisations pour la fonction Lambda. Lambda nécessite l’accès aux journaux CloudWatch pour enregistrer les détails d’exécution et à AWS Secrets Manager pour lire en toute sécurité la clé API et la zone Bright Data. Un rôle IAM est créé pour Lambda et la politique appropriée est jointe, garantissant ainsi un fonctionnement sécurisé avec uniquement les autorisations nécessaires.
- Définition de la fonction Lambda: ici, la fonction Lambda elle-même est définie et configurée. Elle spécifie le runtime et l’architecture Python, pointe vers le dossier contenant le code Lambda (qui sera implémenté à l’étape suivante) et configure les variables d’environnement telles que le niveau de journalisation et le nom du groupe d’actions. Des autorisations sont accordées afin qu’AWS Bedrock puisse invoquer la fonction Lambda, permettant à l’agent IA de déclencher des recherches sur le Web via l’API SERP de Bright Data.
- Rôle IAM de l’agent Bedrock: crée le rôle d’exécution pour l’agent IA Bedrock. L’agent a besoin d’autorisations pour invoquer le modèle IA de base sélectionné parmi ceux pris en charge (
amazon.nova-lite-v1:0, dans ce cas). Une relation de confiance est définie afin que seul Bedrock puisse assumer ce rôle au sein de votre compte. Une politique est jointe pour accorder l’accès au modèle. - Définition du groupe d’actions: un groupe d’actions définit les actions spécifiques que l’agent IA peut effectuer. Il relie l’agent à la fonction Lambda qui lui permet d’exécuter des recherches sur le Web via l’API SERP de Bright Data. Le groupe d’actions comprend également des métadonnées pour les paramètres d’entrée, afin que l’agent comprenne comment interagir avec la fonction et quelles informations sont requises pour chaque recherche.
- Définition de l’agent IA Bedrock: définit l’agent IA lui-même. Il relie l’agent au groupe d’actions et au rôle d’exécution et fournit une description claire et des instructions pour son utilisation.
Après avoir déployé la pile CDK, un agent IA apparaîtra dans votre console AWS. Cet agent peut effectuer de manière autonome des recherches sur le Web et récupérer des informations à jour en tirant parti de l’intégration de l’API SERP de Bright Data dans la fonction Lambda. Fantastique !
Étape n° 8 : implémenter Lambda pour l’intégration de l’API SERP
Jetez un œil à cet extrait du code précédent :
lambda_function = _lambda.Function(
self,
LAMBDA_FUNCTION_NAME,
function_name=LAMBDA_FUNCTION_NAME,
runtime=_lambda.Runtime.PYTHON_3_12, # Python runtime
architecture=_lambda.Architecture.ARM_64,
code=_lambda.Code.from_asset("lambda"), # Lire le code Lambda à partir du dossier « lambda/ »
handler=f"{LAMBDA_FUNCTION_NAME}.lambda_handler",
timeout=Duration.seconds(120),
role=lambda_role, # Joindre le rôle IAM
environment={"LOG_LEVEL": "DEBUG", "ACTION_GROUP": f"{ACTION_GROUP_NAME}"},
)La ligne code=_lambda.Code.from_asset("lambda") spécifie que le code de la fonction Lambda sera chargé à partir du dossier lambda/. Par conséquent, créez un dossier lambda/ dans votre projet et ajoutez-y un fichier nommé serp_api_lambda.py:
Le fichier serp_api_lambda.py doit contenir l’implémentation de la fonction Lambda utilisée par l’agent IA défini précédemment. Implémentez cette fonction pour gérer l’intégration avec l’API SERP de Bright Data comme suit :
import json
import logging
import os
import urllib.parse
import urllib.request
import boto3
# ----------------------------
# Configuration de la journalisation
# ----------------------------
log_level = os.environ.get("LOG_LEVEL", "INFO").strip().upper()
logging.basicConfig(
format="[%(asctime)s] p%(process)s {%(filename)s:%(lineno)d} %(levelname)s - %(message)s"
)
logger = logging.getLogger(__name__)
logger.setLevel(log_level)
# ----------------------------
# Région AWS à partir de l'environnement
# ----------------------------
AWS_REGION = os.environ.get("AWS_REGION")
if not AWS_REGION:
logger.warning("Variable d'environnement AWS_REGION non définie ; boto3 utilisera la région par défaut")
# ----------------------------
# Récupérer l'objet secret à partir d'AWS Secrets Manager
# ----------------------------
def get_secret_object(key: str) -> str:
"""
Obtenir une valeur secrète à partir d'AWS Secrets Manager.
"""
session = boto3.session.Session()
client = session.client(
service_name='secretsmanager',
region_name=AWS_REGION
)
try:
get_secret_value_response = client.get_secret_value(
SecretId=key
)
except Exception as e:
logger.error(f"Impossible d'obtenir le secret '{key}' à partir de Secrets Manager : {e}")
raise e
secret = json.loads(get_secret_value_response["SecretString"])
return secret
# Récupérer les identifiants Bright Data
bright_data_secret = get_secret_object("BRIGHT_DATA")
BRIGHT_DATA_API_KEY = bright_data_secret["BRIGHT_DATA_API_KEY"]
BRIGHT_DATA_SERP_API_ZONE = bright_data_secret["BRIGHT_DATA_SERP_API_ZONE"]
# ----------------------------
# Recherche Web API SERP
# ----------------------------
def serp_api_web_search(search_query: str) -> str:
"""
Appelle l'API SERP de Bright Data pour récupérer les résultats de recherche Google.
"""
logger.info(f"Exécution de la recherche API SERP de Bright Data pour search_query='{search_query}'")
# Encodage de la requête pour l'URL
encoded_query = urllib.parse.quote(search_query)
# Construit l'URL Google à partir de laquelle extraire le SERP
search_engine_url = f"https://www.google.com/search?q={encoded_query}"
# Requête API Bright Data (docs : https://docs.brightdata.com/scraping-automation/serp-api/send-your-first-request)
url = "https://api.brightdata.com/request"
headers = {
"Content-Type": "application/json",
"Authorization": f"Bearer {BRIGHT_DATA_API_KEY}"
}
data = {
"zone": BRIGHT_DATA_SERP_API_ZONE,
"url": search_engine_url,
"format": "raw",
"data_format": "markdown" # Pour obtenir le SERP sous forme de document Markdown prêt pour l’IA
}
payload = json.dumps(data).encode("utf-8")
request = urllib.request.Request(url, data=payload, headers=headers)
try:
response = urllib.request.urlopen(request)
response_data: str = response.read().decode("utf-8")
logger.debug(f"Réponse de l'API SERP : {response_data}")
return response_data
except urllib.error.HTTPError as e:
logger.error(f"Échec de l'appel à l'API SERP de Bright Data. Erreur HTTP {e.code} : {e.reason}")
except urllib.error.URLError as e:
logger.error(f"Échec de l'appel à l'API SERP de Bright Data. Erreur URL : {e.reason}")
return ""
# ----------------------------
# Gestionnaire Lambda
# ----------------------------
def lambda_handler(event, _):
"""
Gestionnaire AWS Lambda.
Attend un événement avec actionGroup, function et des paramètres facultatifs (y compris search_query).
"""
logger.debug(f"lambda_handler appelé avec l'événement : {event}")
action_group = event.get("actionGroup")
function = event.get("function")
parameters = event.get("parameters", [])
# Extrait search_query des paramètres
search_query = next(
(param["value"] for param in parameters if param.get("name") == "search_query"),
None,
)
logger.debug(f"Requête de recherche saisie : {search_query}")
serp_page = serp_api_web_search(search_query) if search_query else ""
logger.debug(f"Résultats de la requête de recherche : {serp_page}")
# Préparation de la réponse Lambda
function_response_body = {"TEXT": {"body": serp_page}}
action_response = {
"actionGroup": action_group,
"function": function,
"functionResponse": {"responseBody": function_response_body},
}
response = {"response": action_response, "messageVersion": event.get("messageVersion")}
logger.debug(f"lambda_handler response: {response}")
return responseCette fonction Lambda gère trois tâches principales :
- Récupérer les identifiants API en toute sécurité: récupère la clé API Bright Data et la zone API SERP à partir d’AWS Secrets Manager, afin que les informations sensibles ne soient jamais codées en dur.
- Effectuer des recherches sur le Web via l’API SERP: encode la requête de recherche, construit l’URL de recherche Google et envoie une requête à l’API SERP de Bright Data. L’API renvoie les résultats de recherche au format Markdown, qui est un format de données idéal pour l’utilisation par l’IA.
- Répondre à AWS Bedrock: renvoie les résultats dans une réponse structurée que l’agent IA peut utiliser.
Et voilà ! Votre fonction AWS Lambda pour vous connecter à l’API SERP de Bright Data a maintenant été définie avec succès.
Étape n° 9 : déployez votre application AWS CDK
Maintenant que votre pile CDK et sa fonction Lambda associée ont été implémentées, la dernière étape consiste à déployer votre pile sur AWS. Pour ce faire, dans votre dossier de projet, exécutez la commande de déploiement:
cdk deployLorsque vous êtes invité à donner l’autorisation de créer le rôle IAM, tapez y pour approuver.
Après quelques instants, si tout fonctionne comme prévu, vous devriez voir un résultat similaire à celui-ci :
Ensuite, accédez à la console Amazon Bedrock. Dans la page « Agents », vous devriez voir une entrée « web_search_agent » :
Ouvrez l’agent pour afficher les détails de l’agent déployé :
Inspectez-le en appuyant sur le bouton « Edit and Agent Builder » (Modifier et générateur d’agent) et vous verrez exactement le même agent IA implémenté dans «Comment intégrer l’API SERP de Bright Data à AWS Bedrock ».
Enfin, notez que vous pouvez tester l’agent directement à l’aide de l’interface de chat dans le coin droit. C’est ce que vous ferez dans la prochaine et dernière étape !
Étape n° 10 : Tester l’agent IA
Pour tester les capacités de recherche Web et de récupération de données en direct de votre agent IA, essayez une invite telle que :
« Donnez-moi les 3 derniers articles d'actualité sur la fermeture du gouvernement américain ».(Remarque: il s’agit simplement d’un exemple. Vous pouvez donc tester n’importe quelle invite nécessitant des résultats de recherche sur le Web).
Il s’agit d’une invite idéale, car elle demande des informations à jour que le modèle de base seul ne connaît pas. L’agent appellera la fonction Lambda intégrée à l’API SERP, récupérera les résultats et traitera les données pour générer une réponse cohérente.
Exécutez cette invite dans la section « Tester l’agent » de votre agent, et vous devriez obtenir un résultat similaire à celui-ci :
En arrière-plan, l’agent invoque la fonction Lambda de l’API SERP, récupère les derniers résultats de recherche Google pour la requête « fermeture du gouvernement américain » et extrait les articles les plus pertinents (ainsi que leurs URL). C’est quelque chose qu’un LLM standard, tel que Nova Lite configuré, ne peut pas faire seul.
Voici en détail la réponse générée par l’agent :
Les articles d’actualité sélectionnés (et leurs URL) correspondent à ce que vous trouveriez manuellement sur Google pour la requête « fermeture du gouvernement américain » (du moins à la date à laquelle l’agent a été testé) :
Or, toute personne ayant déjà essayé de scraper les résultats de recherche Google sait à quel point cela peut être difficile en raison de la détection des bots, des interdictions d’IP, du rendu JavaScript et d’autres défis. L’API SERP de Bright Data gère tous ces problèmes pour vous, en renvoyant les SERP scrapées au format Markdown (ou HTML, JSON, etc.) optimisé pour l’IA.
Pour confirmer que votre agent a bien appelé la fonction Lambda de l’API SERP, cliquez sur le bouton « Afficher la trace » dans la zone de réponse. Dans la section « Trace étape 1 », faites défiler vers le bas jusqu’au journal d’invocation du groupe pour inspecter la sortie de l’appel Lambda :
Cela permet de vérifier que la fonction Lambda s’est exécutée avec succès et que l’agent a interagi avec l’API SERP comme prévu. Vous pouvez également consulter les journaux AWS CloudWatch de votre fonction Lambda pour confirmer l’exécution.
Il est temps de faire passer votre agent au niveau supérieur ! Testez des invites liées à la vérification des faits, à la surveillance des marques, à l’analyse des tendances du marché ou à d’autres scénarios pour voir comment il se comporte dans différents cas d’utilisation de l’agent et du RAG.
Et voilà ! Vous avez réussi à créer un agent AWS Bedrock intégré à l’API SERP de Bright Data à l’aide de Python et de la bibliothèque AWS CDK. Cet agent IA est capable de récupérer à la demande des données de recherche web actualisées, fiables et contextuelles.
Conclusion
Dans cet article, vous avez appris à intégrer l’API SERP de Bright Data dans un agent AWS Bedrock IA à l’aide d’un projet AWS CDK Python. Ce workflow est parfait pour les développeurs qui souhaitent créer des agents IA plus sensibles au contexte sur AWS.
Pour créer des agents IA encore plus sophistiqués, explorez l’infrastructure IA de Bright Data. Elle offre une suite d’outils permettant de récupérer, valider et transformer des données web en temps réel.
Créez dès aujourd’hui un compte Bright Data gratuit et commencez à tester nos solutions de données web prêtes pour l’IA !
