Código de inferência personalizado com serviços de host - SageMaker IA da Amazon
Como a SageMaker IA executa sua imagem de inferênciaComo a SageMaker IA carrega seus artefatos de modeloComo o contêiner deve responder a solicitações de inferênciaComo o contêiner deve responder a solicitações de verificação de integridade (ping)Contrato de contêiner para oferecer suporte a recursos de streaming bidirecional

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

Código de inferência personalizado com serviços de host

Esta seção explica como a Amazon SageMaker AI interage com um contêiner Docker que executa seu próprio código de inferência para serviços de hospedagem. Use essas informações para gravar um código de inferência e criar uma imagem do Docker.

Tópicos

Como a SageMaker IA executa sua imagem de inferência

Para que um contêiner funcione como um executável, é preciso configurá-lo com uma instrução ENTRYPOINT em um Dockerfile. Observe o seguinte:

  • Para inferência do modelo, a SageMaker IA executa o contêiner como:

    docker run image serve

    SageMaker A IA substitui CMD as declarações padrão em um contêiner especificando o serve argumento após o nome da imagem. O argumento serve substitui os argumentos que você fornece com o comando CMD no Dockerfile.

     

  • SageMaker A IA espera que todos os contêineres sejam executados com usuários root. Crie seu contêiner para que ele use somente usuários-raiz. Quando a SageMaker IA executa seu contêiner, os usuários que não têm acesso no nível raiz podem causar problemas de permissões.

     

  • Recomendamos que você use a forma exec da instrução ENTRYPOINT:

    ENTRYPOINT ["executable", "param1", "param2"]

    Por exemplo:

    ENTRYPOINT ["python", "k_means_inference.py"]

    A forma exec da instrução ENTRYPOINT inicia o executável diretamente, não como elemento filho de /bin/sh. Isso permite que ele receba sinais como SIGTERM e SIGKILL das operações da SageMaker API, o que é um requisito.

     

    Por exemplo, quando você usa a CreateEndpointAPI para criar um endpoint, a SageMaker IA provisiona o número de instâncias de computação de ML exigidas pela configuração do endpoint, que você especifica na solicitação. SageMaker A IA executa o contêiner Docker nessas instâncias.

     

    Se você reduzir o número de instâncias que apoiam o endpoint (chamando a UpdateEndpointWeightsAndCapacitiesAPI), a SageMaker IA executa um comando para interromper o contêiner do Docker nas instâncias que estão sendo encerradas. Primeiramente, o comando envia o sinal SIGTERM e, então, envia o sinal SIGKILL 30 segundos depois.

     

    Se você atualizar o endpoint (chamando a UpdateEndpointAPI), a SageMaker AI lançará outro conjunto de instâncias de computação de ML e executará os contêineres do Docker que contêm seu código de inferência neles. Em seguida, ele executará um comando para interromper os contêineres anteriores do Docker. Para interromper um contêiner do Docker, primeiramente, o comando envia o sinal SIGTERM e, 30 segundos depois, envia o sinal SIGKILL.

     

  • SageMaker A IA usa a definição de contêiner que você forneceu em sua CreateModelsolicitação para definir variáveis de ambiente e o nome do host DNS para o contêiner da seguinte forma:

     

    • Ele define variáveis de ambiente usando o ContainerDefinition.Environment string-to-string mapa.

    • Ele define o nome de host DNS usando ContainerDefinition.ContainerHostname.

       

  • Se você planeja usar dispositivos de GPU para inferências de modelo (especificando instâncias de cálculo de ML baseadas em GPU na sua solicitação CreateEndpointConfig), verifique se os seus contêineres são compatíveis com nvidia-docker. Não empacote drivers NVIDIA com a imagem. Para obter mais informações sobre o nvidia-docker, consulte NVIDIA/nvidia-docker.

     

  • Você não pode usar o tini inicializador como seu ponto de entrada em contêineres de SageMaker IA porque ele fica confuso com os argumentos train e. serve

Como a SageMaker IA carrega seus artefatos de modelo

Em sua solicitação de CreateModelAPI, você pode usar o S3DataSource parâmetro ModelDataUrl or para identificar o local do S3 onde os artefatos do modelo são armazenados. SageMaker A IA copia os artefatos do seu modelo da localização do S3 para o /opt/ml/model diretório para serem usados pelo seu código de inferência. Seu contêiner tem acesso somente leitura ao /opt/ml/model. Não grave nesse diretório.

O ModelDataUrl deve apontar para um arquivo tar.gz. Caso contrário, a SageMaker IA não baixará o arquivo.

Se você treinou seu modelo em SageMaker IA, os artefatos do modelo são salvos como um único arquivo tar compactado no Amazon S3. Se você treinou seu modelo fora da SageMaker IA, precisará criar esse único arquivo tar compactado e salvá-lo em um local do S3. SageMaker O AI descompacta esse arquivo tar no opt/ml/model diretório/antes do início do contêiner.

Para implantar grandes modelos, recomendamos que você siga Implantação de modelos não compactados.

Como o contêiner deve responder a solicitações de inferência

Para obter inferências, o aplicativo cliente envia uma solicitação POST para o endpoint de SageMaker IA. SageMaker A IA passa a solicitação para o contêiner e retorna o resultado da inferência do contêiner para o cliente.

Para obter mais informações sobre as solicitações de inferência que seu contêiner receberá, consulte as seguintes ações na Amazon SageMaker AI API Reference:

Requisitos para contêineres de inferência

Para responder às solicitações de inferência, seu contêiner deve atender aos seguintes requisitos:

  • SageMaker A IA remove todos os POST cabeçalhos, exceto aqueles suportados peloInvokeEndpoint. SageMaker A IA pode adicionar cabeçalhos adicionais. É necessário que os contêineres de inferência consigam ignorar esses cabeçalhos adicionais com segurança.

  • Para receber solicitações de inferência, o contêiner deve ter um servidor web ouvindo na porta 8080 e deve aceitar solicitações POST para os endpoints /invocations e /ping.

  • Os contêineres de modelo do cliente devem aceitar solicitações de conexão de soquete dentro de 250 ms.

  • Os contêineres de modelo de um cliente devem responder a solicitações dentro de 60 segundos. O modelo em si pode ter um tempo máximo de processamento de 60 segundos antes de responder às /invocations. Se o seu modelo precisar de 50 a 60 segundos de tempo de processamento, o tempo limite de soquete do SDK deverá ser definido como 70 segundos.

  • O modelo de contêiner de um cliente que ofereça suporte a streaming bidirecional deve:

    • suporta WebSockets conexões na porta 8080 a/invocations-bidirectional-stream por padrão.

    • tem um servidor web escutando na porta 8080 e deve aceitar solicitações POST nos endpoints /ping.

    • Além das verificações de integridade do contêiner via HTTP, o contêiner deve responder com Pong Frame per (RFC6455), para enviar o WebSocket Ping Frame.

exemplo funções de invocação

Os exemplos a seguir demonstram como o código em seu contêiner pode processar solicitações de inferência. Esses exemplos tratam das solicitações que os aplicativos clientes enviam usando a InvokeEndpoint ação.

FastAPI

O FastAPI é uma estrutura web para construção APIs com 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
. . .

Neste exemplo, a invocations função manipula a solicitação de inferência que a SageMaker IA envia para o /invocations endpoint.

Flask

O Flask é um framework para o desenvolvimento de aplicações web com 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')

Neste exemplo, a invoke função manipula a solicitação de inferência que a SageMaker IA envia para o /invocations endpoint.

exemplo funções de invocação para solicitações de streaming

Os exemplos a seguir demonstram como o código em seu contêiner pode processar solicitações de inferência de streaming. Esses exemplos tratam das solicitações que os aplicativos clientes enviam usando a InvokeEndpointWithResponseStream ação.

Quando um contêiner processa uma solicitação de inferência de streaming, ele retorna a inferência do modelo como uma série de partes incrementalmente à medida que o modelo as gera. As aplicações cliente começam a receber respostas imediatamente conforme elas ficam disponíveis. Eles não precisam esperar que o modelo gere a resposta completa. Você pode implementar o streaming para oferecer apoio a experiências interativas rápidas, como chatbots, assistentes virtuais e geradores de música.

FastAPI

O FastAPI é uma estrutura web para construção APIs com 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
. . .

Neste exemplo, a invocations função manipula a solicitação de inferência que a SageMaker IA envia para o /invocations endpoint. Para transmitir a resposta, o exemplo usa a classe StreamingResponse do framework Starlette.

Flask

O Flask é um framework para o desenvolvimento de aplicações web com 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')
. . .

Neste exemplo, a invocations função manipula a solicitação de inferência que a SageMaker IA envia para o /invocations endpoint. Para transmitir a resposta, o exemplo usa função flask.stream_with_context do framework Flask.

exemplo Exemplo de funções de invocação para streaming bidirecional

Os exemplos a seguir demonstram como o código em seu contêiner pode processar solicitações e respostas de inferência de streaming. Esses exemplos lidam com solicitações de streaming que os aplicativos clientes enviam usando a InvokeEndpointWithBidirectionalStream ação.

Um contêiner com capacidade de streaming bidirecional lida com solicitações de inferência de streaming em que as partes são geradas incrementalmente no cliente e transmitidas para o contêiner. Ele retorna a inferência do modelo ao cliente como uma série de partes à medida que o modelo as gera. As aplicações cliente começam a receber respostas imediatamente conforme elas ficam disponíveis. Eles não precisam esperar que a solicitação seja totalmente gerada no cliente ou que o modelo gere a resposta inteira. Você pode implementar o streaming bidirecional para oferecer suporte a experiências interativas rápidas, como chatbots, assistentes de IA de voz interativos e traduções em tempo real para uma experiência mais em tempo real.

FastAPI

O FastAPI é uma estrutura web para construção APIs com 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()

Neste exemplo, a websocket_invoke função manipula a solicitação de inferência que a SageMaker IA envia para o /invocations-bidirectional-stream endpoint. Ele mostra como lidar com solicitações de stream e transmitir respostas de volta para o cliente.

Como o contêiner deve responder a solicitações de verificação de integridade (ping)

SageMaker A IA lança novos contêineres de inferência nas seguintes situações:

  • Respondendo a chamadas de API CreateEndpoint, UpdateEndpoint, UpdateEndpointWeightsAndCapacities

  • Patches de segurança

  • Substituição de instâncias não íntegras

Logo após a inicialização do contêiner, a SageMaker IA começa a enviar solicitações GET periódicas para o /ping endpoint.

O requisito mais simples é que o contêiner deve responder com um código de status HTTP 200 e um corpo vazio. Isso indica à SageMaker IA que o contêiner está pronto para aceitar solicitações de inferência no /invocations endpoint.

Se o contêiner não começar a passar pelas verificações de integridade, respondendo consistentemente com 200s durante os 8 minutos após a inicialização, a execução da nova instância falhará. Isso fará o CreateEndpoint falhar, deixando o endpoint em um estado de falha. A atualização solicitada por UpdateEndpoint não será concluída, os patches de segurança não serão aplicados e as instâncias não íntegras não serão substituídas.

Embora a exigência mínima seja para o contêiner retornar um 200 estático, um desenvolvedor de contêiner pode usar essa funcionalidade para executar verificações mais profundas. O tempo limite da solicitação em tentativas /ping é de 2 segundos.

Além disso, um contêiner capaz de lidar com solicitações de streaming bidirecional deve responder com um Pong Frame (por WebSocket protocolo RFC6455) a um Ping Frame. Se nenhum Pong Frame for recebido por 5 pings consecutivos, a conexão com o contêiner será fechada pela plataforma SageMaker AI. SageMaker A plataforma de IA também responderá aos Ping Frames do contêiner do modelo com Pong Frames.

Contrato de contêiner para oferecer suporte a recursos de streaming bidirecional

Se você quiser hospedar seu contêiner de modelo como um endpoint de SageMaker IA que ofereça suporte a recursos de streaming bidirecional, o contêiner de modelo deve oferecer suporte ao contrato abaixo:

1. Etiqueta Docker bidirecional

O contêiner do modelo deve ter um rótulo Docker indicando à plataforma de SageMaker IA que a capacidade de streaming bidirecional é compatível com esse contêiner.

com.amazonaws.sagemaker.capabilities.bidirectional-streaming=true

2. Support WebSocket Connection para invocações

O modelo de contêiner do cliente que suporta streaming bidirecional deve suportar WebSockets conexões na porta 8080 ou, por padrão. /invocations-bidirectional-stream

Esse caminho pode ser substituído passando o cabeçalho X-Amzn-SageMaker-Model -Invocation-Path ao invocar a API. InvokeEndpointWithBidirectionalStream Além disso, os usuários podem especificar uma string de consulta a ser anexada a esse caminho passando o cabeçalho X-Amzn-SageMaker-Model -Query-String ao invocar a API. InvokeEndpointWithBidirectionalStream

3. Tratamento de fluxo de solicitações

<Blob>As cargas de entrada da InvokeEndpointWithBidirectionalStream API são transmitidas como uma série de PayloadParts, que é apenas um invólucro de um fragmento binário (“Bytes”:): 

{
   "PayloadPart": { 
      "Bytes": <Blob>,
      "DataType": <String: UTF8 | BINARY>,
      "CompletionState": <String: PARTIAL | COMPLETE>
      "P": <String>
   }
}

3.1. Quadros de dados

SageMaker A IA passa a entrada PayloadParts para o contêiner do modelo como quadros de WebSocket dados (RFC6455-Seção-5.6)

  1. SageMaker A IA não inspeciona o fragmento binário.

  2. Ao receber uma entrada PayloadPart

    • SageMaker A IA cria exatamente um quadro de WebSocket dados PayloadPart.Bytes e o passa para o contêiner do modelo.

    • SePayloadPart.DataType = UTF8, a SageMaker IA criar um quadro de dados de texto

    • Se PayloadPart.DataType não estiver presente ouPayloadPart.DataType = BINARY, a SageMaker IA cria um quadro de dados binário

  3. Para uma sequência de PayloadParts com e terminada por uma PayloadPart com PayloadPart.CompletionState = PARTIALPayloadPart.CompletionState = COMPLETE, a SageMaker IA as traduz em mensagem WebSocket fragmentada RFC6455-Seção-5.4: Fragmentação:

    • A largura inicial PayloadPart PayloadPart.CompletionState = PARTIAL será traduzida em um quadro de WebSocket dados, com o FIN um pouco claro.

    • O texto subsequente PayloadParts PayloadPart.CompletionState = PARTIAL será traduzido em Quadros de WebSocket Continuação com FIN um pouco claro.

    • A largura final PayloadPart PayloadPart.CompletionState = COMPLETE será traduzida em WebSocket Continuation Frame com o bit FIN definido.

  4. SageMaker A IA não codifica nem decodifica o fragmento binário da entrada PayloadPart, os bytes são passados para o contêiner do modelo no estado em que se encontram.

  5. SageMaker A IA não combina várias entradas PayloadParts em uma BinaryDataFrame.

  6. SageMaker A IA não divide uma entrada PayloadPart em várias BinaryDataFrames.

Exemplo: fluxo de mensagens fragmentado

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. Quadros de controle

Além dos quadros de dados, a SageMaker IA também envia quadros de controle para o contêiner do modelo (RFC6455-Seção-5.5):

  1. Fechar quadro: a SageMaker AI pode enviar o Close Frame (RFC6455-Seção-5.5.1) para o contêiner do modelo caso a conexão seja fechada por qualquer motivo.

  2. Ping Frame: a SageMaker IA envia o Ping Frame (RFC6455-Seção-5.5.2) uma vez a cada 60 segundos, o contêiner do modelo deve responder com o Pong Frame. Se nenhum Pong Frame (RFC6455-Seção-5.5.3) for recebido por 5 pings consecutivos, a conexão será fechada pela IA. SageMaker

  3. Pong Frame: A SageMaker IA responderá aos Ping Frames do contêiner do modelo com Pong Frames.

4. Tratamento do fluxo de resposta

A saída é transmitida como uma série de PayloadParts, ModelStreamErrors ou InternalStreamFailures.

{   
   "PayloadPart": { 
      "Bytes": <Blob>,
      "DataType": <String: UTF8 | BINARY>,
      "CompletionState": <String: PARTIAL | COMPLETE>,
   },
   "ModelStreamError": {
      "ErrorCode": <String>,
      "Message": <String>
   },
   "InternalStreamFailure": {
      "Message": <String>
   }
}

4.1. Quadros de dados

SageMaker A IA converte os quadros de dados recebidos do contêiner do modelo em saída PayloadParts:

  1. Ao receber um quadro de dados de WebSocket texto do contêiner do modelo, a SageMaker IA obtém os bytes brutos do quadro de dados de texto e os agrupa em uma resposta PayloadPart, enquanto isso é definidoPayloadPart.DataType = UTF8.

  2. Ao receber um quadro de dados WebSocket binário do contêiner do modelo, a SageMaker IA agrupa diretamente os bytes do quadro de dados em uma resposta PayloadPart, enquanto isso é definidoPayloadPart.DataType = BINARY.

  3. Para mensagens fragmentadas, conforme definido em RFC6455-Seção-5.4: Fragmentação:

    • O quadro de dados inicial com FIN bit clear será traduzido em um PayloadPart withPayloadPart.CompletionState = PARTIAL.

    • Os quadros de continuação subsequentes com FIN bit clear serão traduzidos para PayloadParts comPayloadPart.CompletionState = PARTIAL.

    • O quadro de continuação final com o conjunto de bits FIN será traduzido para PayloadPart comPayloadPart.CompletionState = COMPLETE.

  4. SageMaker A IA não codifica nem decodifica os bytes recebidos dos contêineres do modelo; os bytes são passados para o contêiner do modelo no estado em que se encontram.

  5. SageMaker A IA não combina vários quadros de dados recebidos do contêiner do modelo em uma resposta PayloadPart.

  6. SageMaker A IA não divide um quadro de dados recebido do contêiner do modelo em várias respostas PayloadParts.

Exemplo: fluxo de resposta de streaming

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. Quadros de controle

SageMaker A IA responde aos seguintes quadros de controle do contêiner do modelo:

  1. Ao receber um Close Frame (RFC6455-Section-5.5.1) do contêiner do modelo, a SageMaker IA empacotará o código de status (RFC6455-Seção-7.4) e as mensagens de falha e os transmitirá de volta ao ModelStreamError usuário final.

  2. Ao receber um Ping Frame (RFC6455-Seção-5.5.2) do contêiner do modelo, a SageMaker IA responderá com o Pong Frame.

  3. Pong Frame (RFC6455-Seção-5.5.3): Se nenhum Pong Frame for recebido por 5 pings consecutivos, a conexão será fechada pela IA. SageMaker