AWS Bedrock

Le service d'IA générative d'AWS qui permet d'accéder à des grands modèles de langage de pointe comme Claude, Mistral et Llama via une API unifiée, sans avoir à gérer l'infrastructure.

Retour aux compétences Documentation officielle

Pour les non-initiés

Qu'est-ce qu'AWS Bedrock ?

Imaginez AWS Bedrock comme une place de marché d'intelligences artificielles facile d'accès, où vous pouvez essayer et utiliser différentes IA créées par les leaders du domaine (comme Anthropic avec Claude ou Meta avec Llama), le tout depuis une seule et même plateforme.

Sans AWS Bedrock, pour utiliser ces différentes IA, il faudrait s'inscrire à plusieurs services, apprendre différentes APIs, gérer plusieurs facturations et parfois même installer des infrastructures complexes. C'est comme devoir vous inscrire à 10 services de streaming vidéo différents au lieu d'avoir un portail unique qui vous donne accès à tout.

Les avantages de Bedrock

Confidentialité et sécurité

Vos données restent dans votre environnement AWS sécurisé — elles ne sont pas utilisées pour entraîner les modèles d'IA et respectent les mêmes normes de sécurité que vos autres services AWS.

Choix et flexibilité

Testez et utilisez différents modèles d'IA pour trouver celui qui répond le mieux à vos besoins spécifiques, sans vous engager exclusivement avec un seul fournisseur.

Simplicité d'intégration

Intégrez l'IA dans vos applications existantes via des API standardisées, sans avoir à gérer l'infrastructure complexe normalement nécessaire pour faire fonctionner ces modèles.

Personnalisation possible

Adaptez les modèles d'IA à vos besoins spécifiques en les entraînant avec vos propres données, sans avoir besoin d'expertise en science des données avancée.

En résumé, AWS Bedrock est une solution qui simplifie considérablement l'adoption de l'IA générative dans les entreprises, en offrant un accès facile à plusieurs modèles de pointe, avec la sécurité, l'évolutivité et la simplicité qu'offre l'écosystème AWS.

Pour les développeurs

Fonctionnement technique

AWS Bedrock est un service entièrement géré qui offre une API unifiée pour accéder à divers modèles fondamentaux (FMs) de plusieurs fournisseurs via l'infrastructure AWS. Il permet aux développeurs d'intégrer et de déployer des capacités d'IA générative dans leurs applications sans avoir à gérer l'infrastructure complexe nécessaire pour exécuter ces modèles à grande échelle.

Architecture et fonctionnalités

Accès aux modèles fondamentaux

Bedrock fournit l'accès à une variété de modèles fondamentaux de premier plan via une seule API, incluant Claude d'Anthropic, Llama 2 de Meta, Mistral, Stable Diffusion, et les modèles d'Amazon (Titan).

Appel à Claude via l'API Bedrock (Node.js)

// Exemple d'utilisation de l'SDK AWS avec Node.js pour appeler Claude via Bedrock
import { BedrockRuntimeClient, InvokeModelCommand } from "@aws-sdk/client-bedrock-runtime";

async function generateText(prompt) {
  // Initialiser le client Bedrock
  const client = new BedrockRuntimeClient({ 
    region: "us-west-2" // Région où Bedrock est disponible
  });

  // Préparer la requête pour Claude
  const payload = {
    prompt: `

Human: ${prompt}

Assistant:`,
    max_tokens_to_sample: 2000,
    temperature: 0.7,
    top_k: 250,
    top_p: 0.999,
    stop_sequences: ["

Human:"]
  };

  // Configurer la commande
  const command = new InvokeModelCommand({
    modelId: "anthropic.claude-v2", // Modèle Claude v2 via Bedrock
    contentType: "application/json",
    accept: "application/json",
    body: JSON.stringify(payload)
  });

  try {
    // Envoyer la requête
    const response = await client.send(command);
    
    // Traiter la réponse
    const responseBody = JSON.parse(new TextDecoder().decode(response.body));
    return responseBody.completion;
    
  } catch (error) {
    console.error("Erreur lors de l'appel à Bedrock:", error);
    throw error;
  }
}

Personnalisation des modèles

Bedrock permet d'adapter les modèles fondamentaux à vos cas d'usage spécifiques par fine-tuning, en utilisant vos propres données d'entraînement stockées dans S3. Cela se fait sans avoir à gérer l'infrastructure d'entraînement complexe.

Personnalisation de modèle avec AWS SDK

// Exemple de personnalisation de modèle avec AWS Bedrock (AWS SDK v3)
import { BedrockClient, CreateModelCustomizationJobCommand } from "@aws-sdk/client-bedrock";

async function customizeModel() {
  // Initialiser le client Bedrock (non pas bedrock-runtime, mais bedrock pour la gestion)
  const client = new BedrockClient({ 
    region: "us-west-2"
  });

  // Configuration du job de personnalisation
  const customizationJobParams = {
    customizationName: "mon-assistant-juridique",
    modelId: "anthropic.claude-v2",
    baseModelIdentifier: "anthropic.claude-v2",
    jobName: "personnalisation-assistant-juridique",
    hyperParameters: {
      epochCount: "5",
      batchSize: "4",
      learningRate: "0.00001"
    },
    trainingDataConfig: {
      s3Uri: "s3://mon-bucket/donnees-entrainement/"
    },
    outputDataConfig: {
      s3Uri: "s3://mon-bucket/resultats-personnalisation/"
    },
    roleArn: "arn:aws:iam::123456789012:role/BedrockCustomizationRole"
  };

  // Création de la commande
  const command = new CreateModelCustomizationJobCommand(customizationJobParams);

  try {
    // Envoi de la commande
    const response = await client.send(command);
    console.log("Job de personnalisation créé avec succès:", response.jobArn);
    return response;
  } catch (error) {
    console.error("Erreur lors de la création du job de personnalisation:", error);
    throw error;
  }
}

Agents Bedrock

Les agents Bedrock sont des assistants d'IA qui peuvent effectuer des tâches complexes, répondre aux questions et prendre des actions en utilisant d'autres services AWS comme Lambda et DynamoDB. Ils permettent de créer des applications d'IA conversationnelles sans avoir à gérer le flux de conversation et l'orchestration des tâches.

Création d'un agent Bedrock avec AWS CDK

// Exemple de création d'un agent Bedrock avec AWS CDK en TypeScript
import * as cdk from 'aws-cdk-lib';
import { Construct } from 'constructs';
import * as bedrock from 'aws-cdk-lib/aws-bedrock';
import * as iam from 'aws-cdk-lib/aws-iam';
import * as lambda from 'aws-cdk-lib/aws-lambda';
import * as dynamodb from 'aws-cdk-lib/aws-dynamodb';

export class BedrockAgentStack extends cdk.Stack {
  constructor(scope: Construct, id: string, props?: cdk.StackProps) {
    super(scope, id, props);
    
    // Créer une table DynamoDB pour stocker les données
    const productTable = new dynamodb.Table(this, 'ProductCatalog', {
      partitionKey: {
        name: 'productId',
        type: dynamodb.AttributeType.STRING
      },
      billingMode: dynamodb.BillingMode.PAY_PER_REQUEST,
      removalPolicy: cdk.RemovalPolicy.DESTROY
    });
    
    // Créer une fonction Lambda qui sera utilisée comme action d'agent
    const productSearchFunction = new lambda.Function(this, 'ProductSearchFunction', {
      runtime: lambda.Runtime.NODEJS_18_X,
      handler: 'index.handler',
      code: lambda.Code.fromAsset('lambda/product_search'),
      environment: {
        TABLE_NAME: productTable.tableName
      }
    });
    
    // Donner l'accès à la table DynamoDB à la fonction Lambda
    productTable.grantReadData(productSearchFunction);
    
    // Créer un rôle pour l'agent Bedrock
    const agentRole = new iam.Role(this, 'BedrockAgentRole', {
      assumedBy: new iam.ServicePrincipal('bedrock.amazonaws.com')
    });
    
    // Permissions pour invoquer la fonction Lambda
    productSearchFunction.grantInvoke(agentRole);
    
    // Créer un agent Bedrock
    const agent = new bedrock.CfnAgent(this, 'BedrockAgent', {
      agentName: 'ProductCatalogAgent',
      foundationModel: 'anthropic.claude-v2',
      instruction: 'Tu es un assistant qui aide les clients à trouver des produits dans notre catalogue. ' +
                  'Utilise l'action de recherche pour trouver des produits correspondant aux demandes des clients.',
      agentResourceRoleArn: agentRole.roleArn
    });
    
    // Créer une action d'agent pour rechercher des produits
    const searchActionGroup = new bedrock.CfnAgentActionGroup(this, 'SearchActionGroup', {
      actionGroupName: 'ProductSearchAction',
      actionGroupExecutor: {
        lambda: {
          lambdaFunctionArn: productSearchFunction.functionArn
        }
      },
      description: 'Search for products in the catalog',
      parentAgentId: agent.attrAgentId
    });
    
    // Définir la dépendance pour s'assurer que l'agent est créé avant l'action
    searchActionGroup.addDependency(agent);
    
    // Outputs
    new cdk.CfnOutput(this, 'AgentId', {
      value: agent.attrAgentId
    });
  }
}

Intégration multi-langages

Bedrock propose des SDKs pour les langages de programmation courants comme Node.js, permettant aux développeurs d'intégrer facilement ses fonctionnalités dans leurs applications existantes et de l'utiliser avec des frameworks comme React.

Utilisation de Bedrock avec NodeJs

// Exemple d'utilisation de l'SDK AWS avec Node.js pour appeler Mistral via Bedrock
import { BedrockRuntimeClient, InvokeModelCommand } from "@aws-sdk/client-bedrock-runtime";

async function generateText(prompt) {
  // Initialiser le client Bedrock
  const client = new BedrockRuntimeClient({ 
    region: "us-west-2" // Région où Bedrock est disponible
  });

  // Préparer la requête pour Mistral
  const payload = {
    prompt: prompt,
    max_tokens: 1024,
    temperature: 0.7,
    top_p: 0.8
  };

  // Configurer la commande
  const command = new InvokeModelCommand({
    modelId: "mistral.mistral-7b-instruct-v0",
    contentType: "application/json",
    accept: "application/json",
    body: JSON.stringify(payload)
  });

  try {
    // Envoyer la requête
    const response = await client.send(command);
    
    // Traiter la réponse
    const responseBody = JSON.parse(new TextDecoder().decode(response.body));
    return responseBody.outputs[0].text;
    
  } catch (error) {
    console.error("Erreur lors de l'appel à Bedrock:", error);
    throw error;
  }
}

Considérations de sécurité et performances

Contrôle d'accès précis via IAM (Identity and Access Management) pour sécuriser l'accès aux modèles
Chiffrement des données en transit et au repos via AWS KMS pour protéger les informations sensibles
Conformité avec les normes de sécurité AWS et intégration au VPC pour un accès privé
Mise à l'échelle automatique pour gérer les variations de charge sans configuration manuelle
Métriques et surveillance via CloudWatch pour analyser les performances et coûts
Contrôle de coûts avec des quotas ajustables pour prévenir les dépenses imprévues

Modèles disponibles (début 2024)

Anthropic: Claude v1, Claude v2, Claude Instant v1
Meta: Llama 2 (7B, 13B, 70B)
Mistral AI: Mistral 7B, Mixtral 8x7B
Stability AI: Stable Diffusion XL
Amazon: Titan Text, Titan Embeddings, Titan Image Generator
Cohere: Command, Command Light, Embed

Applications concrètes

Cas d'usage

Assistants virtuels avancés

Création de chatbots intelligents capables de comprendre des questions complexes, de mener des conversations naturelles et de fournir des réponses personnalisées basées sur les données de l'entreprise.

Génération et analyse de contenu

Production automatisée de textes marketing, d'articles, de rapports ou de descriptions de produits, ainsi que l'analyse et le résumé de documents volumineux pour en extraire les informations clés.

Moteurs de recherche augmentés

Amélioration des moteurs de recherche internes avec une compréhension sémantique des requêtes, permettant de retrouver des informations pertinentes même lorsque les mots-clés exacts ne sont pas utilisés.

Génération d'images et design

Création d'images, de designs et d'illustrations à partir de descriptions textuelles, adaptée aux besoins spécifiques des marques et optimisée pour différents formats et canaux.

Automatisation de processus métier

Extraction intelligente d'informations à partir de documents non structurés, classification automatique de demandes clients, et automatisation de tâches comme la rédaction d'emails personnalisés à grande échelle.

Assistance au développement

Génération de code, débogage, documentation automatique et création de tests unitaires, permettant aux développeurs d'accélérer leur travail et de se concentrer sur les aspects créatifs et stratégiques.