AWS SageMaker Serverless Inference: Ein Praxisleitfaden

Wenn Unternehmen ihre Machine-Learning-Operationen skalieren, tritt ein häufiger Schwachpunkt auf: die Verwaltung der Kosten und der Komplexität von Inferenz-Endpunkten. Traditionelle SageMaker-Endpunkte stellen dedizierte EC2-Instanzen bereit, was für hohen, konstanten Datenverkehr fantastisch ist, aber eine teure Angelegenheit für sporadische Workloads oder Modelle mit unvorhersehbaren Nutzungsmustern darstellt. Hier wird AWS SageMaker Serverless Inference zum Game Changer. Es ermöglicht die Bereitstellung von Modellen, ohne die zugrunde liegende Infrastruktur verwalten zu müssen, und skaliert die Compute-Ressourcen automatisch basierend auf dem Datenverkehr.

Dieser Leitfaden führt Sie durch einen Ansatz zur Bereitstellung und Verwaltung serverloser Inferenz-Endpunkte auf SageMaker. Wir werden das was, warum und vor allem das wie behandeln.

Auf dem Weg von einem in einem Notebook entwickelten KI-Modell zu einer robusten, produktionsreifen API führt die Modellbereitstellung oft zu einem erheblichen Betriebsaufwand. Viele Jahre lang war es auf SageMaker Standard, EC2-Instanzen, manchmal sogar GPU-gestützte, bereitzustellen, die 24 Stunden am Tag, 7 Tage die Woche liefen, unabhängig vom Datenverkehr. Organisationen konnten Budgets verbrennen, indem sie ml.g4dn.xlarge-Instanzen stundenlang untätig ließen, nur um auf die nächste Inferenzanfrage zu warten. Das ist nicht nur ineffizient; es widerspricht dem Versprechen der Cloud-Elastizität und den Herausforderungen der Nachhaltigkeit.

Die spezifische technische Herausforderung, die wir hier ansprechen, ist die effiziente, skalierbare und kostengünstige Bereitstellung von Machine-Learning-Modellen für die Inferenz, insbesondere bei unregelmäßigen oder geringen Workloads. AWS SageMaker Serverless Inference bietet eine überzeugende Lösung, indem es die Serververwaltung abstrahiert und uns ermöglicht, nur für die Dauer der Inferenzverarbeitung und die Menge der verarbeiteten Daten zu bezahlen. Es ist das serverlose Paradigma, direkt auf die ML-Inferenz angewendet, das erhebliche Kosteneinsparungen und betriebliche Einfachheit für viele Anwendungsfälle ermöglicht.

Bevor wir uns mit der Implementierung befassen, stellen Sie sicher, dass die folgenden Voraussetzungen erfüllt sind:

• AWS-Konto: Mit Administratorzugriff oder entsprechenden IAM-Berechtigungen für SageMaker, S3 und IAM-Rollen.
• AWS CLI: Version 2, konfiguriert mit Ihren Anmeldeinformationen. Ich empfehle immer, die neueste stabile Version für Funktionsumfang und Fehlerbehebungen zu verwenden. Sie können Ihre Version mit aws --version überprüfen.
• Python 3.8+: Installiert und konfiguriert. Wir werden die boto3- und sagemaker-SDKs verwenden. Das SageMaker SDK ist mit mehreren Python-Versionen kompatibel; 3.8+ ist eine sichere Basis.

python3 --version
pip install boto3 sagemaker --upgrade

• Ein bestehendes SageMaker-Modell: Für diesen Leitfaden gehen wir davon aus, dass Sie ein Modellartefakt (z. B. eine .tar.gz-Datei, die Ihr Modell, den Inferenzcode und Abhängigkeiten enthält) in einem S3-Bucket in einer europäischen Region (z. B. eu-west-1) gespeichert haben. Wenn Sie keines haben, können Sie ein vortrainiertes Modell verwenden oder ein einfaches Modell zum Testen trainieren.

Beispiel-Repository: Grundlegende SageMaker-Beispiele für die Modellpaketierung und -bereitstellung finden Sie im offiziellen AWS Samples GitHub.

Im Kern führt AWS SageMaker Serverless Inference einen neuen Typ von Endpunktkonfiguration ein, der für sporadische, burstfähige Workloads konzipiert ist. Im Gegensatz zu traditionellen Endpunkten, die dedizierte EC2-Instanzen bereitstellen und verwalten, skalieren serverlose Endpunkte die Rechenkapazität automatisch von Null hoch, um Inferenzanfragen zu bearbeiten, und wieder herunter, wenn sie nicht verwendet werden. Dieses „Pay-per-Inference“-Modell reduziert die Kosten für viele gängige ML-Anwendungsfälle erheblich.

Bei der Architektur dieser Systeme sind die wichtigsten Parameter, auf die man sich bei serverloser Inferenz konzentrieren sollte, MemorySizeInMB und MaxConcurrency. Diese beeinflussen direkt die Leistungs- und Kostenmerkmale des Endpunkts:

• MemorySizeInMB: Dies definiert die Menge des Speichers, der Ihrem serverlosen Endpunkt zugewiesen wird. SageMaker bietet Optionen in 1-GB-Schritten (1024 MB, 2048 MB usw., bis zu 6144 MB). Ihre Modellgröße, Inferenzcode-Abhängigkeiten und die Größe der Daten-Payload bestimmen die optimale Speichereinstellung. Ein häufiger Fehler ist die Standardeinstellung auf die kleinste Größe, was zu Out-of-Memory-Fehlern oder erhöhter Latenz führt, da Daten ausgelagert werden müssen.
• MaxConcurrency: Dies ist die maximale Anzahl gleichzeitiger Inferenzanfragen, die Ihr Endpunkt verarbeiten kann. Eine zu niedrige Einstellung kann bei hoher Last zu Drosselung führen, während eine zu hohe Einstellung mehr zugrunde liegende Rechenleistung bereitstellen könnte, als für die Spitzenlastbewältigung erforderlich ist. Es ist ein Kompromiss zwischen Reaktionsfähigkeit und Kosten.
• ProvisionedConcurrency: Obwohl serverlos, können Sie auch eine Basis ProvisionedConcurrency zuweisen, um die Kaltstartlatenz zu reduzieren. Dies hält eine bestimmte Anzahl von Ausführungsumgebungen warm. Für kritische Anwendungen mit geringer Latenz und sprunghaftem Datenverkehr kann dies ein guter Kompromiss sein, obwohl es eine feste Kostenkomponente wieder einführt.

Aus architektonischer Sicht startet SageMaker, wenn eine Anfrage einen serverlosen Endpunkt erreicht, eine Container-Instanz, falls keine warme Instanz verfügbar ist. Es lädt Ihr Modell, verarbeitet die Anfrage und fährt die Instanz nach einer Zeit der Inaktivität wieder herunter. Diese dynamische Skalierung wird vollständig von AWS verwaltet, wodurch die Komplexität von Kubernetes, Autoscaling-Gruppen oder Instanz-Patching abstrahiert wird.

Hier ist ein konzeptioneller Ablauf, wie ein serverloser Inferenz-Endpunkt innerhalb von SageMaker funktioniert:

Für die Modell-Governance und -Sicherheit übernehmen SageMaker-Serverless-Endpunkte die robusten Sicherheitsfunktionen der SageMaker-Plattform. Dazu gehören IAM für die Zugriffssteuerung, VPC-Integration für die Netzwerkisolierung und Verschlüsselung im Ruhezustand und während der Übertragung. Alle Aufrufe werden in CloudWatch protokolliert und bieten eine Überwachungsprotokoll für Compliance und Betriebsüberwachung. Stellen Sie sicher, dass Ihre SageMaker-Ausführungsrolle über die entsprechenden Berechtigungen für den Zugriff auf S3 (wo sich Ihr Modellartefakt befindet) und andere AWS-Dienste verfügt, mit denen Ihr Inferenzcode interagieren könnte.

Codebeispiel (ServerlessInferenceConfig): Dieses Snippet, direkt aus dem SageMaker Python SDK, zeigt, wie die serverlosen Parameter konfiguriert werden.

from sagemaker.serverless import ServerlessInferenceConfig

# Configure serverless endpoint with specific memory and concurrency
serverless_config = ServerlessInferenceConfig(
    memory_size_in_mb=2048,  # Allocate 2GB of memory
    max_concurrency=10      # Allow up to 10 concurrent requests
)

print(f"Serverless configuration created: Memory={serverless_config.memory_size_in_mb}MB, MaxConcurrency={serverless_config.max_concurrency}")

Referenzimplementierung: Ein detaillierteres Architekturmuster, das serverlose Inferenz für Echtzeit-NLP-Aufgaben verwendet, finden Sie im AWS Samples GitHub, insbesondere in den SageMaker-Beispielen für die Modellbereitstellung.

Gehen wir den Prozess der Bereitstellung eines Modells für einen SageMaker Serverless Inference-Endpunkt durch. Für diesen Leitfaden gehe ich davon aus, dass Sie ein Modellartefakt in S3 bereit haben. Ich ziehe es vor, das SageMaker Python SDK zu verwenden, da es viele der zugrunde liegenden Boto3-Aufrufe vereinfacht und eine entwicklerfreundlichere Schnittstelle bietet, insbesondere wenn Sie es in bestehende ML-Pipelines integrieren.

1. Bereiten Sie Ihr Modellartefakt und Ihre IAM-Rolle vor

Zuerst benötigen Sie ein trainiertes Modellartefakt (z. B. model.tar.gz) in einem S3-Bucket und eine IAM-Rolle, die SageMaker annehmen kann, um auf S3 zuzugreifen und Inferenz durchzuführen. Stellen Sie sicher, dass sich Ihr S3-Bucket in einer europäischen Region wie eu-west-1 befindet.

import boto3
import sagemaker
from sagemaker.serverless import ServerlessInferenceConfig
import time
import os

# --- Configuration --- #
aws_region = 'eu-west-1' # Always use European regions for consistency

sagemaker_session = sagemaker.Session(boto3.Session(region_name=aws_region))
bucket = sagemaker_session.default_bucket()
role = sagemaker.get_execution_role()
# Ensure this role has S3 read/write and SageMaker permissions

# Assuming your model artifact is already uploaded to S3
# Example: s3://your-sagemaker-eu-west-1-xxxxxxxxx/model.tar.gz
# For demonstration, we'll use a placeholder model data path
model_data_uri = f"s3://{bucket}/my-nlp-model/model.tar.gz"

# For a real scenario, you would upload your model.tar.gz:
# boto3_session = boto3.Session(region_name=aws_region)
# s3_client = boto3_session.client('s3')
# s3_client.upload_file('local_model.tar.gz', bucket, 'my-nlp-model/model.tar.gz')

print(f"Using Sagemaker Session in region: {aws_region}")
print(f"Default S3 bucket: {bucket}")
print(f"SageMaker Execution Role ARN: {role}")
print(f"Model data URI: {model_data_uri}")

Expected Output:

Using Sagemaker Session in region: eu-west-1
Default S3 bucket: sagemaker-eu-west-1-xxxxxxxxxxxx
SageMaker Execution Role ARN: arn:aws:iam::xxxxxxxxxxxx:role/service-role/AmazonSageMaker-ExecutionRole-xxxxxxxxxxxx
Model data URI: s3://sagemaker-eu-west-1-xxxxxxxxxxxx/my-nlp-model/model.tar.gz

2. Definieren Sie die Serverless-Inferenzkonfiguration

Hier geben wir die serverless-spezifischen Parameter wie Speicher und Parallelität an. Ich beginne typischerweise mit 2 GB Speicher und passe ihn basierend auf der Modellgröße und der beobachteten Leistung an.

# Define the Serverless Inference Configuration
serverless_config = ServerlessInferenceConfig(
    memory_size_in_mb=2048, # 2GB memory allocation
    max_concurrency=5      # Up to 5 concurrent invocations
)

print(f"Serverless configuration defined: Memory={serverless_config.memory_size_in_mb}MB, Max Concurrency={serverless_config.max_concurrency}")

Expected Output:

Serverless configuration defined: Memory=2048MB, Max Concurrency=5

3. Erstellen Sie ein SageMaker-Modellobjekt

Wir müssen ein sagemaker.model.Model-Objekt erstellen. Dieses Objekt kapselt Ihr Modellartefakt und das Inferenz-Container-Image (oft ein vorgefertigter SageMaker Deep Learning Container (DLC) oder ein benutzerdefiniertes Image).

from sagemaker.model import Model

# You would typically use a framework-specific image (e.g., PyTorchModel, TensorFlowModel)
# For a generic example, we use the Model class with a pre-built Scikit-learn image
# Always check for the latest image URI in your desired European region
# Example: https://docs.aws.amazon.com/sagemaker/latest/dg/pre-built-containers-frameworks-reference.html

framework_version = '1.2-1' # Example Scikit-learn version
python_version = 'py3'
processor_type = 'cpu'

# Construct the image URI dynamically for eu-west-1
# This example uses a common pattern for DLCs, but verify against SageMaker documentation
# sagemaker.image_uris.retrieve is the recommended way to get image URIs
container_image_uri = sagemaker.image_uris.retrieve(
    framework='sklearn',
    region=aws_region,
    version=framework_version,
    py_version=python_version,
    instance_type='ml.m5.xlarge' # Instance type here is just for image retrieval, not for actual deployment instance
)

model = Model(
    image_uri=container_image_uri,
    model_data=model_data_uri,
    role=role,
    sagemaker_session=sagemaker_session
)

print(f"SageMaker Model object created using image URI: {container_image_uri}")

Expected Output:

SageMaker Model object created using image URI: xxxxx.dkr.ecr.eu-west-1.amazonaws.com/sagemaker-sklearn:1.2-1-cpu-py3

4. Stellen Sie das Modell auf einem Serverless-Endpunkt bereit

Nun stellen wir das Modell bereit, indem wir unsere serverless_config an die deploy-Methode übergeben. Der endpoint_name ist entscheidend für den Aufruf. Verwenden Sie einen aussagekräftigen, versionierten Namen.

# Generate a unique endpoint name
endpoint_name = f"my-serverless-nlp-endpoint-{int(time.time())}"

try:
    # Deploy the model with the serverless configuration
    # The 'instance_type' and 'initial_instance_count' are NOT needed for serverless inference
    # if 'serverless_inference_config' is provided.
    predictor = model.deploy(
        endpoint_name=endpoint_name,
        serverless_inference_config=serverless_config,
        wait=True # Wait for the deployment to complete
    )
    print(f"Successfully deployed serverless endpoint: {endpoint_name}")
    print(f"Endpoint ARN: {predictor.endpoint_name}") # predictor.endpoint_name holds the actual name
except Exception as e:
    print(f"Error deploying endpoint: {e}")
    # Implement retry logic or detailed error logging in production

Expected Output:

... (SageMaker deployment logs) ...
Successfully deployed serverless endpoint: my-serverless-nlp-endpoint-xxxxxxxxxx
Endpoint ARN: my-serverless-nlp-endpoint-xxxxxxxxxx

5. Rufen Sie den Serverless-Endpunkt auf

Sobald der Endpunkt InService ist, können Sie ihn über das predictor-Objekt oder direkt über den sagemaker-runtime-Client in Boto3 aufrufen. Denken Sie daran, Ihre Eingabedaten im richtigen ContentType zu senden.

from sagemaker.predictor import Predictor
from sagemaker.serializers import JSONSerializer
from sagemaker.deserializers import JSONDeserializer

# If you don't have the predictor object from deployment, you can instantiate it:
# predictor = Predictor(endpoint_name=endpoint_name, sagemaker_session=sagemaker_session)

# Configure serializer/deserializer for JSON input/output
predictor.serializer = JSONSerializer()
predictor.deserializer = JSONDeserializer()

# Example input for an NLP model (e.g., sentiment analysis)
input_payload = {"instances": ["This is a fantastic article!", "I am not happy with this service."]}

try:
    print(f"Invoking endpoint: {endpoint_name} with payload: {input_payload}")
    response = predictor.predict(input_payload)
    print(f"Inference result: {response}")
except Exception as e:
    print(f"Error invoking endpoint: {e}")
    # Common errors include incorrect input format, IAM permissions, or model loading issues

Expected Output:

Invoking endpoint: my-serverless-nlp-endpoint-xxxxxxxxxx with payload: {'instances': ['This is a fantastic article!', 'I am not happy with this service.']}
Inference result: {'predictions': [0.98, 0.12]}

6. Ressourcen bereinigen

Denken Sie immer daran, Ihren Endpunkt und Ihr Modell zu löschen, um unnötige Kosten zu vermeiden. Dies ist ein entscheidender Schritt: Managed Services sind großartig, aber das Vergessen der Bereinigung von Ressourcen ist eine häufige Ursache für unerwartete Cloud-Rechnungen.

# Delete the endpoint
try:
    predictor.delete_endpoint()
    print(f"Endpoint {endpoint_name} deleted successfully.")
except Exception as e:
    print(f"Error deleting endpoint {endpoint_name}: {e}")

# Delete the model as well if it's no longer needed
# model.delete_model()
# print(f"Model associated with {endpoint_name} deleted successfully.")

Expected Output:

Endpoint my-serverless-nlp-endpoint-xxxxxxxxxx deleted successfully.

Die vollständige Implementierung für diese Schritte finden Sie unter [link to your internal repo].

Es ist entscheidend, dass Ihr serverloser Endpunkt wie erwartet funktioniert. So überprüfe und behebe ich typischerweise Probleme.

Verifikationsbefehle:

Um den Status Ihres Endpunkts und seiner Konfiguration zu überprüfen:

# Check endpoint status
aws sagemaker describe-endpoint \
  --endpoint-name "my-serverless-nlp-endpoint-xxxxxxxxxx" \
  --region eu-west-1

# Expected output for InService status:
# {
#     "EndpointName": "my-serverless-nlp-endpoint-xxxxxxxxxx",
#     "EndpointArn": "arn:aws:sagemaker:eu-west-1:xxxxxxxxxxxx:endpoint/my-serverless-nlp-endpoint-xxxxxxxxxx",
#     "EndpointConfigName": "my-serverless-nlp-endpoint-xxxxxxxxxx-Config",
#     "EndpointStatus": "InService",
#     ...
# }

# Check endpoint configuration details (including serverless config)
aws sagemaker describe-endpoint-config \
  --endpoint-config-name "my-serverless-nlp-endpoint-xxxxxxxxxx-Config" \
  --region eu-west-1

# Expected output showing ServerlessConfig:
# {
#     "EndpointConfigName": "my-serverless-nlp-endpoint-xxxxxxxxxx-Config",
#     "EndpointConfigArn": "arn:aws:sagemaker:eu-west-1:xxxxxxxxxxxx:endpoint-config/my-serverless-nlp-endpoint-xxxxxxxxxx-Config",
#     "ProductionVariants": [
#         {
#             "VariantName": "AllTraffic",
#             "ModelName": "sagemaker-sklearn-2026-03-14-xxxxxx",
#             "ServerlessConfig": {
#                 "MemorySizeInMB": 2048,
#                 "MaxConcurrency": 5
#             },
#             "InitialVariantWeight": 1.0
#         }
#     ],
#     ...
# }

Häufige Fehler & Lösungen:

1. Fehler: ValidationException: Could not find model data in S3 location

An error occurred (ValidationException) when calling the CreateModel operation: Could not find model data in S3 location: s3://your-bucket/non-existent-model.tar.gz

**Lösung:** Dies bedeutet typischerweise, dass der S3-Pfad (`model_data_uri`), der beim Erstellen des `sagemaker.model.Model`-Objekts angegeben wurde, falsch ist, oder dass die SageMaker-Ausführungsrolle keine Leseberechtigungen für diesen S3-Bucket hat. Überprüfen Sie Ihren S3-URI doppelt und stellen Sie sicher, dass die IAM-Rolle `s3:GetObject` für das Modellartefakt und `s3:ListBucket` für den Bucket besitzt.

1. Fehler: ClientError: An error occurred (ModelError) when calling the InvokeEndpoint operation: Received client error (4xx) from model with message "Failure loading model"

sagemaker.exceptions.UnexpectedStatusException: Error hosting model: Failed. Reason: ClientError: An error occurred (ModelError) when calling the InvokeEndpoint operation: Received client error (4xx) from model with message "Failure loading model"

**Lösung:** Dies ist ein häufiges Problem beim Aufruf, das darauf hinweist, dass Ihr Inferenz-Container das Modell nicht laden oder die Eingabe nicht verarbeiten konnte. Das Problem liegt in Ihrer `model.tar.gz` und dem darin enthaltenen `inference.py`-Skript. Überprüfen Sie:
*   **Abhängigkeiten:** Sind alle erforderlichen Bibliotheken in der `requirements.txt` innerhalb Ihrer `model.tar.gz` aufgeführt?
*   **`model_fn`:** Implementiert Ihr `inference.py` `model_fn` korrekt, um das Modellartefakt aus `/opt/ml/model` zu laden?
*   **`predict_fn`:** Verarbeitet `predict_fn` das Eingabeformat (z. B. JSON) korrekt und gibt die Ausgabe wie erwartet zurück?
*   **Protokolle:** Der wichtigste Schritt ist die Überprüfung der CloudWatch-Protokolle für Ihren SageMaker-Endpunkt. Suchen Sie nach Protokollgruppen mit dem Namen `/aws/sagemaker/Endpoints/your-endpoint-name`, um detaillierte Fehlermeldungen von Ihrem Inferenz-Container zu finden.

1. Fehler: ValidationException: You must provide either an InstanceType and InitialInstanceCount or a ServerlessConfig.

# During model.deploy()
ValidationException: You must provide either an InstanceType and InitialInstanceCount or a ServerlessConfig.

**Lösung:** Dieser Fehler weist Sie explizit darauf hin, dass Sie versuchen, Konfigurationstypen zu mischen. Stellen Sie sicher, dass Sie beim Aufruf von `model.deploy()` entweder `serverless_inference_config=serverless_config` (für serverlos) ODER `instance_type='ml.m5.xlarge', initial_instance_count=1` (für instanzbasiert) übergeben, aber nicht beides oder keines. Für serverlose Bereitstellungen lassen Sie die instanzbasierten Parameter vollständig weg.

Testskript: Für robuste Tests können Sie ein kleines Python-Skript entwickeln, das ein Testmodell bereitstellt, es mit verschiedenen Payloads aufruft und dann bereinigt. Dies ermöglicht eine automatisierte Validierung in CI/CD-Pipelines. Eine Basisversion könnte wie das kombinierte Skript im Implementierungsabschnitt aussehen, erweitert um Zusicherungen für die erwartete Ausgabe.

AWS SageMaker Serverless Inference ist ein leistungsstarkes Tool im Cloud-Architektur-Toolkit, insbesondere für diejenigen, die Kosten optimieren und Operationen für die KI-Inferenz rationalisieren möchten. Es ist keine Patentlösung für jedes Szenario – Anforderungen mit hohem Durchsatz und extrem niedriger Latenz könnten immer noch von bereitgestellten Instanzen mit sorgfältiger Autoskalierung profitieren. Für die überwiegende Mehrheit unvorhersehbarer oder geringvolumiger Inferenz-Workloads bietet Serverless jedoch eine unschlagbare Kombination aus Kosteneffizienz, Skalierbarkeit und reduziertem Betriebsaufwand. Organisationen können ihre monatlichen Inferenzkosten um bis zu 80 % senken, indem sie geeignete Modelle auf serverlose Endpunkte migrieren.

Wichtige Erkenntnisse:

• Kostenoptimierung: Serverlose Inferenz eliminiert Leerlaufkosten; es wird nur für die tatsächliche Nutzung bezahlt.
• Operationale Einfachheit: Keine Instanzverwaltung, Patching oder Skalierungsrichtlinien zu konfigurieren.
• Skalierbarkeit: Skaliert automatisch von Null, um die Nachfrage zu decken.
• Konfiguration: Schlüsselparameter sind MemorySizeInMB und MaxConcurrency über ServerlessInferenceConfig.
• Kaltstarts: Achten Sie auf mögliche Kaltstartlatenz beim ersten Aufruf nach Inaktivität; ProvisionedConcurrency kann dies mindern.

Der Schlüssel ist, die Verkehrsmuster Ihres Modells genau zu bewerten. Wenn sie sprunghaft, intermittierend oder geringvolumig sind, ist SageMaker Serverless Inference wahrscheinlich Ihre beste Wahl für eine kostengünstige Bereitstellung. Beginnen Sie mit konservativen Werten für MemorySizeInMB und MaxConcurrency, überwachen und passen Sie diese dann basierend auf der tatsächlichen Last und den Leistungsmetriken von CloudWatch an.

Repository-Ressourcen: * Offizielle Beispiele: Erkunden Sie eine breite Palette offizieller SageMaker-Beispiele auf dem AWS Samples GitHub. * Verwandte Projekte: Für tiefere Einblicke in MLOps-Muster ziehen Sie Projekte wie SageMaker MLOps Templates in Betracht.

Zusätzliche Codebeispiele: Für komplexere Szenarien mit benutzerdefinierten Containern oder Multi-Modell-Endpunkten mit Serverless verweise ich oft auf die von AWS in ihrem Amazon SageMaker Developer Guide bereitgestellten fortgeschrittenen Beispiele.