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 # Verwenden Sie eine private Docker-Registry für Echtzeit-Inferenzcontainer Mit Amazon SageMaker AI-Hosting können Sie standardmäßig in Amazon ECR gespeicherte Bilder verwenden, um Ihre Container für Echtzeit-Inferenzen zu erstellen. Optional können Sie Container für Echtzeit-Inferenzen aus Images in einer privaten Docker-Registry erstellen. Die private Registry muss von einer Amazon VPC in Ihrem Konto aus zugänglich sein. Modelle, die Sie basierend auf den in Ihrer privaten Docker-Registry gespeicherten Images erstellen, müssen so konfiguriert sein, dass sie eine Verbindung zu derselben VPC herstellen, über die auf die private Docker-Registry zugegriffen werden kann. Informationen zum Herstellen einer Verbindung Ihres Modells mit einem VPC finden Sie unter [Geben Sie SageMaker KI-gehosteten Endpunkten Zugriff auf Ressourcen in Ihrer Amazon VPC](host-vpc.md). Ihre Docker-Registry muss mit einem TLS-Zertifikat einer bekannten öffentlichen Zertifizierungsstelle (CA) gesichert werden. **Anmerkung** Ihre private Docker-Registry muss eingehenden Datenverkehr von den Sicherheitsgruppen zulassen, die Sie in der VPC-Konfiguration für Ihr Modell angeben, damit SageMaker KI-Hosting Modellimages aus Ihrer Registrierung abrufen kann. SageMaker KI kann Modellbilder abrufen, DockerHub wenn es in Ihrer VPC einen Pfad zum offenen Internet gibt. **Topics** + [Speichern Sie Images in einer privaten Docker-Registry, bei der es sich nicht um Amazon Elastic-Container-Registry handelt](#your-algorithms-containers-inference-private-registry) + [Verwenden Sie ein Image aus einer privaten Docker-Registry für Echtzeit-Inferenz](#your-algorithms-containers-inference-private-use) + [Erlauben Sie der SageMaker KI, sich bei einer privaten Docker-Registry zu authentifizieren](#inference-private-docker-authenticate) + [So erstellen Sie die Lambda-Funktion:](#inference-private-docker-lambda) + [Lambda die Berechtigung für Ihre Ausführungsrolle erteilen](#inference-private-docker-perms) + [Einen Schnittstellen-VPC-Endpunkt für Lambda erstellen](#inference-private-docker-vpc-interface) ## Speichern Sie Images in einer privaten Docker-Registry, bei der es sich nicht um Amazon Elastic-Container-Registry handelt Um eine private Docker-Registry zum Speichern Ihrer Bilder für SageMaker KI-Echtzeit-Inferenzen zu verwenden, erstellen Sie eine private Registry, auf die von Ihrer Amazon VPC aus zugegriffen werden kann. Informationen zum Erstellen einer Docker-Registry finden Sie in der Docker-Dokumentation unter [Bereitstellen eines Registry-Servers](https://docs.docker.com/registry/deploying/). Die Docker-Registry muss den folgenden Anforderungen entsprechen: + Bei der Registrierung muss es sich um eine [Docker Registry HTTP API V2](https://docs.docker.com/registry/spec/api/)-Registrierung handeln. + Auf die Docker-Registry muss von derselben VPC aus zugegriffen werden können, die Sie in dem `VpcConfig` Parameter angeben, den Sie bei der Erstellung Ihres Modells angeben. ## Verwenden Sie ein Image aus einer privaten Docker-Registry für Echtzeit-Inferenz Wenn Sie ein Modell erstellen und es für SageMaker KI-Hosting bereitstellen, können Sie angeben, dass es ein Image aus Ihrer privaten Docker-Registry verwendet, um den Inferenzcontainer zu erstellen. Geben Sie dies im `ImageConfig` Objekt in dem `PrimaryContainer` Parameter an, den Sie an einen Aufruf der [create\$1model-Funktion](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_model) übergeben. **Um ein in Ihrer privaten Docker-Registry gespeichertes Image für Ihren Inferenzcontainer zu verwenden,** 1. erstellen Sie das Image-Konfigurationsobjekt und geben Sie einen Wert von `Vpc` für das `RepositoryAccessMode` Feld an. ``` image_config = { 'RepositoryAccessMode': 'Vpc' } ``` 1. Wenn Ihre private Docker-Registry eine Authentifizierung erfordert, fügen Sie dem Image-Konfigurationsobjekt ein `RepositoryAuthConfig`-Objekt hinzu. Geben Sie für das `RepositoryCredentialsProviderArn` Feld des `RepositoryAuthConfig` Objekts den Amazon-Ressourcennamen (ARN) einer AWS Lambda Funktion an, die Anmeldeinformationen bereitstellt, mit denen sich SageMaker KI bei Ihrer privaten Docker-Registry authentifizieren kann. Weitere Informationen zum Erstellen der Lambda-Funktion für die Authentifizierung finden Sie unter [Erlauben Sie der SageMaker KI, sich bei einer privaten Docker-Registry zu authentifizieren](#inference-private-docker-authenticate). ``` image_config = { 'RepositoryAccessMode': 'Vpc', 'RepositoryAuthConfig': { 'RepositoryCredentialsProviderArn': 'arn:aws:lambda:Region:Acct:function:FunctionName' } } ``` 1. Erstellen Sie das primäre Container-Objekt, das Sie an `create_model` übergeben wollen, unter Verwendung des Image-Konfigurationsobjekts, das Sie im vorherigen Schritt erstellt haben. Stellen Sie Ihr Image in [Digest](https://docs.docker.com/engine/reference/commandline/pull/#pull-an-image-by-digest-immutable-identifier)-Form bereit. Wenn Sie Ihr Bild mithilfe des `:latest` Tags bereitstellen, besteht das Risiko, dass SageMaker KI eine neuere Version des Images als beabsichtigt abruft. Durch die Verwendung des Digest-Formulars wird sichergestellt, dass SageMaker KI die beabsichtigte Bildversion abruft. ``` primary_container = { 'ContainerHostname': 'ModelContainer', 'Image': 'myteam.myorg.com/docker-local/my-inference-image:', 'ImageConfig': image_config } ``` 1. Geben Sie den Modellnamen und die Ausführungsrolle an, die Sie an `create_model` übergeben wollen. ``` model_name = 'vpc-model' execution_role_arn = 'arn:aws:iam::123456789012:role/SageMakerExecutionRole' ``` 1. Geben Sie eine oder mehrere Sicherheitsgruppen und Subnetze für die VPC-Konfiguration für Ihr Modell an. Ihre private Docker-Registry muss eingehenden Datenverkehr von den Sicherheitsgruppen zulassen, die Sie angeben. Die Subnetze, die Sie angeben, müssen sich in derselben VPC wie Ihre private Docker-Registry befinden. ``` vpc_config = { 'SecurityGroupIds': ['sg-0123456789abcdef0'], 'Subnets': ['subnet-0123456789abcdef0','subnet-0123456789abcdef1'] } ``` 1. Holen Sie sich einen Boto3 AI-Client SageMaker . ``` import boto3 sm = boto3.client('sagemaker') ``` 1. Erstellen Sie das Modell, indem Sie `create_model` aufrufen und dabei die Werte verwenden, die Sie in den vorherigen Schritten für die Parameter `PrimaryContainer` und `VpcConfig` angegeben haben. ``` try: resp = sm.create_model( ModelName=model_name, PrimaryContainer=primary_container, ExecutionRoleArn=execution_role_arn, VpcConfig=vpc_config, ) except Exception as e: print(f'error calling CreateModel operation: {e}') else: print(resp) ``` 1. Rufen Sie abschließend [create\$1endpoint\$1config](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint_config) und [create\$1endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint) auf, um den Hosting-Endpunkt zu erstellen. Verwenden Sie dabei das Modell, das Sie im vorherigen Schritt erstellt haben. ``` endpoint_config_name = 'my-endpoint-config' sm.create_endpoint_config( EndpointConfigName=endpoint_config_name, ProductionVariants=[ { 'VariantName': 'MyVariant', 'ModelName': model_name, 'InitialInstanceCount': 1, 'InstanceType': 'ml.t2.medium' }, ], ) endpoint_name = 'my-endpoint' sm.create_endpoint( EndpointName=endpoint_name, EndpointConfigName=endpoint_config_name, ) sm.describe_endpoint(EndpointName=endpoint_name) ``` ## Erlauben Sie der SageMaker KI, sich bei einer privaten Docker-Registry zu authentifizieren [Um ein Inferenz-Image aus einer privaten Docker-Registry abzurufen, für die eine Authentifizierung erforderlich ist, erstellen Sie eine AWS Lambda Funktion, die Anmeldeinformationen bereitstellt, und geben Sie den Amazon-Ressourcennamen (ARN) der Lambda-Funktion an, wenn Sie create\$1model aufrufen.](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_model) Wenn SageMaker AI ausgeführt wird`create_model`, ruft es die Lambda-Funktion auf, die Sie angegeben haben, um Anmeldeinformationen für die Authentifizierung bei Ihrer Docker-Registry abzurufen. ## So erstellen Sie die Lambda-Funktion: Erstellen Sie eine AWS Lambda Funktion, die eine Antwort mit der folgenden Form zurückgibt: ``` def handler(event, context): response = { "Credentials": {"Username": "username", "Password": "password"} } return response ``` Je nachdem, wie Sie die Authentifizierung für Ihre private Docker-Registry einrichten, können die Anmeldeinformationen, die Ihre Lambda-Funktion zurückgibt, eine der folgenden Bedeutungen haben: + Wenn Sie Ihre private Docker-Registry für die Verwendung der grundlegenden Authentifizierung einrichten, geben Sie die Anmeldeinformationen für die Authentifizierung bei der Registrierung ein. + Wenn Sie Ihre private Docker-Registry für die Verwendung der Bearer-Token-Authentifizierung einrichten, werden die Anmeldeinformationen an Ihren Autorisierungsserver gesendet, der ein Bearer-Token zurückgibt, das dann zur Authentifizierung bei der privaten Docker-Registry verwendet werden kann. ## Lambda die Berechtigung für Ihre Ausführungsrolle erteilen Die Ausführungsrolle, die Sie zum Aufrufen verwenden, `create_model` muss über Berechtigungen zum Aufrufen von AWS Lambda Funktionen verfügen. Fügen Sie der Berechtigungsrichtlinie Ihrer Ausführungsrolle Folgendes hinzu. ``` { "Effect": "Allow", "Action": [ "lambda:InvokeFunction" ], "Resource": [ "arn:aws:lambda:*:*:function:*myLambdaFunction*" ] } ``` Wo *myLambdaFunction*ist der Name Ihrer Lambda-Funktion. Informationen zum Bearbeiten einer Rollenberechtigungsrichtlinie finden Sie unter [Abändern einer Rollenberechtigungsrichtlinie (Konsole)](https://docs.aws.amazon.com/IAM/latest/UserGuide/roles-managingrole-editing-console.html#roles-modify_permissions-policy) im *AWS Identity and Access Management Benutzerhandbuch*. **Anmerkung** Eine Ausführungsrolle, an die die `AmazonSageMakerFullAccess` verwaltete Richtlinie angehängt ist, hat die Berechtigung, jede Lambda-Funktion aufzurufen, die **SageMaker**in ihrem Namen steht. ## Einen Schnittstellen-VPC-Endpunkt für Lambda erstellen Erstellen Sie einen Schnittstellenendpunkt, damit Ihre Amazon VPC mit Ihrer AWS Lambda Funktion kommunizieren kann, ohne Traffic über das Internet zu senden. Informationen dazu finden Sie unter [Konfigurieren von Schnittstellen-VPC-Endpunkten für Lambda](https://docs.aws.amazon.com/lambda/latest/dg/configuration-vpc-endpoints.html) im *AWS Lambda Entwicklerhandbuch*. SageMaker KI-Hosting sendet über Ihre VPC eine Anfrage an`lambda.region.amazonaws.com`, um Ihre Lambda-Funktion aufzurufen. Wenn Sie bei der Erstellung Ihres Schnittstellenendpunkts den privaten DNS-Namen wählen, leitet Amazon Route 53 den Anruf an den Lambda-Schnittstellenendpunkt weiter. Wenn Sie einen anderen DNS-Anbieter verwenden, stellen Sie sicher, dass Sie `lambda.region.amazonaws.com` Ihrem Lambda-Schnittstellenendpunkt zuordnen.