Table des matières
Introduction
Dans un monde où l'intelligence artificielle transforme rapidement tous les secteurs d'activité, les entreprises cherchent des moyens d'intégrer ces technologies puissantes sans avoir à construire leur propre infrastructure d'IA. AWS Bedrock répond précisément à ce besoin en offrant un service entièrement géré qui rend accessible une variété de modèles fondamentaux (FMs) via une API unifiée.
Lancé officiellement en 2023, AWS Bedrock a rapidement transformé la façon dont les développeurs et les entreprises abordent l'intégration de l'IA générative dans leurs applications. Ce service permet d'accéder à des modèles d'IA de classe mondiale provenant de leaders comme Anthropic, AI21 Labs, Cohere, Meta, Stability AI et bien sûr les propres modèles Amazon Titan, le tout sans nécessiter une expertise approfondie en science des données ou en infrastructure d'IA.
AWS Bedrock est un service sans serveur, ce qui signifie qu'il n'y a aucune infrastructure à gérer. Vous payez uniquement pour ce que vous utilisez, ce qui rend l'IA avancée accessible même aux petites équipes de développement.
Dans cet article, nous explorerons en profondeur comment AWS Bedrock fonctionne, pourquoi il représente une avancée majeure dans le domaine de l'IA générative appliquée, et comment vous pouvez rapidement l'intégrer à vos projets avec des exemples concrets de code. Que vous soyez un développeur curieux, un architecte solution ou un décideur technologique, vous découvrirez comment cette plateforme peut vous aider à transformer vos idées en applications intelligentes.
Qu'est-ce qu'AWS Bedrock ?
AWS Bedrock est un service entièrement géré qui offre un accès simplifié à une variété de modèles fondamentaux d'IA via une API unifiée. Il s'agit de la solution d'Amazon pour démocratiser l'accès à l'IA générative, permettant aux entreprises d'intégrer facilement des capacités d'IA avancées dans leurs applications sans avoir à développer leurs propres modèles ou à gérer l'infrastructure sous-jacente.
Caractéristiques principales
Accès à des modèles de pointe : Intégration de modèles d'IA de leaders comme Anthropic (Claude), AI21 Labs (Jurassic), Cohere, Meta (Llama 2), Stability AI et Amazon (Titan)
API unifiée : Interface cohérente pour accéder à différents modèles, simplifiant l'expérimentation et l'intégration
Personnalisation des modèles : Capacité à affiner les modèles avec vos propres données sans expertise approfondie en ML
Sécurité et confidentialité : Vos données restent dans votre compte AWS, avec un chiffrement complet et des contrôles d'accès précis
Intégration native : Connexion fluide avec d'autres services AWS comme Lambda, SageMaker et d'autres services serverless
Modèle sans serveur : Paiement uniquement pour ce que vous utilisez, sans infrastructure à gérer
Modèles disponibles
AWS Bedrock propose plusieurs familles de modèles fondamentaux, chacun ayant ses propres points forts :
Anthropic Claude (v1, v2, Instant) : Excellents pour les conversations naturelles, les résumés et la génération de contenu avec une compréhension nuancée du contexte
Meta Llama 2 : Modèles open-source puissants pour diverses tâches de langage, avec différentes tailles (7B, 13B, 70B)
Cohere : Spécialisés dans la compréhension et la génération de texte multilingue, particulièrement efficaces pour l'embeddings et la recherche sémantique
AI21 Jurassic : Optimisés pour la génération de contenu de haute qualité et la compréhension contextuelle approfondie
Stability AI : Centrés sur la génération d'images (Stable Diffusion)
Amazon Titan : Modèles propriétaires d'Amazon pour le texte et les embeddings, entraînés sur des données diverses
Pourquoi utiliser plusieurs modèles ?
Chaque modèle a été entraîné différemment et possède des forces distinctes. Par exemple, Claude excelle dans les conversations nuancées et l'analyse de documents longs, tandis que Stable Diffusion est spécialisé dans la génération d'images. La diversité des modèles disponibles vous permet de choisir celui qui correspond le mieux à votre cas d'utilisation spécifique, ou même de combiner plusieurs modèles pour des résultats optimaux.
Pourquoi utiliser AWS Bedrock ?
L'adoption rapide de l'IA générative pose de nombreux défis aux entreprises : choix des modèles, infrastructure complexe, coûts élevés, problèmes de sécurité et de confidentialité. AWS Bedrock offre une solution élégante à ces problèmes, avec plusieurs avantages clés :
Avantages par rapport aux alternatives
Flexibilité et expérimentation : Testez facilement différents modèles sans engagement et pivotez en fonction des performances
Réduction des coûts d'infrastructure : Éliminez les dépenses liées à la formation et au déploiement de modèles complexes
Time-to-market accéléré : Intégrez des capacités d'IA en quelques heures au lieu de semaines ou de mois
Sécurité de niveau entreprise : Bénéficiez des contrôles de sécurité robustes d'AWS (VPC, IAM, KMS, CloudTrail)
Évolutivité automatique : Le service gère automatiquement la mise à l'échelle en fonction de la demande
Intégration simplifiée : Connectez-vous facilement à d'autres services AWS dans votre architecture existante
Personnalisation privée : Affinez les modèles avec vos données sans les exposer à des tiers
Comparaison avec les alternatives
Pour comprendre la proposition de valeur de Bedrock, il est utile de le comparer aux alternatives :
APIs directes des fournisseurs de modèles (OpenAI, Anthropic, etc.) : Bedrock offre une interface unifiée avec une intégration AWS native et des garanties de sécurité et de conformité supérieures
Déploiement autogéré : Bedrock élimine la complexité de l'infrastructure, les coûts de matériel et la nécessité d'expertise en ML
Autres services cloud d'IA (Azure OpenAI, Vertex AI) : Bedrock offre la plus large sélection de modèles et une flexibilité supérieure avec l'écosystème AWS
Cas d'usage concret : Réduction des coûts
Une entreprise de services financiers a réduit ses coûts de 60% en passant d'une infrastructure d'IA autogérée à AWS Bedrock, tout en éliminant la complexité de la gestion des GPU et de la mise à l'échelle. L'équipe de développement a pu se concentrer sur la création de valeur métier plutôt que sur la maintenance de l'infrastructure.
Premiers pas avec AWS Bedrock
Commencer avec AWS Bedrock est remarquablement simple. Suivons les étapes essentielles pour intégrer ce service puissant dans vos applications.
Prérequis
Un compte AWS actif
Accès au service AWS Bedrock (peut nécessiter une demande d'accès pour certains modèles)
Des autorisations IAM appropriées pour utiliser Bedrock
Node.js (pour nos exemples de code)
AWS SDK pour JavaScript v3
Configuration initiale
Pour commencer, vous devez installer le SDK AWS et configurer vos informations d'identification :
1# Installation du SDK AWS pour JavaScript v3
2npm install @aws-sdk/client-bedrock-runtime
3
4# Configuration des informations d'identification (si pas déjà fait)
5aws configureAssurez-vous de demander l'accès aux modèles que vous souhaitez utiliser via la console AWS Bedrock. Certains modèles nécessitent une approbation explicite avant de pouvoir être utilisés.
Votre première requête avec Bedrock
Voici un exemple simple de code qui utilise Claude d'Anthropic pour générer une réponse à partir d'un prompt :
1// Import des dépendances nécessaires
2const { BedrockRuntimeClient, InvokeModelCommand } = require('@aws-sdk/client-bedrock-runtime');
3
4// Créer un client Bedrock dans la région appropriée
5const client = new BedrockRuntimeClient({ region: 'us-west-2' });
6
7// Fonction pour invoquer le modèle Claude d'Anthropic
8async function invokeClaudeModel() {
9 try {
10 // Définir les paramètres pour le modèle
11 const modelId = 'anthropic.claude-v2';
12 const prompt = `\n\nHuman: Explique-moi l'intelligence artificielle générative en termes simples.\n\nAssistant:`;
13
14 const payload = {
15 prompt: prompt,
16 max_tokens_to_sample: 2000,
17 temperature: 0.7,
18 top_p: 0.9,
19 };
20
21 // Créer la commande d'invocation
22 const command = new InvokeModelCommand({
23 modelId: modelId,
24 contentType: 'application/json',
25 accept: 'application/json',
26 body: JSON.stringify(payload),
27 });
28
29 // Exécuter la commande
30 const response = await client.send(command);
31
32 // Traiter la réponse
33 const responseBody = JSON.parse(new TextDecoder().decode(response.body));
34 console.log('Réponse du modèle:', responseBody.completion);
35
36 return responseBody.completion;
37 } catch (error) {
38 console.error('Erreur lors de l\'invocation du modèle:', error);
39 throw error;
40 }
41}
42
43// Appel de la fonction
44invokeClaudeModel();Utilisation de différents modèles
Différents modèles dans Bedrock peuvent nécessiter des formats de requête légèrement différents. Voici un exemple d'utilisation du modèle Titan d'Amazon :
1// Pour Amazon Titan Text
2async function invokeTitanModel() {
3 try {
4 const modelId = 'amazon.titan-text-express-v1';
5
6 const payload = {
7 inputText: "Explique-moi l'intelligence artificielle générative en termes simples.",
8 textGenerationConfig: {
9 maxTokenCount: 2000,
10 temperature: 0.7,
11 topP: 0.9,
12 stopSequences: []
13 }
14 };
15
16 const command = new InvokeModelCommand({
17 modelId: modelId,
18 contentType: 'application/json',
19 accept: 'application/json',
20 body: JSON.stringify(payload),
21 });
22
23 const response = await client.send(command);
24 const responseBody = JSON.parse(new TextDecoder().decode(response.body));
25
26 console.log('Réponse du modèle Titan:', responseBody.results[0].outputText);
27 return responseBody.results[0].outputText;
28 } catch (error) {
29 console.error('Erreur lors de l\'invocation du modèle Titan:', error);
30 throw error;
31 }
32}Cas d'utilisation concrets
AWS Bedrock peut être appliqué à une variété de cas d'utilisation dans presque tous les secteurs. Examinons quelques exemples concrets avec des implémentations.
Assistance client intelligente
Un des cas d'utilisation les plus courants de Bedrock est la création de systèmes d'assistance client avancés. Voici un exemple simplifié d'un chatbot de service client :
1const { BedrockRuntimeClient, InvokeModelCommand } = require('@aws-sdk/client-bedrock-runtime');
2
3const client = new BedrockRuntimeClient({ region: 'us-west-2' });
4
5// Contexte de base pour notre agent de service client
6const systemContext = `Tu es un assistant de service client pour une entreprise de commerce électronique appelée 'TechShop'.
7Tu dois être amical, serviable et fournir des informations précises sur les produits, les retours, les expéditions et les politiques de l'entreprise.
8
9Politiques importantes à connaître:
10- Retours acceptés dans les 30 jours avec reçu
11- Livraison gratuite pour les commandes de plus de 50€
12- Garantie de 1 an sur tous les produits électroniques`;
13
14async function customerServiceBot(userQuery) {
15 try {
16 // Formater le prompt pour Claude
17 const prompt = `\n\nHuman: ${systemContext}\n\nClient: ${userQuery}\n\nAssistant:`;
18
19 const payload = {
20 prompt: prompt,
21 max_tokens_to_sample: 1000,
22 temperature: 0.4, // Température plus basse pour des réponses plus cohérentes
23 top_p: 0.9,
24 };
25
26 const command = new InvokeModelCommand({
27 modelId: 'anthropic.claude-instant-v1',
28 contentType: 'application/json',
29 accept: 'application/json',
30 body: JSON.stringify(payload),
31 });
32
33 const response = await client.send(command);
34 const responseBody = JSON.parse(new TextDecoder().decode(response.body));
35
36 return responseBody.completion.trim();
37 } catch (error) {
38 console.error('Erreur avec le chatbot:', error);
39 return "Je suis désolé, je rencontre des difficultés techniques. Veuillez contacter notre équipe de support directement.";
40 }
41}
42
43// Exemple d'utilisation
44async function handleCustomerRequest() {
45 const userQuestion = "Comment puis-je retourner un produit que j'ai acheté la semaine dernière ?";
46 const response = await customerServiceBot(userQuestion);
47 console.log(`Client: ${userQuestion}\n\nAssistant: ${response}`);
48}
49
50handleCustomerRequest();Résultats réels
Une entreprise de télécommunications a réduit son temps moyen de résolution des problèmes de 45% et augmenté la satisfaction client de 30% en déployant un assistant basé sur Bedrock et Claude. Le système peut désormais gérer plus de 70% des demandes sans intervention humaine, tout en maintenant une expérience conversationnelle naturelle.
Génération et transformation de contenu
Un autre cas d'utilisation puissant est la génération et la transformation automatisées de contenu. Voici un exemple d'outil qui peut prendre des notes brouillonnes et les transformer en contenu structuré :
1const { BedrockRuntimeClient, InvokeModelCommand } = require('@aws-sdk/client-bedrock-runtime');
2
3const client = new BedrockRuntimeClient({ region: 'us-west-2' });
4
5async function transformContent(rawNotes, outputFormat) {
6 try {
7 const prompt = `\n\nHuman: Tu es un assistant expert en rédaction et formatage de contenu. J'ai des notes brouillonnes que j'aimerais transformer en un contenu bien structuré et professionnel au format ${outputFormat}. Voici mes notes:\n\n${rawNotes}\n\nTransforme ces notes en un ${outputFormat} bien structuré, professionnel et prêt à être utilisé.\n\nAssistant:`;
8
9 const payload = {
10 prompt: prompt,
11 max_tokens_to_sample: 4000,
12 temperature: 0.7,
13 top_p: 0.9,
14 };
15
16 const command = new InvokeModelCommand({
17 modelId: 'anthropic.claude-v2',
18 contentType: 'application/json',
19 accept: 'application/json',
20 body: JSON.stringify(payload),
21 });
22
23 const response = await client.send(command);
24 const responseBody = JSON.parse(new TextDecoder().decode(response.body));
25
26 return responseBody.completion.trim();
27 } catch (error) {
28 console.error('Erreur lors de la transformation du contenu:', error);
29 throw error;
30 }
31}
32
33// Exemple d'utilisation
34async function processContentExample() {
35 const rawNotes = `Réunion équipe marketing 15/03
36- discuté nouvelle campagne printemps
37- cible: 25-35 ans urbains
38- budget environ 50k
39- idées: vidéos courtes pour réseaux, collab influenceurs
40- problèmes: délais serrés (lancement 1er avril)
41- actions: maria prépare brief, jean contacte agence, moi recherche influenceurs`;
42
43 const result = await transformContent(rawNotes, 'compte-rendu de réunion formaté avec sections, points d\'action et responsables');
44 console.log(result);
45}
46
47processContentExample();Analyse intelligente de documents
Bedrock excelle également dans l'analyse de documents complexes. Voici un exemple qui utilise Claude pour extraire des informations structurées à partir d'un contrat :
1const { BedrockRuntimeClient, InvokeModelCommand } = require('@aws-sdk/client-bedrock-runtime');
2const fs = require('fs').promises;
3
4const client = new BedrockRuntimeClient({ region: 'us-west-2' });
5
6async function analyzeContract(contractText) {
7 try {
8 const prompt = `\n\nHuman: Tu es un assistant juridique expert. J'ai besoin que tu analyses le contrat suivant et que tu extraies les informations clés dans un format JSON structuré. Inclus ces champs : parties impliquées, date d'effet, durée du contrat, obligations principales, clauses de résiliation, et toute clause inhabituelle ou risquée que tu identifies.\n\nVoici le contrat:\n\n${contractText}\n\nFournis ton analyse sous forme de JSON valide.\n\nAssistant:`;
9
10 const payload = {
11 prompt: prompt,
12 max_tokens_to_sample: 4000,
13 temperature: 0.2, // Température basse pour une sortie plus factuelle et structurée
14 top_p: 0.95,
15 };
16
17 const command = new InvokeModelCommand({
18 modelId: 'anthropic.claude-v2',
19 contentType: 'application/json',
20 accept: 'application/json',
21 body: JSON.stringify(payload),
22 });
23
24 const response = await client.send(command);
25 const responseBody = JSON.parse(new TextDecoder().decode(response.body));
26
27 // Extraire le JSON de la réponse
28 const jsonMatch = responseBody.completion.match(/\{[\s\S]*\}/);
29 if (jsonMatch) {
30 return JSON.parse(jsonMatch[0]);
31 } else {
32 throw new Error('Impossible d\'extraire le JSON de la réponse');
33 }
34 } catch (error) {
35 console.error('Erreur lors de l\'analyse du contrat:', error);
36 throw error;
37 }
38}
39
40// Exemple d'utilisation
41async function processContractExample() {
42 try {
43 // Lire un contrat à partir d'un fichier
44 const contractText = await fs.readFile('./sample_contract.txt', 'utf8');
45 const analysisResult = await analyzeContract(contractText);
46 console.log('Analyse du contrat:', JSON.stringify(analysisResult, null, 2));
47 } catch (error) {
48 console.error('Erreur:', error);
49 }
50}Cette approche peut être adaptée pour analyser divers types de documents comme des rapports financiers, des articles scientifiques, des spécifications techniques ou des documents juridiques complexes.
Fonctionnalités avancées de Bedrock
Au-delà des cas d'utilisation de base, AWS Bedrock offre plusieurs fonctionnalités avancées qui méritent d'être explorées pour tirer pleinement parti de ce service.
Personnalisation de modèles
L'une des fonctionnalités les plus puissantes de Bedrock est la capacité à personnaliser des modèles fondamentaux avec vos propres données, sans avoir besoin d'une expertise approfondie en ML. Cette technique, appelée 'fine-tuning', permet d'adapter des modèles génériques à des cas d'utilisation spécifiques.
1const { BedrockClient, CreateModelCustomizationJobCommand } = require('@aws-sdk/client-bedrock');
2
3const bedrockClient = new BedrockClient({ region: 'us-west-2' });
4
5async function customizeModel() {
6 try {
7 const params = {
8 // Nom unique pour cette tâche de personnalisation
9 customizationName: 'support-assistant-customization',
10 // Modèle de base à personnaliser
11 baseModelIdentifier: 'anthropic.claude-v2',
12 // Configuration de l'ensemble de données d'entraînement
13 trainingDataConfig: {
14 s3Uri: 's3://mon-bucket/training-data/support-conversations.jsonl'
15 },
16 // Configuration de l'ensemble de données de validation (optionnel)
17 validationDataConfig: {
18 s3Uri: 's3://mon-bucket/validation-data/support-conversations-validation.jsonl'
19 },
20 // IAM role qui donne à Bedrock l'accès aux ressources nécessaires
21 roleArn: 'arn:aws:iam::123456789012:role/BedrockCustomizationRole',
22 // Paramètres de personnalisation spécifiques au modèle
23 hyperParameters: {
24 epochCount: 3,
25 batchSize: 4,
26 learningRate: 0.0001
27 },
28 // Tags optionnels pour la catégorisation et la gestion des coûts
29 tags: [
30 { key: 'Department', value: 'CustomerSupport' },
31 { key: 'Project', value: 'AutomatedAssistant' }
32 ]
33 };
34
35 const command = new CreateModelCustomizationJobCommand(params);
36 const response = await bedrockClient.send(command);
37
38 console.log('Tâche de personnalisation créée:', response.jobArn);
39 return response.jobArn;
40 } catch (error) {
41 console.error('Erreur lors de la création de la tâche de personnalisation:', error);
42 throw error;
43 }
44}Formats de données pour la personnalisation
AWS Bedrock attend des données de fine-tuning dans des formats spécifiques, généralement des fichiers JSONL où chaque ligne contient une paire d'échange (instructions et réponse souhaitée). Le format exact dépend du modèle que vous personnalisez. Pour Claude, chaque ligne pourrait avoir la structure: {"prompt": "\n\nHuman: [question]\n\nAssistant:", "completion": "[réponse idéale]"}
Bases de connaissances
Les bases de connaissances Bedrock vous permettent de connecter les modèles fondamentaux à vos données d'entreprise, créant ainsi des IA capables de répondre à des questions en utilisant vos documents propriétaires.
1const { BedrockAgentClient, RetrieveCommand } = require('@aws-sdk/client-bedrock-agent');
2
3const agentClient = new BedrockAgentClient({ region: 'us-west-2' });
4
5async function queryKnowledgeBase(question) {
6 try {
7 const params = {
8 knowledgeBaseId: 'kb-1234567890abcdef0', // ID de votre base de connaissances
9 retrievalQuery: {
10 text: question
11 },
12 // Nombre maximum de résultats à retourner
13 numberOfResults: 3
14 };
15
16 const command = new RetrieveCommand(params);
17 const response = await agentClient.send(command);
18
19 console.log('Résultats de la base de connaissances:', response.retrievalResults);
20 return response.retrievalResults;
21 } catch (error) {
22 console.error('Erreur lors de l\'interrogation de la base de connaissances:', error);
23 throw error;
24 }
25}
26
27// Utilisation de la base de connaissances avec un modèle Bedrock
28async function answerWithKnowledgeBase(question) {
29 // Étape 1: Récupérer les informations pertinentes de la base de connaissances
30 const knowledgeResults = await queryKnowledgeBase(question);
31
32 // Étape 2: Créer un contexte à partir des résultats
33 let context = 'Informations disponibles:\n';
34 knowledgeResults.forEach((result, index) => {
35 context += `\nDocument ${index + 1}: ${result.content.text}\n`;
36 });
37
38 // Étape 3: Utiliser le modèle avec ce contexte
39 const prompt = `\n\nHuman: Je suis un utilisateur cherchant des informations. Ma question est: "${question}"\n\nVoici des informations provenant de notre base de connaissances qui pourraient être pertinentes:\n${context}\n\nUtilise ces informations pour me répondre de manière précise et utile. Si les informations fournies ne sont pas suffisantes pour répondre complètement, indique-le clairement.\n\nAssistant:`;
40
41 const payload = {
42 prompt: prompt,
43 max_tokens_to_sample: 2000,
44 temperature: 0.4
45 };
46
47 const bedrockRuntime = new BedrockRuntimeClient({ region: 'us-west-2' });
48 const command = new InvokeModelCommand({
49 modelId: 'anthropic.claude-v2',
50 contentType: 'application/json',
51 accept: 'application/json',
52 body: JSON.stringify(payload),
53 });
54
55 const response = await bedrockRuntime.send(command);
56 const responseBody = JSON.parse(new TextDecoder().decode(response.body));
57
58 return responseBody.completion.trim();
59}Barrières de sécurité (Guardrails)
Les guardrails de Bedrock vous permettent de définir des règles pour contrôler les sorties des modèles, aidant à garantir que l'IA respecte vos politiques d'entreprise et normes éthiques.
Filtrage de contenu : Bloquer les réponses contenant des propos inappropriés
Rejet de sujets sensibles : Définir des domaines que l'IA devrait éviter
Prévention de fuites d'informations : Empêcher la divulgation de données sensibles
Personnalisation des réponses : Définir des formats de réponse standards pour votre organisation
1const { BedrockClient, CreateGuardrailCommand } = require('@aws-sdk/client-bedrock');
2
3const bedrockClient = new BedrockClient({ region: 'us-west-2' });
4
5async function createGuardrail() {
6 try {
7 const params = {
8 name: 'customer-service-guardrail',
9 description: 'Guardrail for our customer service application',
10 version: '1',
11 blockedInputs: {
12 textFilters: [
13 {
14 filterSource: 'TOPIC',
15 text: 'political opinions',
16 strategy: 'BLOCK'
17 },
18 {
19 filterSource: 'TOPIC',
20 text: 'financial advice',
21 strategy: 'BLOCK'
22 }
23 ]
24 },
25 blockedOutputs: {
26 textFilters: [
27 {
28 filterSource: 'TOXICITY',
29 strategy: 'BLOCK'
30 },
31 {
32 filterSource: 'CUSTOM',
33 text: 'personal email addresses',
34 strategy: 'BLOCK'
35 }
36 ]
37 },
38 contentPolicy: {
39 filters: [
40 {
41 type: 'MALWARE',
42 threshold: 'MEDIUM'
43 },
44 {
45 type: 'PROFANITY',
46 threshold: 'LOW'
47 }
48 ]
49 }
50 };
51
52 const command = new CreateGuardrailCommand(params);
53 const response = await bedrockClient.send(command);
54
55 console.log('Guardrail créé:', response.guardrailArn);
56 return response.guardrailArn;
57 } catch (error) {
58 console.error('Erreur lors de la création du guardrail:', error);
59 throw error;
60 }
61}Intégration avec d'autres services AWS
L'un des grands avantages de Bedrock est sa capacité à s'intégrer facilement avec d'autres services AWS pour créer des solutions complètes.
Intégration avec AWS Lambda
AWS Lambda est un partenaire naturel pour Bedrock, vous permettant de créer des fonctions serverless qui utilisent l'IA générative :
1// Exemple de fonction Lambda qui utilise Bedrock
2const { BedrockRuntimeClient, InvokeModelCommand } = require('@aws-sdk/client-bedrock-runtime');
3
4const client = new BedrockRuntimeClient({ region: 'us-west-2' });
5
6exports.handler = async (event) => {
7 try {
8 // Extraire l'entrée de l'événement
9 const userInput = event.queryStringParameters?.input || 'Parle-moi de l\'IA';
10
11 // Configurer la requête pour Claude
12 const prompt = `\n\nHuman: ${userInput}\n\nAssistant:`;
13
14 const payload = {
15 prompt: prompt,
16 max_tokens_to_sample: 1000,
17 temperature: 0.7,
18 top_p: 0.9,
19 };
20
21 // Invoquer le modèle
22 const command = new InvokeModelCommand({
23 modelId: 'anthropic.claude-instant-v1',
24 contentType: 'application/json',
25 accept: 'application/json',
26 body: JSON.stringify(payload),
27 });
28
29 const response = await client.send(command);
30 const responseBody = JSON.parse(new TextDecoder().decode(response.body));
31
32 // Retourner une réponse formatée pour API Gateway
33 return {
34 statusCode: 200,
35 headers: {
36 'Content-Type': 'application/json',
37 'Access-Control-Allow-Origin': '*'
38 },
39 body: JSON.stringify({
40 input: userInput,
41 response: responseBody.completion.trim()
42 })
43 };
44 } catch (error) {
45 console.error('Erreur:', error);
46 return {
47 statusCode: 500,
48 headers: {
49 'Content-Type': 'application/json',
50 'Access-Control-Allow-Origin': '*'
51 },
52 body: JSON.stringify({ error: 'Erreur lors du traitement de la demande' })
53 };
54 }
55};Exposer Bedrock via API Gateway
AWS API Gateway peut être utilisé pour créer une API REST qui expose les capacités de Bedrock de manière sécurisée :
1# Extrait d'un template CloudFormation/SAM pour déployer une API utilisant Bedrock
2Resources:
3 BedrockFunction:
4 Type: AWS::Serverless::Function
5 Properties:
6 CodeUri: ./src/
7 Handler: index.handler
8 Runtime: nodejs16.x
9 Timeout: 30
10 MemorySize: 256
11 Policies:
12 - AWSLambdaBasicExecutionRole
13 - Version: '2012-10-17'
14 Statement:
15 - Effect: Allow
16 Action:
17 - bedrock:InvokeModel
18 Resource: '*'
19 Environment:
20 Variables:
21 DEFAULT_MODEL: anthropic.claude-v2
22 MAX_TOKENS: 1000
23
24 BedrockApi:
25 Type: AWS::Serverless::Api
26 Properties:
27 StageName: prod
28 Auth:
29 ApiKeyRequired: true
30 UsagePlan:
31 CreateUsagePlan: PER_API
32 Description: Usage plan for Bedrock API
33 Quota:
34 Limit: 1000
35 Period: DAY
36 Throttle:
37 BurstLimit: 10
38 RateLimit: 5
39
40 GenerateTextEndpoint:
41 Type: AWS::Serverless::Function
42 Properties:
43 Events:
44 ApiEvent:
45 Type: Api
46 Properties:
47 RestApiId: !Ref BedrockApi
48 Path: /generate
49 Method: post
50 CodeUri: ./src/
51 Handler: generate.handler
52 Runtime: nodejs16.x
53 Policies:
54 - AWSLambdaBasicExecutionRole
55 - Version: '2012-10-17'
56 Statement:
57 - Effect: Allow
58 Action:
59 - bedrock:InvokeModel
60 Resource: '*'Combiner Bedrock avec SageMaker
Pour des cas d'utilisation plus avancés, vous pouvez combiner Bedrock avec SageMaker pour créer des pipelines de traitement hybrides :
1const { BedrockRuntimeClient, InvokeModelCommand } = require('@aws-sdk/client-bedrock-runtime');
2const { SageMakerRuntimeClient, InvokeEndpointCommand } = require('@aws-sdk/client-sagemaker-runtime');
3
4const bedrockClient = new BedrockRuntimeClient({ region: 'us-west-2' });
5const sagemakerClient = new SageMakerRuntimeClient({ region: 'us-west-2' });
6
7async function processImageAndGenerateDescription(imageBase64) {
8 try {
9 // Étape 1: Utiliser un modèle SageMaker pour analyser l'image
10 const sagemakerParams = {
11 EndpointName: 'image-analysis-endpoint',
12 ContentType: 'application/json',
13 Body: JSON.stringify({ image: imageBase64 })
14 };
15
16 const sagemakerCommand = new InvokeEndpointCommand(sagemakerParams);
17 const sagemakerResponse = await sagemakerClient.send(sagemakerCommand);
18
19 // Analyser la réponse SageMaker
20 const analysisResult = JSON.parse(new TextDecoder().decode(sagemakerResponse.Body));
21 const detectedObjects = analysisResult.detectedObjects;
22 const sceneContext = analysisResult.sceneContext;
23
24 // Étape 2: Utiliser Bedrock pour générer une description basée sur l'analyse
25 const prompt = `\n\nHuman: Je veux générer une description détaillée d'une image. L'analyse automatique a détecté les éléments suivants:\n\nObjets détectés: ${detectedObjects.join(', ')}\nContexte de la scène: ${sceneContext}\n\nGénère une description détaillée et vivante de cette image qui capture ces éléments.\n\nAssistant:`;
26
27 const bedrockParams = {
28 modelId: 'anthropic.claude-v2',
29 contentType: 'application/json',
30 accept: 'application/json',
31 body: JSON.stringify({
32 prompt: prompt,
33 max_tokens_to_sample: 1000,
34 temperature: 0.8
35 }),
36 };
37
38 const bedrockCommand = new InvokeModelCommand(bedrockParams);
39 const bedrockResponse = await bedrockClient.send(bedrockCommand);
40 const bedrockResult = JSON.parse(new TextDecoder().decode(bedrockResponse.body));
41
42 return {
43 analysis: analysisResult,
44 description: bedrockResult.completion.trim()
45 };
46 } catch (error) {
47 console.error('Erreur lors du traitement de l\'image:', error);
48 throw error;
49 }
50}Bonnes pratiques et optimisations
Pour tirer le meilleur parti d'AWS Bedrock, voici quelques bonnes pratiques et conseils d'optimisation :
Optimisation des prompts
Soyez spécifique et détaillé : Fournissez des instructions claires et un contexte suffisant
Structurez vos prompts : Utilisez des sections, des listes et des exemples pour guider le modèle
Expérimentez avec la température : Utilisez des valeurs basses (0.2-0.4) pour des réponses factuelles et cohérentes, et des valeurs plus élevées (0.7-0.9) pour la créativité
Utilisez des few-shot prompting : Fournissez des exemples de paires question-réponse pour illustrer le format de réponse souhaité
Définissez un format de sortie : Demandez explicitement un format (JSON, Markdown, HTML, etc.) selon vos besoins
Optimisation des coûts
Choisissez le bon modèle : Les modèles plus petits ou 'Instant' sont moins coûteux et peuvent être suffisants pour de nombreuses tâches
Limitez les tokens : Définissez des limites raisonnables de max_tokens pour éviter des réponses inutilement longues
Utilisez la mise en cache : Mettez en cache les réponses pour des requêtes fréquentes ou similaires
Optimisez les batchs : Regroupez les requêtes quand c'est possible plutôt que de faire de multiples appels
Surveillez l'utilisation : Utilisez AWS CloudWatch pour suivre votre consommation et définir des alertes
1// Exemple de mise en cache simple avec Node.js et Redis
2const { createClient } = require('redis');
3const { BedrockRuntimeClient, InvokeModelCommand } = require('@aws-sdk/client-bedrock-runtime');
4
5const redis = createClient({
6 url: process.env.REDIS_URL || 'redis://localhost:6379'
7});
8
9const bedrock = new BedrockRuntimeClient({ region: 'us-west-2' });
10
11async function getCachedOrGenerateResponse(prompt, modelId = 'anthropic.claude-v2') {
12 await redis.connect();
13
14 try {
15 // Créer une clé de cache basée sur le prompt et le modèle
16 const cacheKey = `bedrock:${modelId}:${Buffer.from(prompt).toString('base64')}`;
17
18 // Vérifier si une réponse est déjà en cache
19 const cachedResponse = await redis.get(cacheKey);
20 if (cachedResponse) {
21 console.log('Réponse récupérée du cache');
22 return JSON.parse(cachedResponse);
23 }
24
25 // Si pas en cache, générer une nouvelle réponse
26 console.log('Génération d\'une nouvelle réponse');
27 const payload = {
28 prompt: prompt,
29 max_tokens_to_sample: 1000,
30 temperature: 0.7,
31 };
32
33 const command = new InvokeModelCommand({
34 modelId: modelId,
35 contentType: 'application/json',
36 accept: 'application/json',
37 body: JSON.stringify(payload),
38 });
39
40 const response = await bedrock.send(command);
41 const responseBody = JSON.parse(new TextDecoder().decode(response.body));
42
43 // Mettre en cache la réponse (avec expiration après 1 heure)
44 await redis.set(cacheKey, JSON.stringify(responseBody), { EX: 3600 });
45
46 return responseBody;
47 } catch (error) {
48 console.error('Erreur:', error);
49 throw error;
50 } finally {
51 await redis.disconnect();
52 }
53}Bonnes pratiques de sécurité
Utilisez des IAM policies restrictives : Limitez l'accès à Bedrock selon le principe du moindre privilège
Mettez en place des guardrails : Utilisez les guardrails Bedrock pour filtrer les contenus sensibles ou inappropriés
Chiffrez les données sensibles : Utilisez AWS KMS pour chiffrer les données en transit et au repos
Implémentez l'authentification forte : Utilisez API Gateway avec Cognito ou des clés API pour sécuriser vos endpoints
Auditez l'utilisation : Activez AWS CloudTrail pour enregistrer tous les appels d'API vers Bedrock
Surveillez les entrées et sorties : Mettez en place un système pour détecter les tentatives d'ingénierie de prompt ou d'extraction de données sensibles
Limites et considérations
Bien qu'AWS Bedrock soit un service puissant, il est important de comprendre ses limites :
Hallucinations : Comme tous les modèles génératifs, ceux de Bedrock peuvent parfois générer des informations inexactes ou fictives
Biais : Les modèles peuvent refléter les biais présents dans leurs données d'entraînement
Limites de contexte : Chaque modèle a une limite sur la quantité de texte qu'il peut traiter en une seule fois
Disponibilité régionale : Bedrock n'est pas disponible dans toutes les régions AWS
Limites de débit : Des quotas de service s'appliquent au nombre d'appels par seconde que vous pouvez effectuer
Modèles et fonctionnalités en évolution : Les capacités et les modèles disponibles changent au fil du temps
Pour atténuer les risques liés aux hallucinations, il est recommandé d'utiliser Bedrock avec des bases de connaissances ou des systèmes de RAG (Retrieval Augmented Generation) qui ancrent les réponses dans des sources de données fiables.
Conclusion
AWS Bedrock représente une avancée significative dans la démocratisation de l'IA générative pour les entreprises de toutes tailles. En fournissant un accès simple et unifié à une variété de modèles fondamentaux de pointe, Bedrock élimine les barrières techniques et financières qui ont traditionnellement limité l'adoption de l'IA avancée.
Les points clés à retenir :
Simplicité d'intégration : Une API unifiée pour accéder à une multitude de modèles fondamentaux
Flexibilité : La liberté de choisir et de changer de modèles en fonction de vos besoins
Sécurité et confidentialité : Des contrôles robustes pour protéger vos données et applications
Personnalisation : La capacité d'adapter les modèles à vos cas d'utilisation spécifiques
Évolutivité : Une architecture serverless qui évolue automatiquement avec vos besoins
Intégration AWS : Une connexion fluide avec l'écosystème AWS existant
Par où commencer ?
Si vous êtes prêt à explorer AWS Bedrock, commencez par vous familiariser avec la console Bedrock, expérimentez avec le playground intégré, puis passez aux exemples de code présentés dans cet article. Commencez petit, avec des cas d'utilisation bien définis, puis développez votre utilisation au fur et à mesure que vous gagnez en confiance et en expertise.
Alors que nous entrons dans une ère où l'IA générative devient un élément essentiel de l'innovation technologique, AWS Bedrock se positionne comme un outil fondamental pour les développeurs et les entreprises qui cherchent à exploiter cette technologie transformatrice. Avec sa combinaison unique de puissance, de flexibilité et de simplicité, Bedrock ouvre la voie à une nouvelle génération d'applications intelligentes qui changeront la façon dont nous interagissons avec la technologie.
N'oubliez pas que le domaine de l'IA générative évolue rapidement. Restez informé des nouvelles fonctionnalités et des nouveaux modèles ajoutés à Bedrock, car ils pourraient ouvrir de nouvelles possibilités pour vos applications.
