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
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\$1 (`sagemaker>=3.0.0`) für ressourcenbasierten API-Ansatz
  + Boto3 Version 1.35.0\$1 () 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).

## 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 `iam:CreateRole` und Voraussetzungen erforderlich. 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\$1LENGTH und MAX\$1CONCURRENCY finden Sie unter. [Unterstützte Modelle und Instanzen](nova-model-sagemaker-inference.md#nova-sagemaker-inference-supported)

**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.

**Optionale Generierungsparameter**
+ `DEFAULT_TEMPERATURE`: Steuert die Zufälligkeit bei der Generierung. Bereich: 0,0 bis 2,0 (0,0 = deterministisch, höher = eher zufällig).
+ `DEFAULT_TOP_P`: Nucleus-Sampling-Schwellenwert für die Token-Auswahl. Bereich: 1e-10 bis 1,0.
+ `DEFAULT_TOP_K`: Beschränkt die Token-Auswahl auf die Top K der wahrscheinlichsten Tokens. Bereich: Ganzzahl -1 oder größer (-1 = kein Limit).
+ `DEFAULT_MAX_NEW_TOKENS`: Maximale Anzahl von Token, die als Antwort generiert werden sollen (d. h. maximale Anzahl von Ausgabetoken). Bereich: Ganzzahl 1 oder größer.
+ `DEFAULT_LOGPROBS`: Anzahl der Log-Wahrscheinlichkeiten, die pro Token zurückgegeben werden sollen. Bereich: Ganzzahl 1 bis 20.

**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}")

# Model Parameters
CONTEXT_LENGTH = "16000"       # Maximum total context length
MAX_CONCURRENCY = "2"          # Maximum concurrent sequences

# Optional: Default generation parameters (uncomment to use)
DEFAULT_TEMPERATURE = "0.0"   # Deterministic output
DEFAULT_TOP_P = "1.0"         # Consider all tokens
# DEFAULT_TOP_K = "50"        # Uncomment to limit to top 50 tokens
# DEFAULT_MAX_NEW_TOKENS = "2048"  # Uncomment to set max output tokens
# DEFAULT_LOGPROBS = "1"      # Uncomment to enable log probabilities

# Build environment variables for the container
environment = {
    'CONTEXT_LENGTH': CONTEXT_LENGTH,
    'MAX_CONCURRENCY': MAX_CONCURRENCY,
}

# Add optional parameters if defined
if 'DEFAULT_TEMPERATURE' in globals():
    environment['DEFAULT_TEMPERATURE'] = DEFAULT_TEMPERATURE
if 'DEFAULT_TOP_P' in globals():
    environment['DEFAULT_TOP_P'] = DEFAULT_TOP_P
if 'DEFAULT_TOP_K' in globals():
    environment['DEFAULT_TOP_K'] = DEFAULT_TOP_K
if 'DEFAULT_MAX_NEW_TOKENS' in globals():
    environment['DEFAULT_MAX_NEW_TOKENS'] = DEFAULT_MAX_NEW_TOKENS
if 'DEFAULT_LOGPROBS' in globals():
    environment['DEFAULT_LOGPROBS'] = DEFAULT_LOGPROBS

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**

```
# Configure model variant and instance type
TESTCASE = {
    "model": "lite2",              # Options: micro, lite, lite2
    "instance": "ml.p5.48xlarge"   # 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 Modell und Endpunktkonfiguration erstellen


In diesem Schritt erstellen Sie zwei wichtige Ressourcen: ein SageMaker Modellobjekt, das auf Ihre Amazon Nova-Modellartefakte verweist, und eine Endpunktkonfiguration, die definiert, wie das Modell bereitgestellt wird.

**SageMaker Modell**: Ein Modellobjekt, das das Inferenzcontainer-Image, den Speicherort der Modellartefakte und die Umgebungskonfiguration verpackt. Dies ist eine wiederverwendbare Ressource, die auf mehreren Endpunkten bereitgestellt werden kann.

**Endpunktkonfiguration**: Definiert die Infrastruktureinstellungen für die Bereitstellung, einschließlich Instanztyp, Anzahl der Instanzen und Modellvarianten. Auf diese Weise können Sie die Bereitstellungseinstellungen getrennt vom Modell selbst verwalten.

**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

**Ü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")
```

## Schritt 5: Stellen Sie den Endpunkt bereit


Der nächste Schritt besteht darin, Ihr Amazon Nova-Modell bereitzustellen, indem Sie einen SageMaker Echtzeit-Endpunkt erstellen. Dieser Endpunkt hostet Ihr Modell und bietet einen sicheren HTTPS-Endpunkt für Inferenzanfragen.

Die Erstellung von Endpunkten dauert in der Regel 15 bis 30 Minuten, AWS da die Infrastruktur bereitgestellt, Ihre Modellartefakte heruntergeladen und der Inferenzcontainer initialisiert wird.

**Endpunkt erstellen**

```
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}")
```

**Überwachung der Endpunkterstellung**

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, ob der Endpunkt bereit ist**

Sobald der Endpunkt fertig ist InService, können Sie seine Konfiguration ü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 6: 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-/Nicht-Streaming-Modi) und asynchrone Endpunkte (Amazon S3-basiert 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:

```
def invoke_nova_endpoint(request_body):
    """
    Invoke Nova endpoint with automatic streaming detection.
    
    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)
    
    try:
        print(f"Invoking endpoint ({'streaming' if is_streaming else 'non-streaming'})...")
        
        if is_streaming:
            response = runtime_client.invoke_endpoint_with_response_stream(
                EndpointName=ENDPOINT_NAME,
                ContentType='application/json',
                Body=body
            )
            
            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
            response = runtime_client.invoke_endpoint(
                EndpointName=ENDPOINT_NAME,
                ContentType='application/json',
                Accept='application/json',
                Body=body
            )
            
            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 eines Chats ohne Streaming**

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,
    "reasoning_effort": "low",  # Options: "low", "high"
    "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,
    "reasoning_effort": "high",  # For more detailed reasoning
    "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":"","reasoning_content":null},"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","reasoning_content":null},"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","reasoning_content":null},"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","reasoning_content":null},"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","reasoning_content":null},"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 7: 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.

**Löschen Sie den Endpunkt**

```
import boto3

# Initialize SageMaker client
sagemaker = boto3.client('sagemaker', region_name=REGION)

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**

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}")
```