Skip to content
Learni
View all tutorials
Cloud & IA

Comment maîtriser AWS Bedrock avec TypeScript en 2026

18 minEXPERT
TypeScriptAWSIntelligence ArtificielleBedrock

Introduction

AWS Bedrock permet d'accéder à des modèles de fondation comme Claude, Llama ou Titan via une API unifiée sans gérer l'infrastructure. En 2026, son adoption explose pour les cas d'usage RAG et agents autonomes. Ce tutoriel expert vous guide pas à pas dans l'intégration TypeScript avancée, du client basique jusqu'aux architectures résilientes en production. Vous apprendrez à gérer le streaming, les knowledge bases et la sécurité IAM de manière professionnelle.

Prérequis

  • Node.js 20+ et TypeScript 5.4+
  • Compte AWS avec accès à Bedrock (us-east-1 ou eu-west-3)
  • Connaissances solides en IAM et SDK v3
  • AWS CLI configuré avec credentials

Initialisation du client Bedrock

src/lib/bedrock-client.ts
import { BedrockRuntimeClient, InvokeModelCommand } from '@aws-sdk/client-bedrock-runtime';

const client = new BedrockRuntimeClient({
  region: 'eu-west-3',
  credentials: {
    accessKeyId: process.env.AWS_ACCESS_KEY_ID!,
    secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY!,
  },
});

Ce client réutilisable configure la région et les credentials via variables d'environnement. Toujours utiliser le SDK v3 pour de meilleures performances et tree-shaking.

Invocation simple d'un modèle

src/services/invoke-model.ts
import { InvokeModelCommand } from '@aws-sdk/client-bedrock-runtime';

export async function invokeClaude(prompt: string) {
  const command = new InvokeModelCommand({
    modelId: 'anthropic.claude-3-5-sonnet-20241022-v2:0',
    contentType: 'application/json',
    accept: 'application/json',
    body: JSON.stringify({
      anthropic_version: 'bedrock-2023-05-31',
      max_tokens: 1024,
      messages: [{ role: 'user', content: prompt }],
    }),
  });
  const response = await client.send(command);
  return JSON.parse(new TextDecoder().decode(response.body));
}

Code complet et fonctionnel pour invoquer Claude 3.5. Validez toujours le modelId et gérez les tokens pour éviter les erreurs de quota.

Gestion du streaming de réponse

src/services/stream-response.ts
import { InvokeModelWithResponseStreamCommand } from '@aws-sdk/client-bedrock-runtime';

export async function* streamClaude(prompt: string) {
  const command = new InvokeModelWithResponseStreamCommand({
    modelId: 'anthropic.claude-3-5-sonnet-20241022-v2:0',
    contentType: 'application/json',
    body: JSON.stringify({
      anthropic_version: 'bedrock-2023-05-31',
      max_tokens: 2048,
      messages: [{ role: 'user', content: prompt }],
    }),
  });
  const response = await client.send(command);
  for await (const event of response.body!) {
    if (event.chunk) {
      const chunk = JSON.parse(new TextDecoder().decode(event.chunk.bytes));
      yield chunk.delta?.text || '';
    }
  }
}

Le streaming réduit la latence perçue. Utilisez un générateur async pour consommer les chunks en temps réel dans une API route Next.js ou un WebSocket.

Intégration Knowledge Base

src/services/knowledge-base.ts
import { BedrockAgentRuntimeClient, RetrieveAndGenerateCommand } from '@aws-sdk/client-bedrock-agent-runtime';

const agentClient = new BedrockAgentRuntimeClient({ region: 'eu-west-3' });

export async function retrieveAndGenerate(query: string, kbId: string) {
  const command = new RetrieveAndGenerateCommand({
    input: { text: query },
    retrieveAndGenerateConfiguration: {
      type: 'KNOWLEDGE_BASE',
      knowledgeBaseConfiguration: {
        knowledgeBaseId: kbId,
        modelArn: 'arn:aws:bedrock:eu-west-3::foundation-model/anthropic.claude-3-5-sonnet-20241022-v2:0',
      },
    },
  });
  return await agentClient.send(command);
}

Cette méthode permet un RAG managé sans infrastructure vectorielle. Le kbId provient de la console Bedrock après indexation de vos documents S3.

Gestion d'erreurs et retry

src/utils/retry.ts
import { ThrottlingException, ServiceQuotaExceededException } from '@aws-sdk/client-bedrock-runtime';

export async function withRetry<T>(fn: () => Promise<T>, maxRetries = 3): Promise<T> {
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await fn();
    } catch (error) {
      if ((error instanceof ThrottlingException || error instanceof ServiceQuotaExceededException) && i < maxRetries - 1) {
        await new Promise(r => setTimeout(r, 1000 * Math.pow(2, i)));
        continue;
      }
      throw error;
    }
  }
  throw new Error('Max retries exceeded');
}

Implémentez un backoff exponentiel pour les erreurs de throttling Bedrock. C'est critique en production pour maintenir la disponibilité.

Bonnes pratiques

  • Toujours activer le logging CloudWatch et monitorer les InvokeModel metrics
  • Utiliser des IAM roles avec permission minimale (bedrock:InvokeModel sur modèles précis)
  • Valider et sanitizer les prompts pour éviter les injections
  • Mettre en cache les réponses fréquentes avec Redis ou DynamoDB
  • Configurer des guardrails Bedrock pour filtrer les contenus sensibles

Erreurs courantes à éviter

  • Oublier de demander l'accès aux modèles dans la console Bedrock (erreur AccessDenied)
  • Ignorer les limites de tokens et recevoir des réponses tronquées
  • Ne pas gérer les exceptions ThrottlingException en production
  • Utiliser des credentials root au lieu de rôles IAM dédiés

Pour aller plus loin

Approfondissez la création d'agents autonomes et les architectures multi-modèles dans notre formation AWS Bedrock Avancé.