Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Erste Schritte
In diesem Handbuch erfahren Sie, wie Sie maßgeschneiderte Amazon Nova-Modelle auf SageMaker Echtzeit-Endpunkten bereitstellen, Inferenzparameter konfigurieren und Ihre Modelle zu Testzwecken aufrufen.
## Voraussetzungen
Die folgenden Voraussetzungen müssen erfüllt sein, um Amazon Nova-Modelle auf Basis von SageMaker Inferenz bereitzustellen:
+ Erstellen Sie ein AWS-Konto — Falls Sie noch keines haben, finden Sie weitere Informationen unter [AWS Konto erstellen](https://docs.aws.amazon.com//sagemaker/latest/dg/gs-set-up.html#sign-up-for-aws).
+ Erforderliche IAM-Berechtigungen — Stellen Sie sicher, dass Ihrem IAM-Benutzer oder Ihrer IAM-Rolle die folgenden verwalteten Richtlinien zugeordnet sind:
+ `AmazonSageMakerFullAccess`
+ `AmazonS3FullAccess`
+ Erforderliche SDKs/CLI Versionen — Die folgenden SDK-Versionen wurden mit Amazon Nova-Modellen auf SageMaker Inferenz getestet und validiert:
+ SageMaker Python SDK v3.0.0\+ (`sagemaker>=3.0.0`) für ressourcenbasierten API-Ansatz
+ Boto3 Version 1.35.0\+ () für direkte API-Aufrufe. `boto3>=1.35.0` Die Beispiele in diesem Handbuch verwenden diesen Ansatz.
+ Erhöhung des Servicekontingents — Fordern Sie eine Erhöhung des Amazon SageMaker Service-Kontingents für den ML-Instance-Typ an, den Sie für Ihren SageMaker Inference-Endpunkt verwenden möchten (z. B.`ml.p5.48xlarge for endpoint usage`). Eine Liste mit unterstützten Instance-Typen finden Sie unter [Unterstützte Modelle und Instanzen](nova-model-sagemaker-inference.md#nova-sagemaker-inference-supported). Informationen zur Beantragung einer Erhöhung finden Sie unter [Eine Erhöhung des Kontingents beantragen](https://docs.aws.amazon.com//servicequotas/latest/userguide/request-quota-increase.html). Informationen zu SageMaker Instanzkontingenten finden Sie unter [SageMaker Endpunkte und Kontingente](https://docs.aws.amazon.com//general/latest/gr/sagemaker.html).
**Tipp**
Für eine schnelle Komplettbereitstellung können Sie das [Custom Nova Model SageMaker Inference Notebook](https://github.com/aws-samples/amazon-nova-samples/blob/main/customization/Nova_2.0/05_deployment/Custom-Nova-Model-SageMaker-Inference.ipynb) ausführen, um ein benutzerdefiniertes Amazon Nova-Modell auf SageMaker Inferenz in einem einzigen Notebook bereitzustellen.
## Schritt 1: Anmeldeinformationen konfigurieren AWS
Konfigurieren Sie Ihre AWS Anmeldeinformationen mit einer der folgenden Methoden:
**Option 1: AWS CLI (Empfohlen)**
```
aws configure
```
Geben Sie Ihren AWS Zugriffsschlüssel, Ihren geheimen Schlüssel und Ihre Standardregion ein, wenn Sie dazu aufgefordert werden.
**Option 2: Datei mit den AWS Anmeldeinformationen**
Erstellen oder bearbeiten`~/.aws/credentials`:
```
[default]
aws_access_key_id = YOUR_ACCESS_KEY
aws_secret_access_key = YOUR_SECRET_KEY
```
**Option 3: Umgebungsvariablen**
```
export AWS_ACCESS_KEY_ID=your_access_key
export AWS_SECRET_ACCESS_KEY=your_secret_key
```
**Anmerkung**
Weitere Informationen zu AWS Anmeldeinformationen finden Sie unter [Konfiguration und Einstellungen für Anmeldeinformationsdateien](https://docs.aws.amazon.com//cli/latest/userguide/cli-configure-files.html).
**Clients initialisieren AWS **
Erstellen Sie ein Python-Skript oder ein Notizbuch mit dem folgenden Code, um das AWS SDK zu initialisieren und Ihre Anmeldeinformationen zu überprüfen:
```
import boto3
# AWS Configuration - Update these for your environment
REGION = "us-east-1" # Supported regions: us-east-1, us-west-2
AWS_ACCOUNT_ID = "YOUR_ACCOUNT_ID" # Replace with your AWS account ID
# Initialize AWS clients using default credential chain
sagemaker = boto3.client('sagemaker', region_name=REGION)
sts = boto3.client('sts')
# Verify credentials
try:
identity = sts.get_caller_identity()
print(f"Successfully authenticated to AWS Account: {identity['Account']}")
if identity['Account'] != AWS_ACCOUNT_ID:
print(f"Warning: Connected to account {identity['Account']}, expected {AWS_ACCOUNT_ID}")
except Exception as e:
print(f"Failed to authenticate: {e}")
print("Please verify your credentials are configured correctly.")
```
Wenn die Authentifizierung erfolgreich ist, sollten Sie eine Ausgabe sehen, die Ihre AWS Konto-ID bestätigt.
## Schritt 2: Erstellen Sie eine SageMaker Ausführungsrolle
Eine SageMaker Ausführungsrolle ist eine IAM-Rolle, die SageMaker Berechtigungen für den Zugriff auf AWS Ressourcen in Ihrem Namen gewährt, z. B. Amazon S3 S3-Buckets für Modellartefakte und CloudWatch für die Protokollierung.
**Die Ausführungsrolle erstellen**
**Anmerkung**
Für die Erstellung von IAM-Rollen sind `iam:AttachRolePolicy` Berechtigungen erforderlich`iam:CreateRole`. Stellen Sie sicher, dass Ihr IAM-Benutzer oder Ihre IAM-Rolle über diese Berechtigungen verfügt, bevor Sie fortfahren.
Der folgende Code erstellt eine IAM-Rolle mit den erforderlichen Berechtigungen für die Bereitstellung benutzerdefinierter Amazon Nova-Modelle:
```
import json
# Create SageMaker Execution Role
role_name = f"SageMakerInference-ExecutionRole-{AWS_ACCOUNT_ID}"
trust_policy = {
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {"Service": "sagemaker.amazonaws.com"},
"Action": "sts:AssumeRole"
}
]
}
iam = boto3.client('iam', region_name=REGION)
# Create the role
role_response = iam.create_role(
RoleName=role_name,
AssumeRolePolicyDocument=json.dumps(trust_policy),
Description='SageMaker execution role with S3 and SageMaker access'
)
# Attach required policies
iam.attach_role_policy(
RoleName=role_name,
PolicyArn='arn:aws:iam::aws:policy/AmazonSageMakerFullAccess'
)
iam.attach_role_policy(
RoleName=role_name,
PolicyArn='arn:aws:iam::aws:policy/AmazonS3FullAccess'
)
SAGEMAKER_EXECUTION_ROLE_ARN = role_response['Role']['Arn']
print(f"Created SageMaker execution role: {SAGEMAKER_EXECUTION_ROLE_ARN}")
```
**Verwenden einer vorhandenen Ausführungsrolle (optional)**
Wenn Sie bereits über eine SageMaker Ausführungsrolle verfügen, können Sie diese stattdessen verwenden:
```
# Replace with your existing role ARN
SAGEMAKER_EXECUTION_ROLE_ARN = "arn:aws:iam::YOUR_ACCOUNT_ID:role/YOUR_EXISTING_ROLE_NAME"
```
So finden Sie bestehende SageMaker Rollen in Ihrem Konto:
```
iam = boto3.client('iam', region_name=REGION)
response = iam.list_roles()
sagemaker_roles = [role for role in response['Roles'] if 'SageMaker' in role['RoleName']]
for role in sagemaker_roles:
print(f"{role['RoleName']}: {role['Arn']}")
```
**Wichtig**
Die Ausführungsrolle muss über eine Vertrauensbeziehung zu Amazon S3 `sagemaker.amazonaws.com` und SageMaker Ressourcen verfügen und über Zugriffsberechtigungen verfügen.
Weitere Informationen zu SageMaker Ausführungsrollen finden Sie unter [SageMaker Rollen](https://docs.aws.amazon.com//sagemaker/latest/dg/sagemaker-roles.html).
## Schritt 3: Modellparameter konfigurieren
Konfigurieren Sie die Bereitstellungsparameter für Ihr Amazon Nova-Modell. Diese Einstellungen steuern das Modellverhalten, die Ressourcenzuweisung und die Inferenzmerkmale. Eine Liste der unterstützten Instanztypen und der jeweils unterstützten Werte für CONTEXT\_LENGTH und MAX\_CONCURRENCY finden Sie unter. [Unterstützte Modelle und Instanzen](nova-model-sagemaker-inference.md#nova-sagemaker-inference-supported) Eine vollständige Liste zusätzlicher Container-Funktionen wie Sampling-Standardwerte, spekulative Dekodierung und Quantisierung finden Sie unter. [Funktionen des Inferenzcontainers](nova-sagemaker-inference-container-features.md)
**Erforderliche Parameter**
+ `IMAGE`: Die Docker-Container-Image-URI für den Amazon Nova-Inferenzcontainer. Dies wird bereitgestellt von. AWS
+ `CONTEXT_LENGTH`: Länge des Modellkontextes.
+ `MAX_CONCURRENCY`: Maximale Anzahl von Sequenzen pro Iteration; legt die Grenze fest, wie viele einzelne Benutzeranfragen (Eingabeaufforderungen) gleichzeitig innerhalb eines einzelnen Batches auf der GPU verarbeitet werden können. Bereich: Ganzzahl größer als 0.
**Konfigurieren Sie Ihre Bereitstellung**
```
# AWS Configuration
REGION = "us-east-1" # Must match region from Step 1
# ECR Account mapping by region
ECR_ACCOUNT_MAP = {
"us-east-1": "708977205387",
"us-west-2": "176779409107"
}
# Container Image
IMAGE = f"{ECR_ACCOUNT_MAP[REGION]}.dkr.ecr.{REGION}.amazonaws.com/nova-inference-repo:SM-Inference-latest"
print(f"IMAGE = {IMAGE}")
# Required parameters
CONTEXT_LENGTH = "8000" # Maximum total context length
MAX_CONCURRENCY = "8" # Maximum concurrent sequences
# Build environment variables for the container
environment = {
'CONTEXT_LENGTH': CONTEXT_LENGTH,
'MAX_CONCURRENCY': MAX_CONCURRENCY,
# Optional: add container feature environment variables here.
# See "Inference Container Features" for the full list.
# Examples:
# 'DEFAULT_TEMPERATURE': '0.7',
# 'DEFAULT_MAX_NEW_TOKENS': '512',
# 'QUANTIZATION_DTYPE': 'fp8',
}
print("Environment configuration:")
for key, value in environment.items():
print(f" {key}: {value}")
```
**Konfigurieren Sie bereitstellungsspezifische Parameter**
Konfigurieren Sie jetzt die spezifischen Parameter für Ihre Amazon Nova-Modellbereitstellung, einschließlich des Standorts der Modellartefakte und der Auswahl des Instance-Typs.
**Legen Sie die Bereitstellungs-ID fest**
```
# Deployment identifier - use a descriptive name for your use case
JOB_NAME = "my-nova-deployment"
```
**Geben Sie den Speicherort der Modellartefakte**
Geben Sie die Amazon S3 S3-URI an, in der Ihre trainierten Amazon Nova-Modellartefakte gespeichert sind. Dies sollte der Ausgabeort für Ihr Modelltraining oder Ihre Feinabstimmung sein.
```
# S3 location of your trained Nova model artifacts
# Replace with your model's S3 URI - must end with /
MODEL_S3_LOCATION = "s3://your-bucket-name/path/to/model/artifacts/"
```
**Wählen Sie die Modellvariante und den Instanztyp aus**
```
# Configure model variant and instance type
TESTCASE = {
"model": "micro", # Options: micro, lite, lite2
"instance": "ml.g5.12xlarge" # Refer to "Supported models and instances" section
}
# Generate resource names
INSTANCE_TYPE = TESTCASE["instance"]
MODEL_NAME = JOB_NAME + "-" + TESTCASE["model"] + "-" + INSTANCE_TYPE.replace(".", "-")
ENDPOINT_CONFIG_NAME = MODEL_NAME + "-Config"
ENDPOINT_NAME = MODEL_NAME + "-Endpoint"
print(f"Model Name: {MODEL_NAME}")
print(f"Endpoint Config: {ENDPOINT_CONFIG_NAME}")
print(f"Endpoint Name: {ENDPOINT_NAME}")
```
**Benennungskonventionen**
Der Code generiert automatisch konsistente Namen für AWS Ressourcen:
+ Modellname: `{JOB_NAME}-{model}-{instance-type}`
+ Endpunktkonfiguration: `{MODEL_NAME}-Config`
+ Name des Endpunkts: `{MODEL_NAME}-Endpoint`
## Schritt 4: SageMaker Ressourcen erstellen und den Endpunkt bereitstellen
SageMaker bietet zwei Ansätze für die Bereitstellung von Modellen auf Echtzeit-Endpunkten. Wählen Sie den Ansatz, der zu Ihrem Anwendungsfall passt:
+ **Inferenzkomponenten** (empfohlen): Stellt Modelle als Inferenzkomponenten auf einem Endpunkt bereit. Dieser Ansatz ermöglicht es Ihnen, mehrere Modelle auf einem einzigen Endpunkt zu hosten, Modelle unabhängig voneinander zu skalieren und die Ressourcennutzung zu optimieren.
+ **Endpunkte mit einem einzigen Modell**: Stellt mithilfe eines Modellobjekts und einer Endpunktkonfiguration ein einzelnes Modell direkt auf einem Endpunkt bereit. Dieser Ansatz ist einfacher einzurichten und eignet sich für Entwicklungs-, Test- oder Workloads, für die nur ein Modell pro Endpunkt erforderlich ist.
### Option A: Erstellen mit Inferenzkomponenten
Bei Inferenzkomponenten erstellen Sie zuerst einen Endpunkt und stellen dann Ihr Modell als Inferenzkomponente auf diesem Endpunkt bereit. Dadurch wird das Modell von der Endpunktinfrastruktur entkoppelt, was Ihnen mehr Flexibilität bietet.
**Erstellen Sie die Endpunktkonfiguration**
Erstellen Sie eine Endpunktkonfiguration, die die Infrastruktur definiert, ohne ein Modell anzugeben. Der Instanztyp und die Anzahl der Instanzen werden auf Endpunktebene verwaltet:
```
# Create Endpoint Configuration for inference components
INFERENCE_COMPONENT_NAME = MODEL_NAME + "-IC"
try:
config_response = sagemaker.create_endpoint_config(
EndpointConfigName=ENDPOINT_CONFIG_NAME,
ProductionVariants=[
{
'VariantName': 'primary',
'InstanceType': INSTANCE_TYPE,
'InitialInstanceCount': 1,
'RoutingConfig': {
'RoutingStrategy': 'LEAST_OUTSTANDING_REQUESTS'
}
}
],
Tags=[
{
'Key': 'sagemaker:nova-inference-component',
'Value': 'true'
}
]
)
print("Endpoint configuration created successfully!")
print(f"Config ARN: {config_response['EndpointConfigArn']}")
except sagemaker.exceptions.ClientError as e:
print(f"Error creating endpoint configuration: {e}")
```
**Den Endpunkt erstellen und bereitstellen**
```
import time
try:
endpoint_response = sagemaker.create_endpoint(
EndpointName=ENDPOINT_NAME,
EndpointConfigName=ENDPOINT_CONFIG_NAME
)
print("Endpoint creation initiated successfully!")
print(f"Endpoint ARN: {endpoint_response['EndpointArn']}")
except Exception as e:
print(f"Error creating endpoint: {e}")
# Wait for endpoint to be InService
print("Waiting for endpoint to be InService...")
print("This typically takes 5-10 minutes...\n")
while True:
try:
response = sagemaker.describe_endpoint(EndpointName=ENDPOINT_NAME)
status = response['EndpointStatus']
if status == 'Creating':
print(f"⏳ Status: {status} - Provisioning infrastructure...")
elif status == 'InService':
print(f"✅ Status: {status}")
print(f"\nEndpoint '{ENDPOINT_NAME}' is ready.")
break
elif status == 'Failed':
print(f"❌ Status: {status}")
print(f"Failure Reason: {response.get('FailureReason', 'Unknown')}")
break
else:
print(f"Status: {status}")
except Exception as e:
print(f"Error checking endpoint status: {e}")
break
time.sleep(30)
```
**Erstellen Sie die Inferenzkomponente**
Sobald der Endpunkt fertig ist InService, stellen Sie Ihr Amazon Nova-Modell als Inferenzkomponente bereit:
```
try:
ic_response = sagemaker.create_inference_component(
InferenceComponentName=INFERENCE_COMPONENT_NAME,
EndpointName=ENDPOINT_NAME,
VariantName='primary',
Specification={
'Container': {
'Image': IMAGE,
'ArtifactUrl': MODEL_S3_LOCATION,
'Environment': environment
},
'ComputeResourceRequirements': {
'NumberOfCpuCoresRequired': 15,
'NumberOfAcceleratorDevicesRequired': 4,
'MinMemoryRequiredInMb': 25000
}
},
RuntimeConfig={
'CopyCount': 1
}
)
print("Inference component creation initiated!")
print(f"Inference Component ARN: {ic_response['InferenceComponentArn']}")
except sagemaker.exceptions.ClientError as e:
print(f"Error creating inference component: {e}")
```
Hauptparameter:
+ `InferenceComponentName`: Eindeutiger Bezeichner für Ihre Inferenzkomponente
+ `EndpointName`: Der Endpunkt, auf dem die Komponente bereitgestellt werden soll
+ `Image`: Docker-Container-Image-URI für Amazon Nova-Inferenz
+ `ArtifactUrl`: Amazon S3 S3-Standort Ihrer Modellartefakte
+ `Environment`: In Schritt 3 konfigurierte Umgebungsvariablen
+ `NumberOfCpuCoresRequired`: Anzahl der pro Modellkopie benötigten CPU-Kerne
+ `NumberOfAcceleratorDevicesRequired`: Anzahl der pro Modellkopie benötigten Beschleunigergeräte (GPUs)
+ `MinMemoryRequiredInMb`: Pro Modellkopie ist mindestens Speicherplatz in MB erforderlich
+ `CopyCount`: Anzahl der bereitzustellenden Modellkopien
**Überwachen Sie die Bereitstellung von Inferenzkomponenten**
```
# Wait for inference component to be InService
print("Waiting for inference component deployment...")
print("This typically takes 10-20 minutes as the model is loaded...\n")
while True:
try:
ic_desc = sagemaker.describe_inference_component(
InferenceComponentName=INFERENCE_COMPONENT_NAME
)
ic_status = ic_desc['InferenceComponentStatus']
if ic_status == 'Creating':
print(f"⏳ Status: {ic_status} - Loading model artifacts...")
elif ic_status == 'InService':
print(f"✅ Status: {ic_status}")
print(f"\nInference component '{INFERENCE_COMPONENT_NAME}' is ready!")
break
elif ic_status == 'Failed':
print(f"❌ Status: {ic_status}")
print(f"Failure Reason: {ic_desc.get('FailureReason', 'Unknown')}")
break
else:
print(f"Status: {ic_status}")
except Exception as e:
print(f"Error checking inference component status: {e}")
break
time.sleep(30)
```
**Anmerkung**
Wenn Sie den Endpunkt in Schritt 5 aufrufen, müssen Sie den `InferenceComponentName` Parameter in Ihre Aufruf-Aufrufe aufnehmen. Einzelheiten finden Sie in Schritt 5.
### Option B: Endpunkte mit einem einzigen Modell erstellen
Bei Einzelmodell-Endpunkten erstellen Sie ein SageMaker Modellobjekt, eine Endpunktkonfiguration und stellen dann den Endpunkt bereit. Bei diesem Ansatz wird das Modell direkt in die Endpunktkonfiguration gepackt.
**Erstellen Sie das SageMaker Modell**
Der folgende Code erstellt ein SageMaker Modell, das auf Ihre Amazon Nova-Modellartefakte verweist:
```
try:
model_response = sagemaker.create_model(
ModelName=MODEL_NAME,
PrimaryContainer={
'Image': IMAGE,
'ModelDataSource': {
'S3DataSource': {
'S3Uri': MODEL_S3_LOCATION,
'S3DataType': 'S3Prefix',
'CompressionType': 'None'
}
},
'Environment': environment
},
ExecutionRoleArn=SAGEMAKER_EXECUTION_ROLE_ARN,
EnableNetworkIsolation=True
)
print("Model created successfully!")
print(f"Model ARN: {model_response['ModelArn']}")
except sagemaker.exceptions.ClientError as e:
print(f"Error creating model: {e}")
```
Hauptparameter:
+ `ModelName`: Eindeutiger Bezeichner für Ihr Modell
+ `Image`: Docker-Container-Image-URI für Amazon Nova-Inferenz
+ `ModelDataSource`: Amazon S3 S3-Standort Ihrer Modellartefakte
+ `Environment`: In Schritt 3 konfigurierte Umgebungsvariablen
+ `ExecutionRoleArn`: IAM-Rolle aus Schritt 2
+ `EnableNetworkIsolation`: Aus Sicherheitsgründen auf True setzen (verhindert, dass der Container ausgehende Netzwerkanrufe tätigt)
**Erstellen Sie die Endpunktkonfiguration**
Erstellen Sie als Nächstes eine Endpunktkonfiguration, die Ihre Bereitstellungsinfrastruktur definiert:
```
# Create Endpoint Configuration
try:
production_variant = {
'VariantName': 'primary',
'ModelName': MODEL_NAME,
'InitialInstanceCount': 1,
'InstanceType': INSTANCE_TYPE,
}
config_response = sagemaker.create_endpoint_config(
EndpointConfigName=ENDPOINT_CONFIG_NAME,
ProductionVariants=[production_variant]
)
print("Endpoint configuration created successfully!")
print(f"Config ARN: {config_response['EndpointConfigArn']}")
except sagemaker.exceptions.ClientError as e:
print(f"Error creating endpoint configuration: {e}")
```
Hauptparameter:
+ `VariantName`: Identifier für diese Modellvariante (verwenden Sie „primary“ für Implementierungen mit nur einem Modell)
+ `ModelName`: Verweist auf das oben erstellte Modell
+ `InitialInstanceCount`: Anzahl der bereitzustellenden Instanzen (beginnen Sie mit 1, skalieren Sie bei Bedarf später)
+ `InstanceType`: In Schritt 3 ausgewählter ML-Instanztyp
**Stellen Sie den Endpunkt bereit**
```
import time
try:
endpoint_response = sagemaker.create_endpoint(
EndpointName=ENDPOINT_NAME,
EndpointConfigName=ENDPOINT_CONFIG_NAME
)
print("Endpoint creation initiated successfully!")
print(f"Endpoint ARN: {endpoint_response['EndpointArn']}")
except Exception as e:
print(f"Error creating endpoint: {e}")
```
**Überwachen Sie die Endpunktentwicklung**
Der folgende Code fragt den Endpunktstatus ab, bis die Bereitstellung abgeschlossen ist:
```
# Monitor endpoint creation progress
print("Waiting for endpoint creation to complete...")
print("This typically takes 15-30 minutes...\n")
while True:
try:
response = sagemaker.describe_endpoint(EndpointName=ENDPOINT_NAME)
status = response['EndpointStatus']
if status == 'Creating':
print(f"⏳ Status: {status} - Provisioning infrastructure and loading model...")
elif status == 'InService':
print(f"✅ Status: {status}")
print("\nEndpoint creation completed successfully!")
print(f"Endpoint Name: {ENDPOINT_NAME}")
print(f"Endpoint ARN: {response['EndpointArn']}")
break
elif status == 'Failed':
print(f"❌ Status: {status}")
print(f"Failure Reason: {response.get('FailureReason', 'Unknown')}")
print("\nFull response:")
print(response)
break
else:
print(f"Status: {status}")
except Exception as e:
print(f"Error checking endpoint status: {e}")
break
time.sleep(30) # Check every 30 seconds
```
**Überprüfen Sie die Ressourcenerstellung**
Sie können überprüfen, ob Ihre Ressourcen erfolgreich erstellt wurden:
```
# Describe the model
model_info = sagemaker.describe_model(ModelName=MODEL_NAME)
print(f"Model Status: {model_info['ModelName']} created")
# Describe the endpoint configuration
config_info = sagemaker.describe_endpoint_config(EndpointConfigName=ENDPOINT_CONFIG_NAME)
print(f"Endpoint Config Status: {config_info['EndpointConfigName']} created")
```
**Überprüfen Sie, ob der Endpunkt bereit ist**
Unabhängig davon, welchen Ansatz Sie gewählt haben, können Sie die Endpunktkonfiguration überprüfen:
```
# Get detailed endpoint information
endpoint_info = sagemaker.describe_endpoint(EndpointName=ENDPOINT_NAME)
print("\n=== Endpoint Details ===")
print(f"Endpoint Name: {endpoint_info['EndpointName']}")
print(f"Endpoint ARN: {endpoint_info['EndpointArn']}")
print(f"Status: {endpoint_info['EndpointStatus']}")
print(f"Creation Time: {endpoint_info['CreationTime']}")
print(f"Last Modified: {endpoint_info['LastModifiedTime']}")
# Get endpoint config for instance type details
endpoint_config_name = endpoint_info['EndpointConfigName']
endpoint_config = sagemaker.describe_endpoint_config(EndpointConfigName=endpoint_config_name)
# Display production variant details
for variant in endpoint_info['ProductionVariants']:
print(f"\nProduction Variant: {variant['VariantName']}")
print(f" Current Instance Count: {variant['CurrentInstanceCount']}")
print(f" Desired Instance Count: {variant['DesiredInstanceCount']}")
# Get instance type from endpoint config
for config_variant in endpoint_config['ProductionVariants']:
if config_variant['VariantName'] == variant['VariantName']:
print(f" Instance Type: {config_variant['InstanceType']}")
break
```
**Behebung von Fehlern bei der Endpunkterstellung**
Häufige Fehlerursachen:
+ **Unzureichende Kapazität**: Der angeforderte Instance-Typ ist in Ihrer Region nicht verfügbar
+ Lösung: Probieren Sie einen anderen Instance-Typ aus oder fordern Sie eine Erhöhung des Kontingents an
+ **IAM-Berechtigungen**: Der Ausführungsrolle fehlen die erforderlichen Berechtigungen
+ Lösung: Stellen Sie sicher, dass die Rolle Zugriff auf Amazon S3 S3-Modellartefakte und die erforderlichen SageMaker Berechtigungen hat
+ **Modellartefakte wurden nicht gefunden**: Die Amazon S3 S3-URI ist falsch oder es kann nicht darauf zugegriffen werden
+ Lösung: Überprüfen Sie die Amazon S3 S3-URI und überprüfen Sie die Bucket-Berechtigungen. Stellen Sie sicher, dass Sie sich in der richtigen Region befinden
+ **Ressourcenlimits**: Die Kontolimits für Endpunkte oder Instances wurden überschritten
+ Lösung: Beantragen Sie eine Erhöhung des Servicekontingents über Service Quotas oder AWS Support
**Anmerkung**
Wenn Sie einen ausgefallenen Endpunkt löschen und von vorne beginnen müssen:
```
sagemaker.delete_endpoint(EndpointName=ENDPOINT_NAME)
```
## Schritt 5: Rufen Sie den Endpunkt auf
Sobald Ihr Endpunkt da ist InService, können Sie Inferenzanfragen senden, um Prognosen aus Ihrem Amazon Nova-Modell zu generieren. SageMaker unterstützt synchrone Endpunkte (Echtzeit mit streaming/non Streaming-Modi) und asynchrone Endpunkte (Amazon S3-based für Batch-Verarbeitung).
**Richten Sie den Runtime-Client ein**
Erstellen Sie einen SageMaker Runtime-Client mit den entsprechenden Timeout-Einstellungen:
```
import json
import boto3
import botocore
from botocore.exceptions import ClientError
# Configure client with appropriate timeouts
config = botocore.config.Config(
read_timeout=120, # Maximum time to wait for response
connect_timeout=10, # Maximum time to establish connection
retries={'max_attempts': 3} # Number of retry attempts
)
# Create SageMaker Runtime client
runtime_client = boto3.client('sagemaker-runtime', config=config, region_name=REGION)
```
**Erstellen Sie eine universelle Inferenzfunktion**
Die folgende Funktion verarbeitet sowohl Streaming- als auch Nicht-Streaming-Anfragen. Sie verwendet die in Schritt 4 definierte `INFERENCE_COMPONENT_NAME` Variable. Wenn Sie die Implementierung mithilfe von Inferenzkomponenten (Option A) durchgeführt haben, wurde diese Einstellung auf `MODEL_NAME + "-IC"` gesetzt. Wenn Sie die Bereitstellung mit Einzelmodell-Endpunkten (Option B) durchgeführt haben, wurde dies nicht definiert. Stellen Sie es daher auf ein, `None` bevor Sie diesen Schritt ausführen:
```
# Only needed if you followed Option B (single model endpoints) in Step 4:
# INFERENCE_COMPONENT_NAME = None
def invoke_nova_endpoint(request_body):
"""
Invoke Nova endpoint with automatic streaming detection.
Supports both inference component and single model endpoint deployments.
Args:
request_body (dict): Request payload containing prompt and parameters
Returns:
dict: Response from the model (for non-streaming requests)
None: For streaming requests (prints output directly)
"""
body = json.dumps(request_body)
is_streaming = request_body.get("stream", False)
# Build invoke parameters
invoke_params = {
'EndpointName': ENDPOINT_NAME,
'ContentType': 'application/json',
'Body': body
}
# Add InferenceComponentName if using inference components
if INFERENCE_COMPONENT_NAME:
invoke_params['InferenceComponentName'] = INFERENCE_COMPONENT_NAME
try:
print(f"Invoking endpoint ({'streaming' if is_streaming else 'non-streaming'})...")
if is_streaming:
response = runtime_client.invoke_endpoint_with_response_stream(**invoke_params)
event_stream = response['Body']
for event in event_stream:
if 'PayloadPart' in event:
chunk = event['PayloadPart']
if 'Bytes' in chunk:
data = chunk['Bytes'].decode()
print("Chunk:", data)
else:
# Non-streaming inference
invoke_params['Accept'] = 'application/json'
response = runtime_client.invoke_endpoint(**invoke_params)
response_body = response['Body'].read().decode('utf-8')
result = json.loads(response_body)
print("✅ Response received successfully")
return result
except ClientError as e:
error_code = e.response['Error']['Code']
error_message = e.response['Error']['Message']
print(f"❌ AWS Error: {error_code} - {error_message}")
except Exception as e:
print(f"❌ Unexpected error: {str(e)}")
```
**Beispiel 1: Abschluss des Non-streaming Chats**
Verwenden Sie das Chat-Format für Konversationsinteraktionen:
```
# Non-streaming chat request
chat_request = {
"messages": [
{"role": "user", "content": "Hello! How are you?"}
],
"max_tokens": 100,
"max_completion_tokens": 100, # Alternative to max_tokens
"stream": False,
"temperature": 0.7,
"top_p": 0.9,
"top_k": 50,
"logprobs": True,
"top_logprobs": 3,
"allowed_token_ids": None, # List of allowed token IDs
"truncate_prompt_tokens": None, # Truncate prompt to this many tokens
"stream_options": None
}
response = invoke_nova_endpoint(chat_request)
```
**Beispielantwort**:
```
{
"id": "chatcmpl-123456",
"object": "chat.completion",
"created": 1234567890,
"model": "default",
"choices": [
{
"index": 0,
"message": {
"role": "assistant",
"content": "Hello! I'm doing well, thank you for asking. I'm here and ready to help you with any questions or tasks you might have. How can I assist you today?"
},
"logprobs": {
"content": [
{
"token": "Hello",
"logprob": -0.123,
"top_logprobs": [
{"token": "Hello", "logprob": -0.123},
{"token": "Hi", "logprob": -2.456},
{"token": "Hey", "logprob": -3.789}
]
}
# Additional tokens...
]
},
"finish_reason": "stop"
}
],
"usage": {
"prompt_tokens": 12,
"completion_tokens": 28,
"total_tokens": 40
}
}
```
**Beispiel 2: Einfache Textvervollständigung**
Verwenden Sie das Vervollständigungsformat für die einfache Textgenerierung:
```
# Simple completion request
completion_request = {
"prompt": "The capital of France is",
"max_tokens": 50,
"stream": False,
"temperature": 0.0,
"top_p": 1.0,
"top_k": -1, # -1 means no limit
"logprobs": 3, # Number of log probabilities to return
"allowed_token_ids": None, # List of allowed token IDs
"truncate_prompt_tokens": None, # Truncate prompt to this many tokens
"stream_options": None
}
response = invoke_nova_endpoint(completion_request)
```
**Beispielantwort**:
```
{
"id": "cmpl-789012",
"object": "text_completion",
"created": 1234567890,
"model": "default",
"choices": [
{
"text": " Paris.",
"index": 0,
"logprobs": {
"tokens": [" Paris", "."],
"token_logprobs": [-0.001, -0.002],
"top_logprobs": [
{" Paris": -0.001, " London": -5.234, " Rome": -6.789},
{".": -0.002, ",": -4.567, "!": -7.890}
]
},
"finish_reason": "stop"
}
],
"usage": {
"prompt_tokens": 6,
"completion_tokens": 2,
"total_tokens": 8
}
}
```
**Beispiel 3: Abschluss des Streaming-Chats**
```
# Streaming chat request
streaming_request = {
"messages": [
{"role": "user", "content": "Tell me a short story about a robot"}
],
"max_tokens": 200,
"stream": True,
"temperature": 0.7,
"top_p": 0.95,
"top_k": 40,
"logprobs": True,
"top_logprobs": 2,
"stream_options": {"include_usage": True}
}
invoke_nova_endpoint(streaming_request)
```
**Beispiel für eine Streaming-Ausgabe:**
```
Chunk: data: {"id":"chatcmpl-029ca032-fa01-4868-80b7-c4cb1af90fb9","object":"chat.completion.chunk","created":1772060532,"model":"default","choices":[{"index":0,"delta":{"role":"assistant","content":""},"logprobs":null,"finish_reason":null}],"prompt_token_ids":null}
Chunk: data: {"id":"chatcmpl-029ca032-fa01-4868-80b7-c4cb1af90fb9","object":"chat.completion.chunk","created":1772060532,"model":"default","choices":[{"index":0,"delta":{"content":" Once"},"logprobs":{"content":[{"token":"\u2581Once","logprob":-0.6078429222106934,"bytes":[226,150,129,79,110,99,101],"top_logprobs":[{"token":"\u2581Once","logprob":-0.6078429222106934,"bytes":[226,150,129,79,110,99,101]},{"token":"\u2581In","logprob":-0.7864127159118652,"bytes":[226,150,129,73,110]}]}]},"finish_reason":null,"token_ids":null}]}
Chunk: data: {"id":"chatcmpl-029ca032-fa01-4868-80b7-c4cb1af90fb9","object":"chat.completion.chunk","created":1772060532,"model":"default","choices":[{"index":0,"delta":{"content":" upon"},"logprobs":{"content":[{"token":"\u2581upon","logprob":-0.0012345,"bytes":[226,150,129,117,112,111,110],"top_logprobs":[{"token":"\u2581upon","logprob":-0.0012345,"bytes":[226,150,129,117,112,111,110]},{"token":"\u2581a","logprob":-6.789,"bytes":[226,150,129,97]}]}]},"finish_reason":null,"token_ids":null}]}
Chunk: data: {"id":"chatcmpl-029ca032-fa01-4868-80b7-c4cb1af90fb9","object":"chat.completion.chunk","created":1772060532,"model":"default","choices":[{"index":0,"delta":{"content":" a"},"logprobs":{"content":[{"token":"\u2581a","logprob":-0.0001234,"bytes":[226,150,129,97],"top_logprobs":[{"token":"\u2581a","logprob":-0.0001234,"bytes":[226,150,129,97]},{"token":"\u2581time","logprob":-9.123,"bytes":[226,150,129,116,105,109,101]}]}]},"finish_reason":null,"token_ids":null}]}
Chunk: data: {"id":"chatcmpl-029ca032-fa01-4868-80b7-c4cb1af90fb9","object":"chat.completion.chunk","created":1772060532,"model":"default","choices":[{"index":0,"delta":{"content":" time"},"logprobs":{"content":[{"token":"\u2581time","logprob":-0.0023456,"bytes":[226,150,129,116,105,109,101],"top_logprobs":[{"token":"\u2581time","logprob":-0.0023456,"bytes":[226,150,129,116,105,109,101]},{"token":",","logprob":-6.012,"bytes":[44]}]}]},"finish_reason":null,"token_ids":null}]}
# Additional chunks...
Chunk: data: {"id":"chatcmpl-029ca032-fa01-4868-80b7-c4cb1af90fb9","object":"chat.completion.chunk","created":1772060532,"model":"default","choices":[{"index":0,"delta":{},"logprobs":null,"finish_reason":"stop"}],"usage":{"prompt_tokens":15,"completion_tokens":87,"total_tokens":102}}
Chunk: data: [DONE]
```
**Beispiel 4: Abschluss eines multimodalen Chats**
Verwenden Sie das multimodale Format für Bild- und Texteingaben:
```
# Multimodal chat request (if supported by your model)
multimodal_request = {
"messages": [
{
"role": "user",
"content": [
{"type": "text", "text": "What's in this image?"},
{"type": "image_url", "image_url": {"url": "data:image/jpeg;base64,..."}}
]
}
],
"max_tokens": 150,
"temperature": 0.3,
"top_p": 0.8,
"stream": False
}
response = invoke_nova_endpoint(multimodal_request)
```
**Beispielantwort**:
```
{
"id": "chatcmpl-345678",
"object": "chat.completion",
"created": 1234567890,
"model": "default",
"choices": [
{
"index": 0,
"message": {
"role": "assistant",
"content": "The image shows..."
},
"finish_reason": "stop"
}
],
"usage": {
"prompt_tokens": 1250,
"completion_tokens": 45,
"total_tokens": 1295
}
}
```
## Schritt 6: Ressourcen bereinigen (optional)
Um unnötige Kosten zu vermeiden, löschen Sie die AWS Ressourcen, die Sie in diesem Tutorial erstellt haben. SageMaker Bei Endpunkten fallen Gebühren an, während sie laufen, auch wenn Sie nicht aktiv Inferenzanfragen stellen.
**Wichtig**
Das Löschen von Ressourcen ist dauerhaft und kann nicht rückgängig gemacht werden. Stellen Sie sicher, dass Sie diese Ressourcen nicht mehr benötigen, bevor Sie fortfahren.
**Initialisieren Sie den Cleanup-Client**
```
import boto3
import time
# Initialize SageMaker client
sagemaker = boto3.client('sagemaker', region_name=REGION)
```
**Löschen Sie die Inferenzkomponente (wenn Sie Option A verwenden)**
Wenn Sie die Bereitstellung mithilfe von Inferenzkomponenten durchgeführt haben, löschen Sie zuerst die Inferenzkomponente, bevor Sie den Endpunkt löschen:
```
# Delete inference component (Option A only)
try:
print("Deleting inference component...")
sagemaker.delete_inference_component(InferenceComponentName=INFERENCE_COMPONENT_NAME)
print(f"✅ Inference component '{INFERENCE_COMPONENT_NAME}' deletion initiated")
except Exception as e:
print(f"❌ Error deleting inference component: {e}")
# Wait for inference component to be deleted before proceeding
print("Waiting for inference component deletion...")
while True:
try:
sagemaker.describe_inference_component(InferenceComponentName=INFERENCE_COMPONENT_NAME)
time.sleep(10)
except sagemaker.exceptions.ClientError as e:
if e.response['Error']['Code'] == 'ValidationException':
print("✅ Inference component successfully deleted")
break
else:
print(f"Error: {e}")
break
```
**Löschen Sie den Endpunkt**
```
try:
print("Deleting endpoint...")
sagemaker.delete_endpoint(EndpointName=ENDPOINT_NAME)
print(f"✅ Endpoint '{ENDPOINT_NAME}' deletion initiated")
print("Charges will stop once deletion completes (typically 2-5 minutes)")
except Exception as e:
print(f"❌ Error deleting endpoint: {e}")
```
**Anmerkung**
Das Löschen des Endpunkts erfolgt asynchron. Sie können den Löschstatus überwachen:
```
import time
print("Monitoring endpoint deletion...")
while True:
try:
response = sagemaker.describe_endpoint(EndpointName=ENDPOINT_NAME)
status = response['EndpointStatus']
print(f"Status: {status}")
time.sleep(10)
except sagemaker.exceptions.ClientError as e:
if e.response['Error']['Code'] == 'ValidationException':
print("✅ Endpoint successfully deleted")
break
else:
print(f"Error: {e}")
break
```
**Löschen Sie die Endpunktkonfiguration**
Nachdem der Endpunkt gelöscht wurde, entfernen Sie die Endpunktkonfiguration:
```
try:
print("Deleting endpoint configuration...")
sagemaker.delete_endpoint_config(EndpointConfigName=ENDPOINT_CONFIG_NAME)
print(f"✅ Endpoint configuration '{ENDPOINT_CONFIG_NAME}' deleted")
except Exception as e:
print(f"❌ Error deleting endpoint configuration: {e}")
```
**Löschen Sie das Modell (nur Option B)**
Wenn Sie Einzelmodell-Endpunkte verwendet haben, entfernen Sie das SageMaker Modellobjekt:
```
try:
print("Deleting model...")
sagemaker.delete_model(ModelName=MODEL_NAME)
print(f"✅ Model '{MODEL_NAME}' deleted")
except Exception as e:
print(f"❌ Error deleting model: {e}")
```