Implantar um modelo a partir do Registro

Depois de registrar uma versão do modelo e aprová-la para implantação, implante-a em um SageMaker endpoint para inferência em tempo real. Você pode implantar seu modelo usando o SageMaker SDK ou o AWS SDK for Python (Boto3) (Boto3).

Quando você cria um projeto de operações de aprendizado de máquina (MLOps) e escolhe um modelo de projeto MLOps que inclui a implantação do modelo, as versões aprovadas do modelo no Registro de Modelos são automaticamente implantadas na produção. Para obter informações sobre o uso de projetos SageMaker MLOps, consulte. Automatize MLOPs com projetos SageMaker

Você também pode habilitar uma conta da AWS para implantar versões de modelo criadas em uma conta diferente adicionando uma política de recursos entre contas. Por exemplo, uma equipe em sua organização pode ser responsável pelos modelos de treinamento e uma equipe diferente é responsável pela implantação e atualização dos modelos.

Implantar um modelo a partir do Registro (SageMaker SDK)

Para implantar uma versão do modelo usando o Amazon SageMaker Python SDK, use o seguinte trecho de código:

from sagemaker import ModelPackage
from time import gmtime, strftime

model_package_arn = 'arn:aws:sagemaker:us-east-2:12345678901:model-package/modeltest/1'
model = ModelPackage(role=role, 
                     model_package_arn=model_package_arn, 
                     sagemaker_session=sagemaker_session)
model.deploy(initial_instance_count=1, instance_type='ml.m5.xlarge')

Implantar um modelo a partir do Registro (Boto3)

Para implantar uma versão do modelo usando o AWS SDK for Python (Boto3), conclua as seguintes etapas:

1. O trecho de código a seguir pressupõe que você já criou o cliente SageMaker Boto3 sm_client e uma versão do modelo cujo ARN está armazenado na variável. model_version_arn

   Crie um objeto de modelo a partir da versão do modelo chamando a operação da API create_model. Passe o Amazon Resource Name (ARN) da versão do modelo como parte do Containers para o objeto do modelo:

   model_name = 'DEMO-modelregistry-model-' + strftime("%Y-%m-%d-%H-%M-%S", gmtime())
   print("Model name : {}".format(model_name))
   container_list = [{'ModelPackageName': model_version_arn}]
   
   create_model_response = sm_client.create_model(
       ModelName = model_name,
       ExecutionRoleArn = role,
       Containers = container_list
   )
   print("Model arn : {}".format(create_model_response["ModelArn"]))

2. Crie uma configuração de endpoint chamando a API create_endpoint_config. A configuração do endpoint especifica o número e o tipo de instâncias do Amazon EC2 a serem usadas para o endpoint.

   endpoint_config_name = 'DEMO-modelregistry-EndpointConfig-' + strftime("%Y-%m-%d-%H-%M-%S", gmtime())
   print(endpoint_config_name)
   create_endpoint_config_response = sm_client.create_endpoint_config(
       EndpointConfigName = endpoint_config_name,
       ProductionVariants=[{
           'InstanceType':'ml.m4.xlarge',
           'InitialVariantWeight':1,
           'InitialInstanceCount':1,
           'ModelName':model_name,
           'VariantName':'AllTraffic'}])

3. Crie o endpoint chamando create_endpoint.

   endpoint_name = 'DEMO-modelregistry-endpoint-' + strftime("%Y-%m-%d-%H-%M-%S", gmtime())
   print("EndpointName={}".format(endpoint_name))
   
   create_endpoint_response = sm_client.create_endpoint(
       EndpointName=endpoint_name,
       EndpointConfigName=endpoint_config_name)
   print(create_endpoint_response['EndpointArn'])

Implantar uma versão do modelo de uma conta diferente

Você pode dar permissão para uma conta da AWS implantar versões de modelo criadas em uma conta diferente adicionando uma política de recursos entre contas. Por exemplo, uma equipe em sua organização pode ser responsável pelos modelos de treinamento e uma equipe diferente é responsável pela implantação e atualização dos modelos. Ao criar essas políticas de recursos, você aplica a política ao recurso específico ao qual deseja conceder acesso. Para obter mais informações sobre políticas de recursos entre contas na AWS, consulte Lógica de avaliação de políticas entre contas no Guia do usuário do AWS Identity and Access Management.

nota

Você deve usar uma chave do KMS para criptografar a ação de configurar dados de saída durante o treinamento para implantação do modelo entre contas.

Para habilitar a implantação do modelo entre contas SageMaker, você precisa fornecer uma política de recursos entre contas para o grupo de modelos que contém as versões do modelo que você deseja implantar, o repositório do Amazon ECR onde reside a imagem de inferência do grupo de modelos e o bucket do Amazon S3 onde as versões do modelo são armazenadas.

Para poder implantar um modelo que foi criado em uma conta diferente, você deve ter uma função que tenha acesso às SageMaker ações, como uma função com a política AmazonSageMakerFullAccess gerenciada. Para obter informações sobre as políticas gerenciadas do SageMaker, consulte AWSPolíticas gerenciadas para a Amazon SageMaker.

O exemplo a seguir cria políticas entre contas para todos esses três recursos e aplica as políticas aos recursos. O exemplo também pressupõe que você tenha definido anteriormente as seguintes variáveis:

• bucket— O bucket do Amazon S3 onde as versões do modelo são armazenadas.

• kms_key_id— A chave KMS usada para criptografar a saída do treinamento.

• sm_client— Um cliente SageMaker Boto3.

• model_package_group_name— O grupo de modelos ao qual você deseja conceder acesso entre contas.

• model_package_group_arn— O ARN do grupo de modelos ao qual você deseja conceder acesso entre contas.

import json

# The cross-account id to grant access to
cross_account_id = "123456789012"

# Create the policy for access to the ECR repository
ecr_repository_policy = {
    'Version': '2012-10-17',
    'Statement': [{
        'Sid': 'AddPerm',
        'Effect': 'Allow',
        'Principal': {
            'AWS': f'arn:aws:iam::{cross_account_id}:root'
        },
        'Action': ['ecr:*']
    }]
}

# Convert the ECR policy from JSON dict to string
ecr_repository_policy = json.dumps(ecr_repository_policy)

# Set the new ECR policy
ecr = boto3.client('ecr')
response = ecr.set_repository_policy(
    registryId = account,
    repositoryName = 'decision-trees-sample',
    policyText = ecr_repository_policy
)

# Create a policy for accessing the S3 bucket
bucket_policy = {
    'Version': '2012-10-17',
    'Statement': [{
        'Sid': 'AddPerm',
        'Effect': 'Allow',
        'Principal': {
            'AWS': f'arn:aws:iam::{cross_account_id}:root'
        },
        'Action': 's3:*',
        'Resource': f'arn:aws:s3:::{bucket}/*'
    }]
}

# Convert the policy from JSON dict to string
bucket_policy = json.dumps(bucket_policy)

# Set the new policy
s3 = boto3.client('s3')
response = s3.put_bucket_policy(
    Bucket = bucket,
    Policy = bucket_policy)

# Create the KMS grant for encryption in the source account to the
# Model Registry account Model Group
client = boto3.client('kms')

response = client.create_grant(
    GranteePrincipal=cross_account_id,
    KeyId=kms_key_id
    Operations=[
        'Decrypt',
        'GenerateDataKey',
    ],
)

# 3. Create a policy for access to the Model Group.
model_package_group_policy = {
    'Version': '2012-10-17',
    'Statement': [{
        'Sid': 'AddPermModelPackageGroup',
        'Effect': 'Allow',
        'Principal': {
            'AWS': f'arn:aws:iam::{cross_account_id}:root'
        },
        'Action': ['sagemaker:DescribeModelPackageGroup'],
        'Resource': f'arn:aws:sagemaker:{region}:{account}:model-package-group/{model_package_group_name}'
    },{
        'Sid': 'AddPermModelPackageVersion',
        'Effect': 'Allow',
        'Principal': {
            'AWS': f'arn:aws:iam::{cross_account_id}:root'
        },
        'Action': ["sagemaker:DescribeModelPackage",
                   "sagemaker:ListModelPackages",
                   "sagemaker:UpdateModelPackage",
                   "sagemaker:CreateModel"],
        'Resource': f'arn:aws:sagemaker:{region}:{account}:model-package/{model_package_group_name}/*'
    }]
}

# Convert the policy from JSON dict to string
model_package_group_policy = json.dumps(model_package_group_policy)

# Set the policy to the Model Group
response = sm_client.put_model_package_group_policy(
    ModelPackageGroupName = model_package_group_name,
    ResourcePolicy = model_package_group_policy)

print('ModelPackageGroupArn : {}'.format(create_model_package_group_response['ModelPackageGroupArn']))
print("First Versioned ModelPackageArn: " + model_package_arn)
print("Second Versioned ModelPackageArn: " + model_package_arn2)

print("Success! You are all set to proceed for cross-account deployment.")