Zu Beginn des Jahres 2026 verfügt AWS über mehrere verwandte, aber unterschiedliche Komponenten, aus denen seine Agenten- und LLM-Abstraktionen bestehen.
- Grundgestein ist die Modellschicht, die den Zugriff auf große Sprachmodelle ermöglicht.
- Agenten für Bedrock ist die verwaltete Anwendungsschicht. Mit anderen Worten: AWS führt die Agenten entsprechend Ihren Anforderungen für Sie aus.
- Bedrock AgentCore ist eine Infrastrukturschicht, die es AWS ermöglicht, Agenten auszuführen, die Sie mithilfe von Drittanbieter-Frameworks wie CrewAI und LangGraph entwickeln.
Abgesehen von diesen drei Diensten bietet AWS auch Folgendes an Stränge, eine Open-Supply-Python-Bibliothek zum Erstellen von Agenten außerhalb des Bedrock-Dienstes, die dann auf anderen AWS-Diensten wie ECS und Lambda bereitgestellt werden kann.
Es kann verwirrend sein, weil alle drei agentenbasierten Dienste den Begriff „Bedrock“ im Namen tragen, aber in diesem Artikel werde ich mich auf den Normal-Bedrock-Dienst konzentrieren und zeigen, wie und warum Sie ihn verwenden würden. Normal-Bedrock-Service und zeigen Sie, wie und warum Sie ihn nutzen würden.
Als Service ist Bedrock erst seit Anfang 2023 auf AWS verfügbar. Das sollte Ihnen einen Hinweis darauf geben, warum es eingeführt wurde. Amazon konnte den Aufstieg großer Sprachmodelle und deren Auswirkungen auf die IT-Architektur und den Systementwicklungsprozess deutlich erkennen. Das sind Fleisch und Kartoffeln von AWS, und sie wollten, dass niemand ihr Mittagessen isst.
Und obwohl AWS einige eigene LLMs entwickelt hat, wurde ihm klar, dass es, um wettbewerbsfähig zu bleiben, den Benutzern die allerbesten Modelle, wie die von Anthropic, zur Verfügung stellen muss. Und hier kommt Bedrock ins Spiel. Wie sie in ihrem eigenen Klappentext auf ihrer Web site sagten:
… Bedrock ist ein vollständig verwalteter Dienst, der über eine einzige API eine Auswahl an leistungsstarken Basis-Modellen (FMs) von führenden KI-Unternehmen wie AI21 Labs, Anthropic, Cohere, Meta, Stability AI und Amazon sowie eine breite Palette an Funktionen bietet, die Sie zum Erstellen generativer KI-Anwendungen benötigen, um die Entwicklung zu vereinfachen und gleichzeitig Datenschutz und Sicherheit zu gewährleisten.
Wie greife ich auf Bedrock zu?
Okay, das ist die Theorie hinter dem Warum von Bedrock, aber wie bekommen wir Zugang dazu und können es tatsächlich nutzen? Es überrascht nicht, dass Sie als Erstes ein AWS-Konto benötigen. Ich gehe davon aus, dass Sie dies bereits haben. Wenn nicht, klicken Sie auf den folgenden Hyperlink, um eines einzurichten.
https://aws.amazon.com/account
Praktischerweise fällt nach der Registrierung für ein neues AWS-Konto ein Großteil der von Ihnen genutzten Dienste unter das sogenannte „kostenlose Kontingent“ bei AWS, was bedeutet, dass Ihre Kosten minimal sein sollten ein Jahr nach der Erstellung Ihres Kontos – vorausgesetzt, Sie werden nicht verrückt und starten riesige Rechenserver und dergleichen.
Es gibt drei Hauptmöglichkeiten, AWS-Dienste zu nutzen.
- Über die Konsole. Wenn Sie ein Anfänger sind, wird dies wahrscheinlich Ihre bevorzugte Route sein, da dies der einfachste Einstieg ist
- Über eine API. Wenn Sie sich mit Programmieren auskennen, können Sie über eine API auf alle Dienste von AWS zugreifen. Für Python-Programmierer stellt AWS beispielsweise Folgendes bereit boto3 Bibliothek. Es gibt ähnliche Bibliotheken für andere Sprachen wie JavaScript usw.
- Über die Befehlszeilenschnittstelle (CLI). Die CLI ist ein zusätzliches Software, das Sie von AWS herunterladen können und das Ihnen die Interaktion mit AWS-Diensten direkt von Ihrem Terminal aus ermöglicht.
Beachten Sie, dass Sie zur Verwendung der beiden letztgenannten Methoden Anmeldeinformationen auf Ihrem lokalen System eingerichtet haben sollten.
Was kann ich mit Bedrock machen?
Die kurze Antwort ist, dass Sie die meisten Dinge, die Sie können, mit regulären Chat-Modellen von OpenAI, Anthropic, Google usw. tun können. Bedrock liegt eine Reihe von Fundamentmodellen zugrunde, die Sie damit verwenden können, wie zum Beispiel:
- Kimi K2 Denken. Ein tiefes Argumentationsmodell
- Claude Opus 4.5. Für viele Menschen ist dies der beste LLM, der bisher verfügbar ist.
- GPT-OSS. OpenAIs Open-Supply-LLM
Und viele, viele andere darüber hinaus. Eine vollständige Liste finden Sie unter dem folgenden Hyperlink.
https://aws.amazon.com/bedrock/model-choice
Wie verwende ich Bedrock?
Um Bedrock zu verwenden, verwenden wir eine Mischung aus der AWS CLI und der Python-API, die von der boto3-Bibliothek bereitgestellt wird. Stellen Sie sicher, dass Sie die folgende Einrichtung als Voraussetzung haben
- Ein AWS-Konto.
- Die AWS CLI wurde heruntergeladen und auf Ihrem System installiert.
- Ein IAM-Benutzer (Identification and Entry Administration) wird mit den entsprechenden Berechtigungen und Zugriffsschlüsseln eingerichtet. Sie können dies über die AWS-Konsole tun.
- Konfigurieren Sie Ihre Benutzeranmeldeinformationen über die AWS CLI wie folgt. Im Allgemeinen müssen drei Informationen bereitgestellt werden. All das erhalten Sie aus dem vorherigen Schritt oben. Sie werden aufgefordert, relevante Informationen einzugeben.
$ aws configure
AWS Entry Key ID (None): AKIAIOSFODNN7EXAMPLE
AWS Secret Entry Key (None): wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
Default area identify (None): us-west-2
Default output format (None):Gewähren von Bedrock-Zugriff auf ein Modell
Früher (vor ein paar Monaten!) musste man die AWS-Verwaltungskonsole verwenden, um Zugriff auf bestimmte Modelle von Bedrock anzufordern, aber jetzt wird der Zugriff automatisch gewährt, wenn man ein Modell zum ersten Mal aufruft.
Beachten Sie, dass Erstbenutzer bei Anthropic-Modellen möglicherweise Anwendungsfalldetails übermitteln müssen, bevor sie auf das Modell zugreifen können. Beachten Sie auch den Zugriff auf Prime-Modelle von Anthropic und anderen Anbietern WilleKosten entstehen Stellen Sie daher bitte sicher, dass Sie Ihre Abrechnung regelmäßig überwachen und alle Modellzugänge entfernen, die Sie nicht mehr benötigen.
Allerdings müssen wir noch den Modellnamen kennen, den wir verwenden möchten. Um eine Liste aller Bedrock-kompatiblen Modelle zu erhalten, können wir den folgenden AWS CLI-Befehl verwenden.
aws bedrock list-foundation-modelsDadurch wird ein JSON-Ergebnissatz zurückgegeben, der verschiedene Eigenschaften jedes Modells auflistet, etwa so.
{
"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": {
"standing": "ACTIVE"
}
},
{
"modelArn": "arn:aws:bedrock:us-east-2::foundation-model/anthropic.claude-sonnet-4-20250514-v1:0",
...
...
...Wählen Sie das gewünschte Modell aus und notieren Sie es Modell-ID aus der JSON-Ausgabe, da wir diese später in unserem Python-Code benötigen. Ein wichtiger Vorbehalt hierbei ist, dass Sie in einer Modellbeschreibung häufig Folgendes sehen:
...
...
"inferenceTypesSupported": (
"INFERENCE_PROFILE"
)
...
...Dies ist Modellen vorbehalten, die:
- Sind groß oder sehr gefragt
- Erfordern reservierte oder verwaltete Kapazität
- Erfordert explizite Kosten- und Durchsatzkontrollen
Für diese Modelle können wir in unserem Code nicht einfach auf die Modell-ID verweisen. Stattdessen müssen wir auf eine verweisen Inferenzprofil. Ein Inferenzprofil ist eine Bedrock-Ressource, die an ein oder mehrere grundlegende LLMs und eine Area gebunden ist.
Es gibt zwei Möglichkeiten, ein Inferenzprofil zu erhalten, das Sie verwenden können. Die erste besteht darin, selbst eines zu erstellen. Diese werden Anwendungsprofile genannt. Die zweite Möglichkeit besteht darin, eines der von AWS unterstützten Profile zu verwenden. Dies ist die einfachere Choice, da sie für Sie vorgefertigt ist und Sie lediglich die relevante Profil-ID abrufen müssen, die mit dem Inferenzprofil verknüpft ist, um es in Ihrem Code zu verwenden.
Wenn Sie Ihr Anwendungsprofil erstellen möchten, sehen Sie sich die entsprechende AWS-Dokumentation an, aber ich werde in meinem Beispielcode ein unterstütztes Profil verwenden.
Eine Liste der unterstützten Profile in AWS finden Sie unter dem folgenden Hyperlink:
Für mein erstes Codebeispiel möchte ich Claudes Sonnet 3.5 V2-Modell verwenden, additionally habe ich auf die Zeile oben geklickt und die folgende Beschreibung gesehen.
Ich habe mir die Profil-ID ( us.anthropic.claude-3–5-sonnet-20241022-v2:0 ) und eine der gültigen Quellregionen ( us-east-1 ) notiert.
Für meine zweiten beiden Beispielcodeausschnitte verwende ich OpenAIs Open-Supply-LLM für die Textausgabe und den Titan Picture Generator von AWS für Bilder. Für keines dieser Modelle ist ein Inferenzprofil erforderlich. Sie können daher einfach die reguläre Modell-ID für sie in Ihrem Code verwenden.
Hinweis: Unabhängig davon, für welches Modell Sie sich entscheiden, stellen Sie sicher, dass Ihre AWS-Area für jedes Modell auf den richtigen Wert eingestellt ist.
Einrichten einer Entwicklungsumgebung
Da wir etwas programmieren werden, ist es am besten, Ihre Umgebung zu isolieren, damit wir keine unserer anderen Projekte beeinträchtigen. Additionally lasst uns das jetzt tun. Ich verwende dafür Home windows und den UV-Paketmanager, verwende aber das Software, mit dem du am besten zurechtkommst. Mein Code wird in einem Jupyter-Pocket book ausgeführt.
uv init bedrock_demo --python 3.13
cd bedrock_demo
uv add boto3 jupyter
# To run the pocket book, sort this in
uv run jupyter pocket bookVerwendung von Bedrock aus Python
Sehen wir uns Bedrock anhand einiger Beispiele in Aktion an. Das erste wird einfach sein, und wir werden die Komplexität im Laufe der Zeit schrittweise erhöhen.
Beispiel 1: Eine einfache Frage und Antwort unter Verwendung eines Inferenzprofils
In diesem Beispiel wird das Modell Claude Sonnet 3.5 V2 verwendet, über das wir zuvor gesprochen haben. Wie bereits erwähnt, verwenden wir zum Aufrufen dieses Modells eine Profil-ID, die seinem Inferenzprofil zugeordnet ist.
import json
import boto3
brt = boto3.shopper("bedrock-runtime", region_name="us-east-1")
profile_id = "us.anthropic.claude-3-5-sonnet-20241022-v2:0"
physique = json.dumps({
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 200,
"temperature": 0.2,
"messages": (
{
"function": "person",
"content material": (
{"sort": "textual content", "textual content": "What's the capital of France?"}
)
}
)
})
resp = brt.invoke_model(
modelId=profile_id,
physique=physique,
settle for="software/json",
contentType="software/json"
)
information = json.hundreds(resp("physique").learn())
# Claude responses come again as a "content material" array, not OpenAI "selections"
print(information("content material")(0)("textual content"))
#
# Output
#
The capital of France is Paris.Beachten Sie, dass durch den Aufruf dieses Modells (und ähnlicher Modelle) ein implizites Abonnement zwischen Ihnen und dem AWS-Marktplatz entsteht. Das ist nicht eine wiederkehrende regelmäßige Gebühr. Es fallen nur dann Kosten an, wenn das Modell tatsächlich genutzt wird. Es ist jedoch am besten, dies im Auge zu behalten, um unerwartete Rechnungen zu vermeiden. Sie sollten eine E-Mail mit einem Überblick über die Abonnementvereinbarung sowie einen Hyperlink zum Verwalten und/oder Kündigen bestehender eingerichteter Modellabonnements erhalten.
Beispiel 2: Erstellen Sie ein Bild
Eine einfache Picture-Erstellung mit dem AWS-eigenen Titan-Modell. Dieses Modell ist keinem Inferenzprofil zugeordnet, daher können wir es einfach über seine Modell-ID referenzieren.
import json
import base64
import boto3
brt_img = boto3.shopper("bedrock-runtime", region_name="us-east-1")
model_id_img = "amazon.titan-image-generator-v2:0"
immediate = "A hippo using a motorbike."
physique = json.dumps({
"taskType": "TEXT_IMAGE",
"textToImageParams": {
"textual content": immediate
},
"imageGenerationConfig": {
"numberOfImages": 1,
"top": 1024,
"width": 1024,
"cfgScale": 7.0,
"seed": 0
}
})
resp = brt_img.invoke_model(
modelId=model_id_img,
physique=physique,
settle for="software/json",
contentType="software/json"
)
information = json.hundreds(resp("physique").learn())
# Titan returns base64-encoded pictures within the "pictures" array
img_b64 = information("pictures")(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)Auf meinem System sah das Ausgabebild so aus.
Beispiel 3: Ein Triage-Assistent für den technischen Help, der das OSS-Modell von OpenAI verwendet
Dies ist ein komplexeres und nützlicheres Beispiel. Hier richten wir einen Assistenten ein, der von technisch nicht versierten Benutzern gemeldete Probleme aufnimmt und zusätzliche Fragen ausgibt, die der Benutzer möglicherweise beantworten soll, sowie die wahrscheinlichsten Ursachen des Issues und die weiteren Schritte, die ergriffen werden müssen. Wie unser vorheriges Beispiel ist dieses Modell nicht mit einem Inferenzprofil verknüpft.
import json
import re
import boto3
from pydantic import BaseModel, Discipline
from typing import Listing, Literal, Optionally available
# ----------------------------
# Bedrock setup
# ----------------------------
REGION = "us-east-2"
MODEL_ID = "openai.gpt-oss-120b-1:0"
brt = boto3.shopper("bedrock-runtime", region_name=REGION)
# ----------------------------
# Output schema
# ----------------------------
Severity = Literal("low", "medium", "excessive")
Class = Literal("account", "billing", "system", "community", "software program", "safety", "different")
class TriageResponse(BaseModel):
class: Class
severity: Severity
abstract: str = Discipline(description="One-sentence restatement of the issue.")
likely_causes: Listing(str) = Discipline(description="Prime believable causes, concise.")
clarifying_questions: Listing(str) = Discipline(description="Ask solely what is required to proceed.")
safe_next_steps: Listing(str) = Discipline(description="Step-by-step actions secure for a non-technical person.")
stop_and_escalate_if: Listing(str) = Discipline(description="Clear crimson flags that require an expert/helpdesk.")
recommended_escalation_target: Optionally available(str) = Discipline(
default=None,
description="If severity is excessive, who to contact (e.g., IT admin, financial institution, ISP)."
)
# ----------------------------
# Helpers
# ----------------------------
def invoke_chat(messages, max_tokens=800, temperature=0.2) -> dict:
physique = json.dumps({
"messages": messages,
"max_tokens": max_tokens,
"temperature": temperature
})
resp = brt.invoke_model(
modelId=MODEL_ID,
physique=physique,
settle for="software/json",
contentType="software/json"
)
return json.hundreds(resp("physique").learn())
def extract_content(information: dict) -> str:
return information("selections")(0)("message")("content material")
def extract_json_object(textual content: str) -> dict:
"""
Extract the primary JSON object from mannequin output.
Handles widespread instances like <reasoning> blocks or additional textual content.
"""
textual content = re.sub(r"<reasoning>.*?</reasoning>", "", textual content, flags=re.DOTALL).strip()
begin = textual content.discover("{")
if begin == -1:
elevate ValueError("No JSON object discovered.")
depth = 0
for i in vary(begin, len(textual content)):
if textual content(i) == "{":
depth += 1
elif textual content(i) == "}":
depth -= 1
if depth == 0:
return json.hundreds(textual content(begin:i+1))
elevate ValueError("Unbalanced JSON braces; couldn't parse.")
# ----------------------------
# The helpful operate
# ----------------------------
def triage_issue(user_problem: str) -> TriageResponse:
messages = (
{
"function": "system",
"content material": (
"You're a cautious technical help triage assistant for non-technical customers. "
"You have to be conservative and safety-first. "
"Return ONLY legitimate JSON matching the given schema. No additional textual content."
)
},
{
"function": "person",
"content material": f"""
Consumer drawback:
{user_problem}
Return JSON that matches this schema:
{TriageResponse.model_json_schema()}
""".strip()
}
)
uncooked = invoke_chat(messages)
textual content = extract_content(uncooked)
parsed = extract_json_object(textual content)
return TriageResponse.model_validate(parsed)
# ----------------------------
# Instance
# ----------------------------
if __name__ == "__main__":
drawback = "My laptop computer is related to Wi-Fi however web sites will not load, and Zoom retains saying unstable connection."
outcome = triage_issue(drawback)
print(outcome.model_dump_json(indent=2))Hier ist die Ausgabe.
"class": "community",
"severity": "medium",
"abstract": "Laptop computer reveals Wi‑Fi connection however can't load web sites and Zoom
experiences an unstable connection.",
"likely_causes": (
"Router or modem malfunction",
"DNS decision failure",
"Native Wi‑Fi interference or weak sign",
"IP handle battle on the community",
"Firewall or safety software program blocking site visitors",
"ISP outage or throttling"
),
"clarifying_questions": (
"Are different units on the identical Wi‑Fi community in a position to entry the web?",
"Did the issue begin after any latest adjustments (e.g., new software program, OS replace, VPN set up)?",
"Have you ever tried shifting nearer to the router or utilizing a wired Ethernet connection?",
"Do you see any error codes or messages within the browser or Zoom moreover "unstable connection"?"
),
"safe_next_steps": (
"Restart the router and modem by unplugging them for 30 seconds, then energy them again on.",
"On the laptop computer, neglect the Wi‑Fi community, then reconnect and re-enter the password.",
"Run the constructed‑in Home windows community troubleshooter (Settings → Community & Web → Standing → Community troubleshooter).",
"Disable any VPN or proxy quickly and check the connection once more.",
"Open a command immediate and run `ipconfig /launch` adopted by `ipconfig /renew`.",
"Flush the DNS cache with `ipconfig /flushdns`.",
"Strive accessing a easy web site (e.g., http://instance.com) and be aware if it hundreds.",
"If attainable, join the laptop computer to the router through Ethernet to see if the problem persists."
),
"stop_and_escalate_if": (
"The laptop computer nonetheless can't attain any web site after finishing all steps.",
"Different units on the identical community additionally can't entry the web.",
"You obtain error messages indicating {hardware} failure (e.g., Wi‑Fi adapter not discovered).",
"The router repeatedly restarts or reveals error lights.",
"Zoom continues to report a poor or unstable connection regardless of a working web check."
),
"recommended_escalation_target": "IT admin"
}Zusammenfassung
Dieser Artikel wurde vorgestellt AWS-Grundgestein, Das von AWS verwaltete Gateway zu grundlegenden großen Sprachmodellen erklärt, warum es existiert und wie es in das Gesamtbild passt AWS AI Stack und wie man ihn in der Praxis nutzt. Wir haben die Modellerkennung, die Einrichtung von Regionen und Anmeldeinformationen sowie den Hauptunterschied zwischen On-Demand-Modellen und solchen, die Inferenzprofile erfordern – eine häufige Quelle der Verwirrung für Entwickler – behandelt.
Anhand praktischer Python-Beispiele haben wir die Textual content- und Bildgenerierung sowohl mit standardmäßigen On-Demand-Modellen als auch mit solchen, die ein Inferenzprofil erfordern, demonstriert.
Im Kern spiegelt Bedrock die langjährige Philosophie von AWS wider: die Komplexität der Infrastruktur zu abstrahieren, ohne die Kontrolle zu verlieren. Anstatt ein einzelnes „bestes“ Modell voranzutreiben, behandelt Bedrock Basis-Modelle als verwaltete Infrastrukturkomponenten – austauschbar, steuerbar und regional orientiert. Dies deutet auf eine Zukunft hin, in der sich Bedrock weniger als Chat-Schnittstelle, sondern mehr als Modellorchestrierungsschicht entwickelt, die eng mit IAM, Netzwerken, Kostenkontrollen und Agenten-Frameworks integriert ist.
Im Laufe der Zeit können wir davon ausgehen, dass sich Bedrock weiter in Richtung standardisierter Inferenzverträge (Abonnements) und einer klareren Trennung zwischen Experimentier- und Produktionskapazität bewegt. Und mit ihren Agent- und AgentCore-Diensten sehen wir bereits eine tiefere Integration von Agenten-Workflows mit Bedrock, wodurch Modelle nicht als eigenständige Produkte, sondern als dauerhafte Bausteine innerhalb von AWS-Systemen positioniert werden.
Zur Klarstellung: Abgesehen davon, dass ich gelegentlich deren Dienste nutze, habe ich keine Verbindung oder Zugehörigkeit zu Amazon Net Companies