Une introduction à AWS Bedrock | Vers la science des données

début 2026, AWS comporte plusieurs composants liés mais distincts qui composent ses abstractions agentiques et LLM.

• Base est la couche modèle qui permet d’accéder à de grands modèles de langage.
• Agents pour le substrat rocheux est la couche d’application gérée. En d’autres termes, AWS exécute les agents pour vous en fonction de vos besoins.
• Agent de base est une couche d’infrastructure qui permet à AWS d’exécuter les agents que vous développez à l’aide de frameworks tiers tels que CrewAI et LangGraph.

Outre ces trois services, AWS propose également Brins, une bibliothèque Python open source pour créer des agents en dehors du service Bedrock, qui peut ensuite être déployée sur d’autres services AWS tels que ECS et Lambda.

Cela peut prêter à confusion car les trois services basés sur des agents portent le terme « Bedrock » dans leur nom, mais dans cet article, je vais me concentrer sur le service Bedrock standard et montrer comment et pourquoi vous l’utiliseriez. service Bedrock standard et montrez comment et pourquoi vous l’utiliseriez.

En tant que service, Bedrock n’est disponible sur AWS que depuis début 2023. Cela devrait vous donner une idée de la raison pour laquelle il a été introduit. Amazon pouvait clairement constater la montée en puissance des grands modèles de langage et leur impact sur l’architecture informatique et le processus de développement des systèmes. C’est la viande et les pommes de terre d’AWS, et ils tenaient à ce que personne ne mange leur déjeuner.

Et bien qu’AWS ait développé ses propres LLM, elle s’est rendu compte que pour rester compétitive, elle devrait mettre les modèles les plus performants, tels que ceux d’Anthropic, à la disposition des utilisateurs. Et c’est là que Bedrock intervient. Comme ils l’ont dit dans leur propre texte de présentation sur leur site Web,

… Bedrock est un service entièrement géré qui offre un choix de modèles de base (FM) hautes performances provenant de grandes sociétés d’IA telles que AI21 Labs, Anthropic, Cohere, Meta, Stability AI et Amazon via une seule API, ainsi qu’un large ensemble de capacités dont vous avez besoin pour créer des applications d’IA génératives, simplifiant le développement tout en préservant la confidentialité et la sécurité.

Comment accéder à Bedrock ?

Ok, c’est donc la théorie derrière le pourquoi de Bedrock, mais comment y accéder et l’utiliser réellement ? Sans surprise, la première chose dont vous avez besoin est un compte AWS. Je vais supposer que vous l’avez déjà, mais sinon, cliquez sur le lien suivant pour en créer un.

https://aws.amazon.com/account

Utilement, après avoir créé un nouveau compte AWS, un bon nombre des services que vous utilisez relèveront du « niveau gratuit » chez AWS, ce qui signifie que vos coûts devraient être minimes pour un an après la création de votre compte – en supposant que vous ne deveniez pas fou et que vous ne commenciez pas à lancer d’énormes serveurs de calcul, etc.

Il existe trois manières principales d’utiliser les services AWS.

• Via la console. Si vous êtes débutant, ce sera probablement votre itinéraire préféré car c’est le moyen le plus simple de commencer.
• Via une API. Si vous êtes doué en codage, vous pouvez accéder à tous les services d’AWS via une API. Par exemple, pour les programmeurs Python, AWS fournit le boto3 bibliothèque. Il existe des bibliothèques similaires pour d’autres langages, tels que JavaScript, etc.
• Via l’interface de ligne de commande (CLI). La CLI est un outil supplémentaire que vous pouvez télécharger depuis AWS et vous permet d’interagir avec les services AWS directement depuis votre terminal.

Notez que, pour utiliser les deux dernières méthodes, vous devez avoir configuré vos informations de connexion sur votre système local.

Que puis-je faire avec Bedrock ?

La réponse courte est que vous pouvez faire la plupart des choses que vous pouvez avec les modèles de chat classiques d’OpenAI, Anthropic, Google, etc. Le substrat rocheux sous-jacent contient un certain nombre de modèles de fondation que vous pouvez utiliser, tels que : –

• Kimi K2 Pensée. Un modèle de raisonnement profond
• Claude Opus 4.5. Pour beaucoup de gens, il s’agit du meilleur LLM disponible à ce jour.
• GPT-OSS. LLM open source d’OpenAI

Et bien d’autres encore. Pour une liste complète, consultez le lien suivant.

https://aws.amazon.com/bedrock/model-choice

Comment utiliser le substrat rocheux ?

Pour utiliser Bedrock, nous utiliserons un mélange de l’AWS CLI et de l’API Python fournie par la bibliothèque boto3. Assurez-vous d’avoir la configuration suivante comme condition préalable

• Un compte AWS.
• L’AWS CLI a été téléchargée et installée sur votre système.
• Un utilisateur de gestion des identités et des accès (IAM) est configuré avec les autorisations et les clés d’accès appropriées. Vous pouvez le faire via la console AWS.
• Configurez vos informations d’identification utilisateur via l’AWS CLI comme ceci. En général, trois informations doivent être fournies. Tout ce que vous obtiendrez à l’étape précédente ci-dessus. Vous serez invité à saisir les informations pertinentes,

$ aws configure

AWS Access Key ID [None]: AKIAIOSFODNN7EXAMPLE
AWS Secret Access Key [None]: wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
Default region name [None]: us-west-2
Default output format [None]:

Donner à Bedrock l’accès à un modèle

À l’époque (il y a quelques mois !), vous deviez utiliser la console de gestion AWS pour demander l’accès à des modèles particuliers à Bedrock, mais désormais l’accès est automatiquement accordé lorsque vous invoquez un modèle pour la première fois.

Notez que pour les modèles Anthropic, les nouveaux utilisateurs devront peut-être soumettre les détails du cas d’utilisation avant de pouvoir accéder au modèle. Notez également que l’accès aux meilleurs modèles d’Anthropic et d’autres fournisseurs volontéengager des frais assurez-vous donc de surveiller régulièrement votre facturation et de supprimer tout accès aux modèles dont vous n’avez plus besoin.

Cependant, nous devons encore connaître le nom du modèle que nous souhaitons utiliser. Pour obtenir une liste de tous les modèles compatibles Bedrock, nous pouvons utiliser la commande AWS CLI suivante.

aws bedrock list-foundation-models

Cela renverra un jeu de résultats JSON répertoriant diverses propriétés de chaque modèle, comme celui-ci.

{
    "modelSummaries": [
        {
            "modelArn": "arn:aws:bedrock:us-east-2::foundation-model/nvidia.nemotron-nano-12b-v2",
            "modelId": "nvidia.nemotron-nano-12b-v2",
            "modelName": "NVIDIA Nemotron Nano 12B v2 VL BF16",
            "providerName": "NVIDIA",
            "inputModalities": [
                "TEXT",
                "IMAGE"
            ],
            "outputModalities": [
                "TEXT"
            ],
            "responseStreamingSupported": true,
            "customizationsSupported": [],
            "inferenceTypesSupported": [
                "ON_DEMAND"
            ],
            "modelLifecycle": {
                "status": "ACTIVE"
            }
        },
        {
            "modelArn": "arn:aws:bedrock:us-east-2::foundation-model/anthropic.claude-sonnet-4-20250514-v1:0",
...
...
...

Choisissez le modèle dont vous avez besoin et notez son ID modèle à partir de la sortie JSON, car nous en aurons besoin plus tard dans notre code Python. Une mise en garde importante à ce sujet est que vous verrez souvent ce qui suit dans la description d’un modèle :

...
...
"inferenceTypesSupported": [
    "INFERENCE_PROFILE"
]
...
...

Ceci est réservé aux modèles qui :

• Sont grands ou très demandés
• Exiger une capacité réservée ou gérée
• Nécessité de contrôles explicites des coûts et du débit

Pour ces modèles, nous ne pouvons pas simplement référencer le modelID dans notre code. Au lieu de cela, nous devons faire référence à un profil d’inférence. Un profil d’inférence est une ressource Bedrock liée à un ou plusieurs LLM fondamentaux et à une région.

Il existe deux manières d’obtenir un profil d’inférence que vous pouvez utiliser. La première consiste à en créer un vous-même. Ceux-ci sont appelés profils d’application. La deuxième méthode consiste à utiliser l’un des profils pris en charge par AWS. Il s’agit de l’option la plus simple, car elle est prédéfinie pour vous et il vous suffit d’obtenir l’ID de profil correspondant associé au profil d’inférence à utiliser dans votre code.

Si vous souhaitez créer votre profil d’application, consultez la documentation AWS appropriée, mais je vais utiliser un profil pris en charge dans mon exemple de code.

Pour obtenir la liste des profils pris en charge dans AWS, consultez le lien ci-dessous :

https://docs.aws.amazon.com/bedrock/latest/userguide/inference-profiles-support.html#inference-profiles-support-system

Pour mon premier exemple de code, je souhaite utiliser le modèle Sonnet 3.5 V2 de Claude, j’ai donc cliqué sur la ligne ci-dessus et vu la description suivante.

J’ai pris note de l’identifiant du profil ( us.anthropic.claude-3–5-sonnet-20241022-v2:0 ) et de l’une des régions sources valides ( us-east-1 )

Pour mes deux deuxièmes exemples d’extraits de code, j’utiliserai le LLM open source d’OpenAI pour la sortie de texte et le générateur d’images Titan d’AWS pour les images. Aucun de ces modèles ne nécessite de profil d’inférence, vous pouvez donc simplement utiliser le modelID normal pour eux dans votre code.

NB : quel que soit le(s) modèle(s) que vous choisissez, assurez-vous que votre région AWS est définie sur la valeur correcte pour chacun.

Mise en place d’un environnement de développement

Comme nous allons faire du codage, il est préférable d’isoler votre environnement afin de ne pas interférer avec aucun de nos autres projets. Alors faisons-le maintenant. J’utilise Windows et le gestionnaire de packages UV pour cela, mais utilisez l’outil avec lequel vous êtes le plus à l’aise. Mon code s’exécutera dans un notebook Jupyter.

uv init bedrock_demo --python 3.13
cd bedrock_demo
uv add boto3 jupyter

# To run the notebook, type this in
uv run jupyter notebook

Utiliser Bedrock à partir de Python

Voyons Bedrock en action avec quelques exemples. La première sera simple, et nous augmenterons progressivement la complexité au fur et à mesure.

Exemple 1 : Une question et une réponse simples utilisant un profil d’inférence

Cet exemple utilise le modèle Claude Sonnet 3.5 V2 dont nous avons parlé plus tôt. Comme mentionné, pour invoquer ce modèle, nous utilisons un identifiant de profil associé à son profil d’inférence.

import json
import boto3

brt = boto3.client("bedrock-runtime", region_name="us-east-1")

profile_id = "us.anthropic.claude-3-5-sonnet-20241022-v2:0"

body = json.dumps({
    "anthropic_version": "bedrock-2023-05-31",
    "max_tokens": 200,
    "temperature": 0.2,
    "messages": [
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "What is the capital of France?"}
            ]
        }
    ]
})

resp = brt.invoke_model(
    modelId=profile_id,
    body=body,
    accept="application/json",
    contentType="application/json"
)

data = json.loads(resp["body"].read())

# Claude responses come back as a "content" array, not OpenAI "choices"
print(data["content"][0]["text"])

#
# Output
#
The capital of France is Paris.

Notez que l’invocation de ce modèle (et d’autres similaires) crée un abonnement implicite entre vous et la place de marché d’AWS. C’est pas une charge régulière récurrente. Cela ne vous coûte que lorsque le modèle est réellement utilisé, mais il est préférable de surveiller cela pour éviter des factures inattendues. Vous devriez recevoir un e-mail décrivant le contrat d’abonnement, avec un lien pour gérer et/ou annuler tout abonnement modèle existant configuré.

Exemple 2 : Créer une image

Une création d’image simple à l’aide du modèle Titan d’AWS. Ce modèle n’est pas associé à un profil d’inférence, nous pouvons donc simplement le référencer à l’aide de son modelID.

import json
import base64
import boto3

brt_img = boto3.client("bedrock-runtime", region_name="us-east-1")
model_id_img = "amazon.titan-image-generator-v2:0"

prompt = "A hippo riding a bike."

body = json.dumps({
    "taskType": "TEXT_IMAGE",
    "textToImageParams": {
        "text": prompt
    },
    "imageGenerationConfig": {
        "numberOfImages": 1,
        "height": 1024,
        "width": 1024,
        "cfgScale": 7.0,
        "seed": 0
    }
})

resp = brt_img.invoke_model(
    modelId=model_id_img,
    body=body,
    accept="application/json",
    contentType="application/json"
)

data = json.loads(resp["body"].read())

# Titan returns base64-encoded images in the "images" array
img_b64 = data["images"][0]
img_bytes = base64.b64decode(img_b64)

out_path = "titan_output.png"
with open(out_path, "wb") as f:
    f.write(img_bytes)

print("Saved:", out_path)

Sur mon système, l’image de sortie ressemblait à ceci.

Exemple 3 : un assistant de tri du support technique utilisant le modèle OSS d’OpenAI

Il s’agit d’un exemple plus complexe et utile. Ici, nous avons mis en place un assistant qui prendra en compte les problèmes signalés par des utilisateurs non techniques et affichera des questions supplémentaires auxquelles vous souhaiterez peut-être que l’utilisateur réponde, ainsi que les causes les plus probables du problème et les mesures supplémentaires à prendre. Comme notre exemple précédent, ce modèle n’est pas associé à un profil d’inférence.

import json
import re
import boto3
from pydantic import BaseModel, Field
from typing import List, Literal, Optional

# ----------------------------
# Bedrock setup
# ----------------------------
REGION = "us-east-2"
MODEL_ID = "openai.gpt-oss-120b-1:0"

brt = boto3.client("bedrock-runtime", region_name=REGION)

# ----------------------------
# Output schema
# ----------------------------
Severity = Literal["low", "medium", "high"]
Category = Literal["account", "billing", "device", "network", "software", "security", "other"]

class TriageResponse(BaseModel):
    category: Category
    severity: Severity
    summary: str = Field(description="One-sentence restatement of the problem.")
    likely_causes: List[str] = Field(description="Top plausible causes, concise.")
    clarifying_questions: List[str] = Field(description="Ask only what is needed to proceed.")
    safe_next_steps: List[str] = Field(description="Step-by-step actions safe for a non-technical user.")
    stop_and_escalate_if: List[str] = Field(description="Clear red flags that require a professional/helpdesk.")
    recommended_escalation_target: Optional[str] = Field(
        default=None,
        description="If severity is high, who to contact (e.g., IT admin, bank, ISP)."
    )

# ----------------------------
# Helpers
# ----------------------------
def invoke_chat(messages, max_tokens=800, temperature=0.2) -> dict:
    body = json.dumps({
        "messages": messages,
        "max_tokens": max_tokens,
        "temperature": temperature
    })

    resp = brt.invoke_model(
        modelId=MODEL_ID,
        body=body,
        accept="application/json",
        contentType="application/json"
    )
    return json.loads(resp["body"].read())

def extract_content(data: dict) -> str:
    return data["choices"][0]["message"]["content"]

def extract_json_object(text: str) -> dict:
    """
    Extract the first JSON object from model output.
    Handles common cases like <reasoning> blocks or extra text.
    """
    text = re.sub(r"<reasoning>.*?</reasoning>", "", text, flags=re.DOTALL).strip()

    start = text.find("{")
    if start == -1:
        raise ValueError("No JSON object found.")

    depth = 0
    for i in range(start, len(text)):
        if text[i] == "{":
            depth += 1
        elif text[i] == "}":
            depth -= 1
            if depth == 0:
                return json.loads(text[start:i+1])

    raise ValueError("Unbalanced JSON braces; could not parse.")

# ----------------------------
# The useful function
# ----------------------------
def triage_issue(user_problem: str) -> TriageResponse:
    messages = [
        {
            "role": "system",
            "content": (
                "You are a careful technical support triage assistant for non-technical users. "
                "You must be conservative and safety-first. "
                "Return ONLY valid JSON matching the given schema. No extra text."
            )
        },
        {
            "role": "user",
            "content": f"""
User problem:
{user_problem}

Return JSON that matches this schema:
{TriageResponse.model_json_schema()}
""".strip()
        }
    ]

    raw = invoke_chat(messages)
    text = extract_content(raw)
    parsed = extract_json_object(text)
    return TriageResponse.model_validate(parsed)

# ----------------------------
# Example
# ----------------------------
if __name__ == "__main__":
    problem = "My laptop is connected to Wi-Fi but websites won't load, and Zoom keeps saying unstable connection."
    result = triage_issue(problem)
    print(result.model_dump_json(indent=2))

Voici le résultat.

"category": "network",
  "severity": "medium",
  "summary": "Laptop shows Wi‑Fi connection but cannot load websites and Zoom 
              reports an unstable connection.",
  "likely_causes": [
    "Router or modem malfunction",
    "DNS resolution failure",
    "Local Wi‑Fi interference or weak signal",
    "IP address conflict on the network",
    "Firewall or security software blocking traffic",
    "ISP outage or throttling"
  ],
  "clarifying_questions": [
    "Are other devices on the same Wi‑Fi network able to access the internet?",
    "Did the problem start after any recent changes (e.g., new software, OS update, VPN installation)?",
    "Have you tried moving closer to the router or using a wired Ethernet connection?",
    "Do you see any error codes or messages in the browser or Zoom besides \"unstable connection\"?"
  ],
  "safe_next_steps": [
    "Restart the router and modem by unplugging them for 30 seconds, then power them back on.",
    "On the laptop, forget the Wi‑Fi network, then reconnect and re-enter the password.",
    "Run the built‑in Windows network troubleshooter (Settings → Network & Internet → Status → Network troubleshooter).",
    "Disable any VPN or proxy temporarily and test the connection again.",
    "Open a command prompt and run `ipconfig /release` followed by `ipconfig /renew`.",
    "Flush the DNS cache with `ipconfig /flushdns`.",
    "Try accessing a simple website (e.g., http://example.com) and note if it loads.",
    "If possible, connect the laptop to the router via Ethernet to see if the issue persists."
  ],
  "stop_and_escalate_if": [
    "The laptop still cannot reach any website after completing all steps.",
    "Other devices on the same network also cannot access the internet.",
    "You receive error messages indicating hardware failure (e.g., Wi‑Fi adapter not found).",
    "The router repeatedly restarts or shows error lights.",
    "Zoom continues to report a poor or unstable connection despite a working internet test."
  ],
  "recommended_escalation_target": "IT admin"
}

Résumé

Cet article a présenté substrat rocheux AWS, La passerelle gérée d’AWS vers les grands modèles de langage de base, expliquant pourquoi elle existe, comment elle s’intègre dans le contexte plus large. Pile AWS AI et comment l’utiliser dans la pratique. Nous avons abordé la découverte de modèles, la configuration des régions et des informations d’identification, ainsi que la distinction clé entre les modèles à la demande et ceux qui nécessitent des profils d’inférence – une source courante de confusion pour les développeurs.

Grâce à des exemples pratiques de Python, nous avons démontré la génération de texte et d’images en utilisant à la fois des modèles standard à la demande et ceux qui nécessitent un profil d’inférence.

À la base, Bedrock reflète la philosophie de longue date d’AWS : abstrait de la complexité de l’infrastructure sans supprimer le contrôle. Plutôt que de promouvoir un seul « meilleur » modèle, Bedrock traite les modèles de base comme des composants d’infrastructure gérés – échangeables, gouvernables et sensibles à la région. Cela suggère un avenir dans lequel Bedrock évoluera moins en tant qu’interface de discussion qu’en tant que couche d’orchestration de modèles, étroitement intégrée à l’IAM, à la mise en réseau, aux contrôles de coûts et aux cadres d’agents.

Au fil du temps, nous pourrions nous attendre à ce que Bedrock évolue davantage vers des contrats d’inférence standardisés (abonnements) et une séparation plus claire entre l’expérimentation et la capacité de production. Et avec leurs services Agent et AgentCore, nous constatons déjà une intégration plus profonde des flux de travail agentiques avec Bedrock, positionnant les modèles non pas comme des produits en eux-mêmes mais comme des éléments de base durables au sein des systèmes AWS.

---

Pour éviter tout doute, en plus d’être un utilisateur occasionnel de leurs services, je n’ai aucun lien ni affiliation avec Amazon Web Services.