Création des composants AWS IoT Greengrass V2

AWS IoT Greengrass utilise composants, un module logiciel qui est déployé et s'exécute sur un dispositif AWS IoT Greengrass Core. Vous avez besoin (au moins) de trois composants :

1. D'un composant AWS IoT Greengrass de l'agent Edge Manager public qui déploie le fichier binaire de l'agent Edge Manager.

2. Composant de modèle généré automatiquement lorsque vous empaquetez votre modèle d'apprentissage automatique avec l'AWS SDK for Python (Boto3)API ou avec la SageMaker console. Pour plus d’informations, consultez Création d'un composant généré automatiquement.

3. D'un composant personnalisé privé pour implémenter l'application client de l'agent Edge Manager, ainsi que pour effectuer le prétraitement et le post-traitement des résultats d'inférence. Pour de plus amples informations sur la création d'un composant personnalisé, veuillez consulter Création d'un composant généré automatiquement ou Create custom AWS IoT Greengrass components (Créer des composants GG personnalisés).

Création d'un composant généré automatiquement

Générez le composant du modèle avec l'CreateEdgePackagingJobAPI et spécifiez le champ API GreengrassV2Component de la tâche d'empaquetage SageMaker Edge ManagerPresetDeploymentType. Lorsque vous appelez l'CreateEdgePackagingJobAPI, Edge Manager prend votre modèle SageMaker compilé Neo dans Amazon S3 et crée un composant de modèle. Le composant du modèle est automatiquement stocké dans votre compte. Vous pouvez afficher n'importe lequel de vos composants en accédant à la console AWS IoT à l'adresse https://console.aws.amazon.com/iot/. Sélectionnez Greengrass, puis Core. La page contient une liste des dispositifs AWS IoT Greengrass Core associés à votre compte. Si le nom d'un composant de modèle n'est pas spécifié dans PresetDeploymentConfig, le nom par défaut généré se compose de "SagemakerEdgeManager" et du nom de la tâche d'empaquetage de votre agent Edge Manager. L'exemple suivant montre comment indiquer à Edge Manager de créer un composant AWS IoT Greengrass V2 avec l'API CreateEdgePackagingJob.

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 = 'edge-manager-demo-bucket'

# 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\"}"
                        }
                    )

Vous pouvez également créer le composant généré automatiquement à l'aide de la SageMaker console. Suivez les étapes 1 à 6 dans Package d'un modèle (Amazon SageMaker Console).

Saisissez l'URI du compartiment Amazon S3 où vous voulez stocker la sortie de la tâche d'empaquetage et la clé de chiffrement facultative.

Pour créer le composant de modèle, procédez comme suit :

1. Choisissez Preset deployment (Préconfigurer un déploiement).

2. Spécifiez le nom du composant dans le champ Component name (Nom du composant).

3. Vous pouvez éventuellement fournir une description du composant, une version du composant, le système d'exploitation de la plateforme ou l'architecture de la plateforme pour Component description (Description du composant), Component version (Version du composant), Platform OS (Système d'exploitation de la plateforme) et Platform architecture (Architecture de la plateforme), respectivement.

4. Sélectionnez Envoyer.

Créer un composant personnalisé Hello World

Le composant d'application personnalisé est utilisé pour effectuer une inférence sur le dispositif périphérique. Le composant est chargé de charger les modèles dans SageMaker Edge Manager, d'appeler l'agent Edge Manager à des fins d'inférence et de décharger le modèle lorsque le composant est arrêté. Avant de créer votre composant, veillez à ce que l'agent et l'application puissent communiquer avec Edge Manager. Pour ce faire, configurez gRPC. L'agent Edge Manager utilise les méthodes définies dans les tampons Protobuf et le serveur gRPC pour établir la communication avec l'application cliente sur l'appareil périphérique et le cloud.

Pour utiliser gRPC, vous devez :

1. Créer un stub gRPC à l'aide du fichier .proto fourni lorsque vous téléchargez l'agent Edge Manager à partir du compartiment de version Amazon S3.

2. Écrire le code client dans le langage qui vous est familier.

Vous n'avez pas besoin de définir le service dans un fichier .proto. Les fichiers .proto du service sont inclus dans le fichier TAR compressé lorsque vous téléchargez le fichier binaire de publication de l'agent Edge Manager à partir du compartiment de version Amazon S3.

Installez gRPC et les autres outils nécessaires sur votre machine hôte et créez les stubs gRPC agent_pb2_grpc.py et agent_pb2.py en Python. Vérifiez que agent.proto se trouve bien dans votre répertoire local.

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

Le code précédent génère les interfaces client et serveur gRPC à partir de votre définition de service .proto. En d'autres termes, il crée le modèle gRPC en Python. Le répertoire d'API contient la spécification Protobuf pour communiquer avec l'agent.

Ensuite, utilisez l'API gRPC pour écrire un client et un serveur pour votre service (2). L'exemple de script suivant, edge_manager_python_example.py, utilise Python pour charger, répertorier et décharger un modèle yolov3 sur le dispositif périphérique.

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()

Assurez-vous que model_path pointe sur le nom du composant AWS IoT Greengrass contenant le modèle, si vous utilisez le même exemple de code client.

Vous pouvez créer votre composant AWS IoT Greengrass V2 Hello World une fois que vous avez généré vos stubs gRPC et que votre code Hello World est prêt. Pour ce faire :

• Téléchargez vos edge_manager_python_example.py, agent_pb2_grpc.py et agent_pb2.py dans votre compartiment Amazon S3 et notez leur chemin d'accès Amazon S3.

• Créez un composant privé dans la console AWS IoT Greengrass V2 et définissez la recette pour votre composant. Spécifiez l'URI Amazon S3 pour votre application Hello World et le stub gRPC dans la recette suivante.

  ---
  RecipeFormatVersion: 2020-01-25
  ComponentName: com.sagemaker.edgePythonExample
  ComponentVersion: 1.0.0
  ComponentDescription: Sagemaker Edge Manager Python example
  ComponentPublisher: Amazon Web Services, Inc.
  ComponentDependencies:
    aws.greengrass.SageMakerEdgeManager:
      VersionRequirement: '>=1.0.0'
      DependencyType: HARD
  Manifests:
    - Platform:
        os: linux
        architecture: "/amd64|x86/"
      Lifecycle:
        install: |-
          apt-get install python3-pip
          pip3 install grpcio
          pip3 install grpcio-tools
          pip3 install protobuf
          pip3 install Pillow
        run:
          script: |- 
            python3 {artifacts:path}/edge_manager_python_example.py
      Artifacts:
        - URI: <code-s3-path>
        - URI: <pb2-s3-path>
        - URI: <pb2-grpc-s3-path>

Pour de plus amples informations sur la création d'une recette Hello World, veuillez consulter Create your first component (Créer votre premier composant) dans la documentation AWS IoT Greengrass.