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

Implante modelos JumpStart usando kubectl

As etapas a seguir mostram como implantar um JumpStart modelo em um HyperPod cluster usando kubectl.

As instruções a seguir contêm células de código e comandos projetados para execução em um ambiente de notebook Jupyter, como Amazon SageMaker Studio ou SageMaker Notebook Instances. Cada bloco de código representa uma célula do notebook que deve ser executada sequencialmente. Os elementos interativos, incluindo tabelas de descoberta de modelos e comandos de monitoramento de status, são otimizados para a interface do notebook e podem não funcionar adequadamente em outros ambientes. Certifique-se de ter acesso a um ambiente de notebook com as AWS permissões necessárias antes de continuar.

Pré-requisitos

Certifique-se de ter configurado recursos de inferência em seus SageMaker HyperPod clusters da Amazon. Para obter mais informações, consulte Configurando seus HyperPod clusters para implantação de modelos.

Definição e configuração

Selecione sua região

Escolha a região para implantar seu HyperPod cluster e onde você deseja executar suas cargas de trabalho de inferência. Você também pode adicionar outras personalizações ao. sagemaker_client

region_name = <REGION>

import boto3
from botocore.config import Config
# Configure retry options
boto3_config = Config(
    retries={
        'max_attempts': 10,  # Maximum number of retry attempts
        'mode': 'adaptive'   # Use adaptive mode for exponential backoff
    }
)

sagemaker_client=boto3.client("sagemaker", region_name=region_name, config=boto3_config)        

Escolha seu modelo e cluster

Configurar o nome do bucket S3

Configure os nomes dos buckets do S3 para certificados. Esse bucket precisa ter uma pasta chamada “certificados” na qual os certificados serão carregados. O bucket também precisa estar na mesma região definida acima.

# Set the S3 bucket name where TLS certificates will be stored for secure model communication
certificate_bucket = "<insert bucket name here>"      

import yaml
from datetime import datetime

# Get current time in format suitable for endpoint name
current_time = datetime.now().strftime("%Y%m%d-%H%M%S")
sagemaker_endpoint_name=f"{model_id}-{current_time}"


def generate_jumpstart_model_yaml(model_id, model_version, namespace, instance_type, output_file_path, certificate_bucket):
    """
    Generate a JumpStartModel YAML file with the provided parameters.

    Args:
        model_id (str): The model ID
        model_version (str): The model version
        namespace (str): The namespace
        instance_type (str): The instance type
        output_file_path (str): Path where the YAML file will be saved
    """

    # Create the YAML structure
    tlsCertificateOutputS3Uri = "s3://" + certificate_bucket + "/certificates/"
    model_config = {
        "apiVersion": "inference.sagemaker.aws.amazon.com/v1alpha1",
        "kind": "JumpStartModel",
        "metadata": {
            "name": model_id,
            "namespace": namespace
        },
        "spec": {
            "sageMakerEndpoint": {
                "name": sagemaker_endpoint_name
            },
            "model": {
                "modelHubName": "SageMakerPublicHub",
                "modelId": model_id,
                # modelVersion is optional
                "modelVersion": model_version
                # acceptEula is optional, set value to True when using a gated model
            },
            "server": {
                "instanceType": instance_type
            },
            "tlsConfig": {
                "tlsCertificateOutputS3Uri": tlsCertificateOutputS3Uri
            }
        }
    }

    # Write to YAML file
    with open(output_file_path, 'w') as file:
        yaml.dump(model_config, file, default_flow_style=False)

    print(f"YAML file created successfully at: {output_file_path}")       

# Import JumpStart utilities to retrieve model specifications and version information
from sagemaker.jumpstart import utilsfrom sagemaker.jumpstart.enums import JumpStartScriptScope

model_specs = utils.verify_model_region_and_return_specs(
        model_id, "*", JumpStartScriptScope.INFERENCE, region=region_name)     
model_version = model_specs.version       

# Generate the output filename for the Kubernetes YAML configuration
output_file_path=f"jumpstart-model-{model_id}.yaml"
generate_jumpstart_model_yaml(
    model_id=model_id,
    model_version=model_version,
    namespace=cluster_namespace,
    instance_type=instance_type,
    output_file_path=output_file_path,
    certificate_bucket=certificate_bucket
)

import os
os.environ["JUMPSTART_YAML_FILE_PATH"]=output_file_path
os.environ["MODEL_ID"]=model_id       

Implantar o modelo

Atualize sua configuração de kubernetes e implante seu modelo

Monitore o status da implantação do seu modelo

Invoque o endpoint do seu modelo

Você pode recuperar programaticamente exemplos de cargas do objeto. JumpStartModel

import boto3

prompt = "{\"inputs\": \"What is AWS SageMaker?\"}}"

runtime_client = boto3.client('sagemaker-runtime', region_name=region_name)
response = runtime_client.invoke_endpoint(
    EndpointName=sagemaker_endpoint_name,
    ContentType="application/json",
    Body=prompt
)
print(response["Body"].read().decode())      

Gerencie sua implantação

Limpar recursos

Exclua a implantação do JumpStart modelo quando não precisar mais dela.

!kubectl delete JumpStartModel $model_id -n $cluster_namespace      

Solução de problemas

Use esses comandos de depuração se sua implantação não estiver funcionando conforme o esperado.