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. # Benutzerdefinierter Inferenzcode mit Hosting-Services In diesem Abschnitt wird erklärt, wie Amazon SageMaker AI mit einem Docker-Container interagiert, der Ihren eigenen Inferenzcode für Hosting-Dienste ausführt. Verwenden Sie diese Informationen zum Schreiben von Inferenzcode und zum Erstellen eines Docker-Images. **Topics** + [Wie SageMaker KI Ihr Inferenz-Image ausführt](#your-algorithms-inference-code-run-image) + [Wie SageMaker KI Ihre Modellartefakte lädt](#your-algorithms-inference-code-load-artifacts) + [So sollte Ihr Container auf Inferenzanforderungen reagieren](#your-algorithms-inference-code-container-response) + [So sollte Ihr Container auf Zustandsprüfungsanforderungen (Ping-Anforderungen) reagieren](#your-algorithms-inference-algo-ping-requests) + [Container-Vertrag zur Support bidirektionaler Streaming-Funktionen](#your-algorithms-inference-algo-bidi) + [Verwenden Sie eine private Docker-Registry für Echtzeit-Inferenzcontainer](your-algorithms-containers-inference-private.md) ## Wie SageMaker KI Ihr Inferenz-Image ausführt Um einen Container so zu konfigurieren, dass er als ausführbare Datei ausgeführt wird, verwenden Sie eine `ENTRYPOINT`-Anweisung in einer Dockerfile. Beachten Sie Folgendes: + Für die Modellinferenz führt SageMaker KI den Container wie folgt aus: ``` docker run {{image}} serve ``` SageMaker AI überschreibt `CMD` Standardanweisungen in einem Container, indem das `serve` Argument hinter dem Bildnamen angegeben wird. Das `serve`-Argument überschreibt Argumente, die Sie mit dem `CMD`-Befehl in der Dockerfile bereitstellen.   + SageMaker AI erwartet, dass alle Container mit Root-Benutzern ausgeführt werden. Erstellen Sie Ihren Container so, dass er nur Root-Benutzer verwendet. Wenn SageMaker KI Ihren Container ausführt, können Benutzer, die keinen Zugriff auf Root-Ebene haben, zu Berechtigungsproblemen führen.   + Es wird empfohlen, das `exec`-Formular der `ENTRYPOINT`-Anleitung zu verwenden: ``` ENTRYPOINT ["executable", "param1", "param2"] ``` Beispiel: ``` ENTRYPOINT ["python", "k_means_inference.py"] ``` Das `exec`-Formular der `ENTRYPOINT`-Anweisung startet die ausführbare Datei direkt, nicht als untergeordnetes Element von `/bin/sh`. Dadurch kann es Signale wie `SIGTERM` und `SIGKILL` von den SageMaker API-Operationen empfangen, was eine Voraussetzung ist.   Wenn Sie beispielsweise die [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html)API verwenden, um einen Endpunkt zu erstellen, stellt SageMaker KI die Anzahl der ML-Compute-Instanzen bereit, die für die Endpunktkonfiguration erforderlich sind, die Sie in der Anfrage angeben. SageMaker AI führt den Docker-Container auf diesen Instanzen aus.   Wenn Sie die Anzahl der Instanzen reduzieren, die den Endpunkt unterstützen (indem Sie die [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpointWeightsAndCapacities.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpointWeightsAndCapacities.html)API aufrufen), führt SageMaker AI einen Befehl aus, um den Docker-Container auf den Instanzen zu stoppen, die beendet werden. Der Befehl sendet das `SIGTERM`-Signal und dann dreißig Sekunden später das `SIGKILL`-Signal.   Wenn Sie den Endpunkt aktualisieren (indem Sie die [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html)API aufrufen), startet SageMaker KI einen weiteren Satz von ML-Compute-Instances und führt die Docker-Container, die Ihren Inferenzcode enthalten, auf ihnen aus. Anschließend wird ein Befehl zum Beenden der vorherigen Docker-Container ausgeführt. Um einen Docker-Container anzuhalten, sendet der Befehl das Signal `SIGTERM` und 30 Sekunden später das Signal `SIGKILL`.   + SageMaker AI verwendet die Container-Definition, die Sie in Ihrer [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html)Anfrage angegeben haben, um Umgebungsvariablen und den DNS-Hostnamen für den Container wie folgt festzulegen:   + Es legt Umgebungsvariablen mithilfe der `ContainerDefinition.Environment` string-to-string Map fest. + Es legt den DNS-Hostnamen mithilfe von `ContainerDefinition.ContainerHostname` fest.   + Wenn Sie planen, GPU-Geräte für Modellinferenzen zu verwenden (indem Sie GPU-basierte ML-Rechen-Instances in Ihrer `CreateEndpointConfig`-Anforderung angeben), stellen Sie sicher, dass Ihre Container `nvidia-docker`-kompatibel sind. Bündeln Sie NVIDIA-Treiber nicht mit dem Abbild. Mehr Informationen über `nvidia-docker` finden Sie unter [NVIDIA/nvidia-docker](https://github.com/NVIDIA/nvidia-docker).   + Sie können den `tini` Initialisierer nicht als Einstiegspunkt in SageMaker KI-Container verwenden, da er durch die Argumente `train` und `serve` verwirrt wird. ## Wie SageMaker KI Ihre Modellartefakte lädt In Ihrer [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html)API-Anfrage können Sie entweder den `S3DataSource` Parameter `ModelDataUrl` oder verwenden, um den S3-Speicherort zu identifizieren, an dem Modellartefakte gespeichert sind. SageMaker AI kopiert Ihre Modellartefakte vom S3-Speicherort in das `/opt/ml/model` Verzeichnis, sodass sie von Ihrem Inferenzcode verwendet werden können. Ihr Container hat schreibgeschützten Zugriff auf `/opt/ml/model`. Schreiben Sie nicht in dieses Verzeichnis. Die `ModelDataUrl` muss auf eine TAR.GZ-Datei zeigen. Andernfalls wird SageMaker AI die Datei nicht herunterladen. Wenn Sie Ihr Modell in SageMaker KI trainiert haben, werden die Modellartefakte als eine einzige komprimierte TAR-Datei in Amazon S3 gespeichert. Wenn Sie Ihr Modell außerhalb von SageMaker KI trainiert haben, müssen Sie diese einzelne komprimierte TAR-Datei erstellen und an einem S3-Speicherort speichern. SageMaker AI dekomprimiert diese Tar-Datei in das opt/ml/model Verzeichnis/, bevor Ihr Container gestartet wird. Wir empfehlen, für die Bereitstellung großer Modelle [Bereitstellung unkomprimierter Modelle](large-model-inference-uncompressed.md) zu befolgen. ## So sollte Ihr Container auf Inferenzanforderungen reagieren Um Rückschlüsse zu ziehen, sendet die Client-Anwendung eine POST-Anfrage an den SageMaker AI-Endpunkt. SageMaker AI leitet die Anfrage an den Container weiter und gibt das Inferenzergebnis vom Container an den Client zurück. Weitere Informationen zu den Inferenzanfragen, die Ihr Container erhält, finden Sie in den folgenden Aktionen in der *Amazon SageMaker AI API-Referenz:* + [ InvokeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html) + [ InvokeEndpointAsync](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpointAsync.html) + [ InvokeEndpointWithResponseStream](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpointWithResponseStream.html) + [ InvokeEndpointWithResponseStream](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpointWithBidirectionalStream.html) **Anforderungen für Inferenzcontainer** Um auf Inferenzanfragen zu antworten, muss Ihr Container die folgenden Anforderungen erfüllen: + SageMaker AI entfernt alle `POST` Header außer denen, die von unterstützt werden. `InvokeEndpoint` SageMaker KI fügt möglicherweise zusätzliche Header hinzu. Inferenzcontainer müssen diese zusätzlichen Header einfach ignorieren können. + Um Inferenzanfragen zu erhalten, muss der Container über einen Webserver verfügen, der auf Port 8080 lauscht, und er muss `POST`-Anfragen an die Endpunkte `/invocations` und `/ping` akzeptieren. + Ein Containermodell des Kunden muss Socket-Verbindungsanfragen innerhalb von 250 ms akzeptieren. + Die Modellcontainer eines Kunden müssen innerhalb von 60 Sekunden auf Anforderungen reagieren. Das Modell selbst kann eine maximale Bearbeitungszeit von 60 Sekunden haben, bevor es auf die `/invocations` antwortet. Wenn Ihr Modell 50 bis 60 Sekunden Verarbeitungszeit benötigt, legen Sie das SDK-Socket-Timeout auf 70 Sekunden fest. + Der Modellcontainer eines Kunden, der bidirektionales Streaming unterstützt, muss: + unterstützt WebSockets standardmäßig Verbindungen auf Port 8080 bis/invocations-bidirectional-stream . + einen Webserver haben, der auf Port 8080 wartet und POST-Anfragen an die /ping-Endpunkte akzeptieren muss. + Zusätzlich zu den Integritätsprüfungen des Containers über HTTP muss der Container mit Pong Frame per ([RFC6455](https://datatracker.ietf.org/doc/html/rfc6455#section-5.5.3)) antworten, damit der Ping-Frame gesendet wird. WebSocket **Example Aufruf-Funktionen** Die folgenden Beispiele zeigen, wie der Code in Ihrem Container Inferenzanfragen verarbeiten kann. In diesen Beispielen werden Anfragen behandelt, die Client-Anwendungen mithilfe der InvokeEndpoint Aktion senden. FastAPI ist ein Web-Framework zum Bauen APIs mit Python. ``` from fastapi import FastAPI, status, Request, Response . . . app = FastAPI() . . . @app.post('/invocations') async def invocations(request: Request): # model() is a hypothetical function that gets the inference output: model_resp = await model(Request) response = Response( content=model_resp, status_code=status.HTTP_200_OK, media_type="text/plain", ) return response . . . ``` In diesem Beispiel verarbeitet die `invocations` Funktion die Inferenzanforderung, die SageMaker KI an den `/invocations` Endpunkt sendet. Flask ist ein Framework für die Entwicklung von Webanwendungen mit Python. ``` import flask . . . app = flask.Flask(__name__) . . . @app.route('/invocations', methods=["POST"]) def invoke(request): # model() is a hypothetical function that gets the inference output: resp_body = model(request) return flask.Response(resp_body, mimetype='text/plain') ``` In diesem Beispiel verarbeitet die `invoke` Funktion die Inferenzanforderung, die SageMaker KI an den `/invocations` Endpunkt sendet. **Example Aufruffunktionen für Streaming-Anfragen** Die folgenden Beispiele zeigen, wie der Code in Ihrem Inferenzcontainer Streaming-Inferenzanfragen verarbeiten kann. Diese Beispiele behandeln Anfragen, die Client-Anwendungen mithilfe der InvokeEndpointWithResponseStream Aktion senden. Wenn ein Container eine Streaming-Inferenzanforderung verarbeitet, gibt er die Inferenz des Modells inkrementell als eine Reihe von Teilen zurück, während das Modell sie generiert. Client-Anwendungen erhalten sofort Antworten, wenn sie verfügbar sind. Sie müssen nicht warten, bis das Modell die gesamte Antwort generiert hat. Sie können Streaming implementieren, um schnelle interaktive Erlebnisse wie Chatbots, virtuelle Assistenten und Musikgeneratoren zu unterstützen. FastAPI ist ein Web-Framework zum Bauen APIs mit Python. ``` from starlette.responses import StreamingResponse from fastapi import FastAPI, status, Request . . . app = FastAPI() . . . @app.post('/invocations') async def invocations(request: Request): # Streams inference response using HTTP chunked encoding async def generate(): # model() is a hypothetical function that gets the inference output: yield await model(Request) yield "\n" response = StreamingResponse( content=generate(), status_code=status.HTTP_200_OK, media_type="text/plain", ) return response . . . ``` In diesem Beispiel verarbeitet die `invocations` Funktion die Inferenzanforderung, die SageMaker KI an den `/invocations` Endpunkt sendet. Um die Antwort zu streamen, verwendet das Beispiel die Klasse `StreamingResponse` aus dem Starlette-Framework. Flask ist ein Framework für die Entwicklung von Webanwendungen mit Python. ``` import flask . . . app = flask.Flask(__name__) . . . @app.route('/invocations', methods=["POST"]) def invocations(request): # Streams inference response using HTTP chunked encoding def generate(): # model() is a hypothetical function that gets the inference output: yield model(request) yield "\n" return flask.Response( flask.stream_with_context(generate()), mimetype='text/plain') . . . ``` In diesem Beispiel verarbeitet die `invocations` Funktion die Inferenzanforderung, die SageMaker KI an den `/invocations` Endpunkt sendet. Um die Antwort zu streamen, verwendet das Beispiel die Funktion `flask.stream_with_context` aus dem Flask-Framework. **Example Beispiel für Aufruffunktionen für bidirektionales Streaming** Die folgenden Beispiele zeigen, wie der Code in Ihrem Container Streaming-Inferenzanfragen und -antworten verarbeiten kann. In diesen Beispielen werden Streaming-Anfragen behandelt, die Client-Anwendungen mithilfe der InvokeEndpointWithBidirectionalStream Aktion senden. Ein Container mit bidirektionaler Streaming-Funktion verarbeitet Streaming-Inferenzanforderungen, bei denen Teile inkrementell auf dem Client generiert und in den Container gestreamt werden. Er gibt die Inferenz des Modells in Form einer Reihe von Teilen an den Client zurück, sobald das Modell sie generiert. Client-Anwendungen erhalten sofort Antworten, wenn sie verfügbar sind. Sie müssen nicht auf die Anfrage warten, die vollständig auf dem Client generiert wurde, oder darauf, dass das Modell die gesamte Antwort generiert. Sie können bidirektionales Streaming implementieren, um schnelle interaktive Erlebnisse wie Chatbots, interaktive KI-Sprachassistenten und Übersetzungen in Echtzeit zu unterstützen und so ein Erlebnis in Echtzeit zu ermöglichen. FastAPI ist ein Web-Framework zum Bauen APIs mit Python. ``` import sys import asyncio import json from fastapi import FastAPI, WebSocket, WebSocketDisconnect from fastapi.responses import JSONResponse import uvicorn app = FastAPI() ... @app.websocket("/invocations-bidirectional-stream") async def websocket_invoke(websocket: WebSocket): """ WebSocket endpoint with RFC 6455 ping/pong and fragmentation support Handles: - Text messages (JSON) - including fragmented frames - Binary messages - including fragmented frames - Ping frames (automatically responds with pong) - Pong frames (logs receipt) - Fragmented frames per RFC 6455 Section 5.4 """ await manager.connect(websocket) # Fragment reassembly buffers per RFC 6455 Section 5.4 text_fragments = [] binary_fragments = [] while True: # Use receive() to handle all WebSocket frame types message = await websocket.receive() print(f"Received message: {message}") if message["type"] == "websocket.receive": if "text" in message: # Handle text frames (including fragments) text_data = message["text"] more_body = message.get("more_body", False) if more_body: # This is a fragment, accumulate it text_fragments.append(text_data) print(f"Received text fragment: {len(text_data)} chars (more coming)") else: # This is the final frame or a complete message if text_fragments: # Reassemble fragmented message text_fragments.append(text_data) complete_text = "".join(text_fragments) text_fragments.clear() print(f"Reassembled fragmented text message: {len(complete_text)} chars total") await handle_text_message(websocket, complete_text) else: # Complete message in single frame await handle_text_message(websocket, text_data) elif "bytes" in message: # Handle binary frames (including fragments) binary_data = message["bytes"] more_body = message.get("more_body", False) if more_body: # This is a fragment, accumulate it binary_fragments.append(binary_data) print(f"Received binary fragment: {len(binary_data)} bytes (more coming)") else: # This is the final frame or a complete message if binary_fragments: # Reassemble fragmented message binary_fragments.append(binary_data) complete_binary = b"".join(binary_fragments) binary_fragments.clear() print(f"Reassembled fragmented binary message: {len(complete_binary)} bytes total") await handle_binary_message(websocket, complete_binary) else: # Complete message in single frame await handle_binary_message(websocket, binary_data) elif message["type"] == "websocket.ping": # Handle ping frames - RFC 6455 Section 5.5.2 ping_data = message.get("bytes", b"") print(f"Received PING frame with payload: {ping_data}") # FastAPI automatically sends pong response elif message["type"] == "websocket.pong": # Handle pong frames pong_data = message.get("bytes", b"") print(f"Received PONG frame with payload: {pong_data}") elif message["type"] == "websocket.close": # Handle close frames - RFC 6455 Section 5.5.1 close_code = message.get("code", 1000) close_reason = message.get("reason", "") print(f"Received CLOSE frame - Code: {close_code}, Reason: '{close_reason}'") # Send close frame response if not already closing try: await websocket.close(code=close_code, reason=close_reason) print(f"Sent CLOSE frame response - Code: {close_code}") except Exception as e: print(f"Error sending close frame: {e}") break elif message["type"] == "websocket.disconnect": print("Client initiated disconnect") break else: print(f"Received unknown message type: {message['type']}") break async def handle_binary_message(websocket: WebSocket, binary_data: bytes): """Handle incoming binary messages (complete or reassembled from fragments)""" print(f"Processing complete binary message: {len(binary_data)} bytes") try: # Echo back the binary data await websocket.send_bytes(binary_data) except Exception as e: print(f"Error handling binary message: {e}") async def handle_text_message(websocket: WebSocket, data: str): """Handle incoming text messages""" try: # Send response back to the same client await manager.send_personal_message(data, websocket) except Exception as e: print(f"Error handling text message: {e}") def main(): if len(sys.argv) > 1 and sys.argv[1] == "serve": print("Starting server on port 8080...") uvicorn.run(app, host="0.0.0.0", port=8080) else: print("Usage: python app.py serve") sys.exit(1) if __name__ == "__main__": main() ``` In diesem Beispiel verarbeitet die `websocket_invoke` Funktion die Inferenzanforderung, die SageMaker KI an den `/invocations-bidirectional-stream` Endpunkt sendet. Es zeigt die Bearbeitung von Stream-Anfragen und Stream-Antworten zurück an den Client. ## So sollte Ihr Container auf Zustandsprüfungsanforderungen (Ping-Anforderungen) reagieren SageMaker KI startet in den folgenden Situationen neue Inferenzcontainer: + Reagieren auf die API-Aufrufe `CreateEndpoint`, `UpdateEndpoint` und `UpdateEndpointWeightsAndCapacities` + Ausführen von Sicherheits-Patching + Ersetzen fehlerhafter Instances Kurz nach dem Start des Containers beginnt SageMaker KI, regelmäßige GET-Anfragen an den `/ping` Endpunkt zu senden. Die einfachste Anforderung für den Container besteht darin, mit einem HTTP 200-Statuscode ohne Text zu antworten. Dies zeigt SageMaker AI an, dass der Container bereit ist, Inferenzanfragen am `/invocations` Endpunkt anzunehmen. Wenn der Container in den ersten 8 Minuten nach dem Start nicht beginnt, die Zustandsprüfungen zu bestehen, in dem er durchweg mit 200s antwortet, schlägt der Start der neuen Instance fehl. Dies führt zu einem Fehlschlag von `CreateEndpoint` und der Endpunkt befindet sich in einem ausgefallenen Zustand. Die von `UpdateEndpoint` angeforderte Aktualisierung wird nicht abgeschlossen, die Sicherheitspatches werden nicht angewendet und fehlerhafte Instances werden nicht ersetzt. Die Mindestgrenze besteht darin, dass der Container statische 200 zurückgibt, ein Containerentwickler kann diese Funktionalität jedoch nutzen, um umfassendere Prüfungen durchzuführen. Das Anforderungstimeout bei `/ping`-Versuchen beträgt 2 Sekunden. Darüber hinaus muss ein Container, der bidirektionale Streaming-Anfragen verarbeiten kann, mit einem Pong-Frame (pro WebSocket Protokoll [RFC6455](https://datatracker.ietf.org/doc/html/rfc6455#section-5.5.3)) auf einen Ping-Frame antworten. Wenn für 5 aufeinanderfolgende Pings kein Pong Frame empfangen wird, wird die Verbindung zum Container von der AI-Plattform geschlossen. SageMaker SageMaker Die KI-Plattform reagiert auch auf Ping-Frames aus dem Modellcontainer mit Pong Frames. ## Container-Vertrag zur Support bidirektionaler Streaming-Funktionen Wenn Sie Ihren Modellcontainer als SageMaker KI-Endpunkt hosten möchten, der bidirektionale Streaming-Funktionen unterstützt, muss der Modellcontainer den folgenden Vertrag unterstützen: **1. Bidirektionales Docker-Label** Der Modellcontainer sollte ein Docker-Label haben, das der SageMaker KI-Plattform mitteilt, dass die bidirektionale Streaming-Funktion auf diesem Container unterstützt wird. ``` com.amazonaws.sagemaker.capabilities.bidirectional-streaming=true ``` **2. WebSocket Support-Verbindung für Aufrufe** Der Modellcontainer eines Kunden, der bidirektionales Streaming unterstützt, muss standardmäßig WebSockets Verbindungen über Port 8080 bis unterstützen. `/invocations-bidirectional-stream` Dieser Pfad kann überschrieben werden, indem beim X-Amzn-SageMaker-Model Aufrufen der API der Header -Invocation-Path übergeben wird. InvokeEndpointWithBidirectionalStream Darüber hinaus können Benutzer eine Abfragezeichenfolge angeben, die an diesen Pfad angehängt werden soll, indem sie beim Aufrufen der API den Header -Query-String übergeben. X-Amzn-SageMaker-Model InvokeEndpointWithBidirectionalStream **3. Stream-Behandlung anfragen** Die InvokeEndpointWithBidirectionalStream API-Eingabe-Payloads werden als eine Reihe von Dateien gestreamt PayloadParts, was nur ein Wrapper eines binären Chunks („Bytes“:) ist: ****** ``` { "PayloadPart": { "Bytes": , "DataType": , "CompletionState": "P": } } ``` **3.1. Datenrahmen** SageMaker AI übergibt die Eingabe als WebSocket Datenrahmen PayloadParts an den Modellcontainer ([RFC6455-Abschnitt-5.6](https://datatracker.ietf.org/doc/html/rfc6455#section-5.6)) 1. SageMaker KI untersucht den binären Chunk nicht. 1. Beim Empfang einer Eingabe PayloadPart + SageMaker KI erstellt genau einen WebSocket Datenrahmen aus `PayloadPart.Bytes` und übergibt ihn dann an den Modellcontainer. + Wenn`PayloadPart.DataType = UTF8`, SageMaker KI einen Textdatenrahmen erstellt + Wenn `PayloadPart.DataType` kein oder vorhanden ist`PayloadPart.DataType = BINARY`, erstellt SageMaker AI einen binären Datenrahmen 1. Bei einer Sequenz aus „ PayloadParts mit`PayloadPart.CompletionState = PARTIAL`“ und einer abschließend durch ein „ PayloadPart mit`PayloadPart.CompletionState = COMPLETE`“ übersetzt SageMaker KI sie in eine WebSocket fragmentierte Nachricht. [RFC6455— Abschnitt-5.4](https://datatracker.ietf.org/doc/html/rfc6455#section-5.4): Fragmentierung: + Das erste PayloadPart mit `PayloadPart.CompletionState = PARTIAL` wird in einen WebSocket Datenrahmen übersetzt, wobei das FIN-Bit leer ist. + Das darauffolgende PayloadParts mit `PayloadPart.CompletionState = PARTIAL` wird in WebSocket Continuation-Frames übersetzt, wobei das FIN-Bit leer ist. + Das letzte PayloadPart mit `PayloadPart.CompletionState = COMPLETE` wird in ein WebSocket Continuation Frame übersetzt, bei dem das FIN-Bit gesetzt ist. 1. SageMaker AI kodiert oder dekodiert den binären Chunk aus der Eingabe nicht PayloadPart, die Bytes werden unverändert an den Modellcontainer übergeben. 1. SageMaker KI kombiniert nicht mehrere Eingaben zu einer. PayloadParts BinaryDataFrame 1. SageMaker KI teilt eine Eingabe nicht PayloadPart in mehrere BinaryDataFrames auf. **Beispiel: Fragmentierter Nachrichtenfluss** ``` Client sends: PayloadPart 1: {Bytes: "Hello ", DataType: "UTF8", CompletionState: "PARTIAL"} PayloadPart 2: {Bytes: "World", DataType: "UTF8", CompletionState: "COMPLETE"} Container receives: Frame 1: Text Data Frame with "Hello " (FIN=0) Frame 2: Continuation Frame with "World" (FIN=1) ``` **3.2. Kontrollrahmen** Neben Datenrahmen sendet SageMaker KI auch Kontrollrahmen an den Modellcontainer ([RFC6455-Sektion-5.5](https://datatracker.ietf.org/doc/html/rfc6455#section-5.5)): 1. Frame schließen: SageMaker KI kann Close Frame ([RFC6455-Section-5.5.1) an den](https://datatracker.ietf.org/doc/html/rfc6455#section-5.5.1) Modellcontainer senden, falls die Verbindung aus irgendeinem Grund geschlossen wird. 1. Ping-Frame: SageMaker KI sendet Ping Frame ([RFC6455-Section-5.5.2](https://datatracker.ietf.org/doc/html/rfc6455#section-5.5.2)) einmal alle 60 Sekunden, der Modellcontainer muss mit Pong Frame antworten. Wenn für 5 aufeinanderfolgende Pings kein Pong Frame ([RFC6455-Section-5.5.3](https://datatracker.ietf.org/doc/html/rfc6455#section-5.5.3)) empfangen wird, wird die Verbindung von KI geschlossen. SageMaker 1. Pong Frame: Die SageMaker KI reagiert auf Ping-Frames aus dem Modellcontainer mit Pong Frames. **4. Verarbeitung von Antwortstreams** Die Ausgabe wird als eine Reihe von PayloadParts ModelStreamErrors oder InternalStreamFailures gestreamt. ``` { "PayloadPart": { "Bytes": , "DataType": , "CompletionState": , }, "ModelStreamError": { "ErrorCode": , "Message": }, "InternalStreamFailure": { "Message": } } ``` **4.1. Datenrahmen** SageMaker KI konvertiert vom Modellcontainer empfangene Datenrahmen in eine Ausgabe PayloadParts: 1. Beim Empfang eines WebSocket Textdatenrahmens aus dem Modellcontainer ruft SageMaker AI die Rohbytes aus dem Textdatenrahmen ab und verpackt sie in eine Antwort PayloadPart, die inzwischen eingestellt `PayloadPart.DataType = UTF8` ist. 1. Beim Empfang eines WebSocket binären Datenrahmens aus dem Modellcontainer verpackt SageMaker KI die Bytes aus dem Datenrahmen direkt in eine Antwort PayloadPart, die inzwischen gesetzt ist. `PayloadPart.DataType = BINARY` 1. Für fragmentierte Nachrichten, wie in [RFC6455-Abschnitt-5.4](https://datatracker.ietf.org/doc/html/rfc6455#section-5.4): Fragmentierung definiert: + Der anfängliche Datenrahmen mit FIN-Bit clear wird in ein With-Zeichen übersetzt. PayloadPart `PayloadPart.CompletionState = PARTIAL` + Die nachfolgenden Continuation-Frames, bei denen das FIN-Bit frei ist, werden in „ PayloadParts mit`PayloadPart.CompletionState = PARTIAL`“ übersetzt. + Der letzte Continuation-Frame mit gesetztem FIN-Bit wird in „ PayloadPart mit“ übersetzt`PayloadPart.CompletionState = COMPLETE`. 1. SageMaker AI kodiert oder dekodiert die von Modellcontainern empfangenen Bytes nicht, die Bytes werden unverändert an den Modellcontainer übergeben. 1. SageMaker KI kombiniert nicht mehrere vom Modellcontainer empfangene Datenrahmen zu einer Antwort. PayloadPart 1. SageMaker KI teilt einen vom Modellcontainer empfangenen Datenrahmen nicht in mehrere Antworten auf PayloadParts. **Beispiel: Streaming-Antwortfluss** ``` Container sends: Frame 1: Text Data Frame with "Generating" (FIN=0) Frame 2: Continuation Frame with " response..." (FIN=1) Client receives: PayloadPart 1: {Bytes: "Generating", DataType: "UTF8", CompletionState: "PARTIAL"} PayloadPart 2: {Bytes: " response...", DataType: "UTF8", CompletionState: "COMPLETE"} ``` **4.2. Kontrollrahmen** SageMaker AI reagiert auf die folgenden Control Frames aus dem Modellcontainer: 1. Beim Empfang eines Close Frame ([RFC6455-Section-5.5.1](https://datatracker.ietf.org/doc/html/rfc6455#section-5.5.1)) vom Modellcontainer verpackt SageMaker AI den Statuscode ([RFC6455-Section-7.4) und die](https://datatracker.ietf.org/doc/html/rfc6455#section-7.4) Fehlermeldungen in und streamt ihn zurück an den ModelStreamError Endbenutzer. 1. Beim Empfang eines Ping-Frames ([RFC6455-Section-5.5.2) vom Modellcontainer antwortet AI](https://datatracker.ietf.org/doc/html/rfc6455#section-5.5.2) mit Pong Frame. SageMaker 1. Pong Frame ([RFC6455-Section-5.5.3): Wenn für 5 aufeinanderfolgende](https://datatracker.ietf.org/doc/html/rfc6455#section-5.5.3) Pings kein Pong Frame empfangen wird, wird die Verbindung von KI geschlossen. SageMaker