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

Crie os componentes AWS IoT Greengrass V2

AWS IoT Greengrass usa componentes, um módulo de software que é implantado e executado em um dispositivo AWS IoT Greengrass principal. Você precisa (no mínimo) de três componentes:

Crie um componente gerado automaticamente

Gere o componente do modelo com a CreateEdgePackagingJobAPI e especifique GreengrassV2Component para o campo API do trabalho de empacotamento do SageMaker Edge ManagerPresetDeploymentType. Quando você chama a CreateEdgePackagingJob API, o Edge Manager pega seu modelo SageMaker AI Neo compilado no Amazon S3 e cria um componente de modelo. O componente do modelo é armazenado automaticamente em sua conta. Você pode visualizar qualquer um dos seus componentes navegando até o AWS IoT console https://console.aws.amazon.com/iot/. Selecione Greengrass e, em seguida, selecione dispositivos de núcleo. A página tem uma lista dos AWS IoT Greengrass principais dispositivos associados à sua conta. Se o nome de um componente do modelo não for especificado em PresetDeploymentConfig, o nome padrão gerado consistirá em "SagemakerEdgeManager" e no nome do seu trabalho de empacotamento do agente do Edge Manager. O exemplo a seguir demonstra como especificar que o Edge Manager crie um componente AWS IoT Greengrass V2 com a CreateEdgePackagingJob API.

import sagemaker
import boto3

# Create a SageMaker client object to make it easier to interact with other AWS services.
sagemaker_client = boto3.client('sagemaker', region=<YOUR_REGION>)

# Replace with your IAM Role ARN
sagemaker_role_arn = "arn:aws:iam::<account>:role/*"

# Replace string with the name of your already created S3 bucket.
bucket = 'amzn-s3-demo-bucket-edge-manager'

# Specify a name for your edge packaging job.
edge_packaging_name = "edge_packag_job_demo" 

# Replace the following string with the name you used for the SageMaker Neo compilation job.
compilation_job_name = "getting-started-demo" 

# The name of the model and the model version.
model_name = "sample-model" 
model_version = "1.1"

# Output directory in S3 where you want to store the packaged model.
packaging_output_dir = 'packaged_models' 
packaging_s3_output = 's3://{}/{}'.format(bucket, packaging_output_dir)

# The name you want your Greengrass component to have.
component_name = "SagemakerEdgeManager" + edge_packaging_name

sagemaker_client.create_edge_packaging_job(
                    EdgePackagingJobName=edge_packaging_name,
                    CompilationJobName=compilation_job_name,
                    RoleArn=sagemaker_role_arn,
                    ModelName=model_name,
                    ModelVersion=model_version,
                    OutputConfig={
                        "S3OutputLocation": packaging_s3_output,
                        "PresetDeploymentType":"GreengrassV2Component",
                        "PresetDeploymentConfig":"{\"ComponentName\":\"sample-component-name\", \"ComponentVersion\":\"1.0.2\"}"
                        }
                    )

Você também pode criar o componente gerado automaticamente com o console de SageMaker IA. Seguir as etapas de 1 a 6 em Package um modelo (Amazon SageMaker AI Console)

Insira o URI do bucket do Amazon S3 em que deseja armazenar a saída do trabalho de empacotamento e a chave de criptografia opcional.

Preencha o seguinte para criar o componente do modelo:

Crie um componente personalizado do Hello World

O componente de aplicação personalizado é usado para realizar inferência no dispositivo de borda. O componente é responsável por carregar modelos no SageMaker Edge Manager, invocar o agente do Edge Manager para inferência e descarregar o modelo quando o componente é desligado. Antes de criar seu componente, certifique-se de que o agente e a aplicação possam se comunicar com o Edge Manager. Para fazer isso, configure o gRPC. O agente do Edge Manager usa métodos definidos no Protobuf Buffers e no servidor gRPC para estabelecer comunicação com a aplicação cliente no dispositivo de borda e na nuvem.

Para usar o gRPC, você deve:

Você não precisa definir o serviço em um arquivo .proto. Os arquivos service .proto são incluídos no arquivo TAR compactado quando você baixa o binário de versão do agente do Edge Manager do bucket de lançamento do Amazon S3.

Instale o gRPC e outras ferramentas necessárias em seu computador host e crie os stubs do gRPC agent_pb2_grpc.py e agent_pb2.py em Python. Verifique se você tem agent.proto em seu diretório local.

%%bash
pip install grpcio
pip install grpcio-tools
python3 -m grpc_tools.protoc --proto_path=. --python_out=. --grpc_python_out=. agent.proto

O código anterior gera as interfaces de cliente e servidor gRPC a partir da sua definição do serviço .proto. Em outras palavras, ele cria o modelo gRPC em Python. O diretório da API contém a especificação Protobuf para comunicação com o agente.

Em seguida, use a API gRPC para escrever um cliente e um servidor para seu serviço (2). O script de exemplo a seguir, edge_manager_python_example.py, usa Python para carregar, listar e descarregar um modelo yolov3 no dispositivo de borda.

import grpc
from PIL import Image
import agent_pb2
import agent_pb2_grpc
import os


model_path = '<PATH-TO-SagemakerEdgeManager-COMPONENT>' 
                    
agent_socket = 'unix:///tmp/aws.greengrass.SageMakerEdgeManager.sock'

agent_channel = grpc.insecure_channel(agent_socket, options=(('grpc.enable_http_proxy', 0),))

agent_client = agent_pb2_grpc.AgentStub(agent_channel)


def list_models():
    return agent_client.ListModels(agent_pb2.ListModelsRequest())


def list_model_tensors(models):
    return {
        model.name: {
            'inputs': model.input_tensor_metadatas,
            'outputs': model.output_tensor_metadatas
        }
        for model in list_models().models
    }


def load_model(model_name, model_path):
    load_request = agent_pb2.LoadModelRequest()
    load_request.url = model_path
    load_request.name = model_name
    return agent_client.LoadModel(load_request)


def unload_model(name):
    unload_request = agent_pb2.UnLoadModelRequest()
    unload_request.name = name
    return agent_client.UnLoadModel(unload_request)


def predict_image(model_name, image_path):
    image_tensor = agent_pb2.Tensor()
    image_tensor.byte_data = Image.open(image_path).tobytes()
    image_tensor_metadata = list_model_tensors(list_models())[model_name]['inputs'][0]
    image_tensor.tensor_metadata.name = image_tensor_metadata.name
    image_tensor.tensor_metadata.data_type = image_tensor_metadata.data_type
    for shape in image_tensor_metadata.shape:
        image_tensor.tensor_metadata.shape.append(shape)
    predict_request = agent_pb2.PredictRequest()
    predict_request.name = model_name
    predict_request.tensors.append(image_tensor)
    predict_response = agent_client.Predict(predict_request)
    return predict_response

def main():
    try:
        unload_model('your-model')
    except:
        pass
  
    print('LoadModel...', end='')
    try:
        load_model('your-model', model_path)
        print('done.')
    except Exception as e:
        print()
        print(e)
        print('Model already loaded!')
        
    print('ListModels...', end='')
    try:
        print(list_models())
        print('done.')
        
    except Exception as e:
        print()
        print(e)
        print('List model failed!')
       
    print('Unload model...', end='')
    try:
        unload_model('your-model')
        print('done.')
    except Exception as e:
        print()
        print(e)
        print('unload model failed!')

if __name__ == '__main__':
    main()

Certifique-se de model_path apontar para o nome do AWS IoT Greengrass componente que contém o modelo se você usar o mesmo exemplo de código de cliente.

Você pode criar seu componente AWS IoT Greengrass V2 Hello World depois de gerar seus stubs gRPC e ter seu código Hello World pronto. Para fazer isso:

Para obter informações detalhadas sobre como criar uma receita do Hello World, consulte Criar seu primeiro componente na AWS IoT Greengrass documentação.