Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Agent Edge Manager
L'agent Edge Manager est un moteur d'inférence pour vos dispositifs périphériques. Utilisez l'agent pour réaliser des prédictions avec les modèles chargés sur vos dispositifs périphériques. L'agent collecte également des métriques de modèle et capture des données à intervalles définis. Des exemples de données sont stockés dans votre compartiment Amazon S3.
Il existe deux méthodes pour installer et déployer l'agent Edge Manager sur vos dispositifs périphériques :
1. Téléchargez l'agent sous forme de fichier binaire à partir du compartiment de version Amazon S3. Pour de plus amples informations, veuillez consulter [Téléchargement et configuration manuels de l'agent Edge Manager](edge-device-fleet-manual.md).
1. Utilisez la console AWS IoT Greengrass V2 ou le AWS CLI pour déployer`aws.greengrass.SageMakerEdgeManager`. Consultez [Création des composants de la AWS IoT Greengrass V2](edge-greengrass-custom-component.md).
# Téléchargement et configuration manuels de l'agent Edge Manager
Téléchargez l'agent Edge Manager en fonction de votre système d'exploitation, de votre architecture et de votre région AWS . Comme l'agent est mis à jour périodiquement, vous avez la possibilité de choisir votre agent en fonction des dates de sortie et des versions. Lorsque vous avez l'agent, créez un fichier de configuration JSON. Spécifiez le nom de l'objet IoT du dispositif, le nom de la flotte, les informations d'identification du dispositif et d'autres paires clé-valeur. Consultez [Exécution de l'agent Edge Manager](#edge-device-fleet-running-agent) pour obtenir une liste complète des clés que vous devez spécifier dans le fichier de configuration. Vous pouvez exécuter l'agent sous forme de fichier binaire exécutable ou le lier en tant qu'objet partagé dynamique (DSO).
## Fonctionnement de l'agent
L'agent s'exécute sur le CPU de vos dispositifs. L'agent exécute l'inférence sur le cadre et le matériel du dispositif cible que vous avez spécifié lors de la tâche de compilation. Par exemple, si vous avez compilé votre modèle pour le Jetson Nano, l'agent prend en charge le GPU dans le package [Deep Learning Runtime](https://github.com/neo-ai/neo-ai-dlr) (DLR).
L'agent est publié au format binaire pour les systèmes d'exploitation pris en charge. Vérifiez que votre système d'exploitation est pris en charge et satisfait la configuration minimale du système d'exploitation indiquée dans le tableau suivant :
------
#### [ Linux ]
**Version :** Ubuntu 18.04
**Formats binaires pris en charge :** x86-64 bits (binaire ELF) et ARMv8 64 bits (binaire ELF)
------
#### [ Windows ]
**Version :** Windows 10 version 1909
**Formats binaires pris en charge :** x86-32 bits (DLL) et x86-64 bits (DLL)
------
## Installation de l'agent Edge Manager
Pour utiliser l'agent Edge Manager, vous devez d'abord obtenir les artefacts de version et un certificat racine. Les artefacts de version sont stockés dans un compartiment Amazon S3 dans la région `us-west-2`. Pour télécharger les artefacts, spécifiez votre système d'exploitation (``) et la ``.
Selon votre système d'exploitation, remplacez `` par l'un des éléments suivants :
| Windows 32 bits | Windows 64 bits | Linux x86-64 | Linux ARMv8 |
| --- | --- | --- | --- |
| windows-x86 | windows-x64 | linux-x64 | linux-armv8 |
La `VERSION` se décompose en trois éléments : `.-`, où :
+ `` : la version de sortie. La version de sortie est actuellement définie sur `1`.
+ `` : l'horodatage de la sortie des artefacts.
+ `` : l'ID de validation du référentiel à partir duquel la version est générée.
Vous devez fournir la `` et l'horodatage au format `YYYY-MM-DD`. Nous vous suggérons d'utiliser le dernier horodatage de version d'artefact.
Exécutez ce qui suit dans votre ligne de commande pour obtenir le dernier horodatage. Remplacez `` par votre système d'exploitation :
```
aws s3 ls s3://sagemaker-edge-release-store-us-west-2-/Releases/ | sort -r
```
Par exemple, si votre système d'exploitation est Windows 32 bits, exécutez :
```
aws s3 ls s3://sagemaker-edge-release-store-us-west-2-windows-x86/Releases/ | sort -r
```
Cela renvoie :
```
2020-12-01 23:33:36 0
PRE 1.20201218.81f481f/
PRE 1.20201207.02d0e97/
```
La sortie renvoyée dans cet exemple montre deux artefacts de version. Le fichier artefact de la première version indique que la version de publication possède une version majeure de`1`, un horodatage `20201218` (au YYYY-MM-DD format) et un identifiant de validation `81f481f` SHA-7.
**Note**
La commande précédente suppose que vous avez configuré la AWS Command Line Interface. Pour plus d'informations sur la façon de configurer les paramètres avec lesquels l' AWS CLI utilisateur interagit AWS, voir [Configuration de la AWS CLI](https://docs.aws.amazon.com//cli/latest/userguide/cli-chap-configure.html).
Selon votre système d'exploitation, utilisez les commandes suivantes pour installer les artefacts :
------
#### [ Windows 32-bit ]
```
aws s3 cp s3://sagemaker-edge-release-store-us-west-2-windows-x86/Releases//.zip .
aws s3 cp s3://sagemaker-edge-release-store-us-west-2-windows-x86/Releases//sha256_hex.shasum .
```
------
#### [ Windows 64-bit ]
```
aws s3 cp s3://sagemaker-edge-release-store-us-west-2-windows-x64/Releases//.zip .
aws s3 cp s3://sagemaker-edge-release-store-us-west-2-windows-x64/Releases//sha256_hex.shasum .
```
------
#### [ Linux x86-64 ]
```
aws s3 cp s3://sagemaker-edge-release-store-us-west-2-linux-x64/Releases//.tgz .
aws s3 cp s3://sagemaker-edge-release-store-us-west-2-linux-x64/Releases//sha256_hex.shasum .
```
------
#### [ Linux ARMv8 ]
```
aws s3 cp s3://sagemaker-edge-release-store-us-west-2-linux-armv8/Releases//.tgz .
aws s3 cp s3://sagemaker-edge-release-store-us-west-2-linux-armv8/Releases//sha256_hex.shasum .
```
------
Vous devez aussi télécharger un certificat racine. Ce certificat valide les artefacts du modèle signés par AWS avant de les charger sur vos appareils Edge.
Remplacez l'`` correspondant à votre plateforme depuis la liste des systèmes d'exploitation pris en charge et remplacez `` par votre région AWS .
```
aws s3 cp s3://sagemaker-edge-release-store-us-west-2-/Certificates//.pem .
```
## Exécution de l'agent Edge Manager
Vous pouvez exécuter l'agent SageMaker AI Edge Manager en tant que processus autonome sous la forme d'un fichier binaire exécutable au format ELF (Executable and Linkable Format) ou vous pouvez créer un lien vers celui-ci en tant qu'objet partagé dynamique (.dll). Linux prend en charge son exécution en tant que fichier binaire exécutable autonome, ce qui correspond au mode préféré. Windows prend en charge son exécution en tant qu'objet partagé (.dll).
Sous Linux, nous vous recommandons d'exécuter le fichier binaire via un service qui fait partie de votre système d'initialisation (`init`). Si vous voulez exécuter le fichier binaire directement, vous pouvez le faire dans un terminal, comme illustré dans l'exemple suivant. Si vous avez un système d'exploitation moderne, vous n'avez rien d'autre à installer avant d'exécuter l'agent, car toutes les exigences sont statiquement intégrées dans le fichier exécutable. Cela vous donne la flexibilité d'exécuter l'agent sur le terminal en tant que service ou dans un conteneur.
Lorsque vous avez l'agent, commencez par créer un fichier de configuration JSON. Spécifiez les paires clé/valeur suivantes :
+ `sagemaker_edge_core_device_name` : nom de l'appareil. Ce nom d'appareil doit être enregistré avec le parc d'appareils dans la console SageMaker Edge Manager.
+ `sagemaker_edge_core_device_fleet_name` : le nom de la flotte à laquelle appartient le dispositif.
+ `sagemaker_edge_core_region`: AWS Région associée à l'appareil, au parc et aux compartiments Amazon S3. Cela correspond à la région où l'appareil est enregistré et à celle où le compartiment Amazon S3 est créé (elles sont censées être les mêmes). Les modèles eux-mêmes peuvent être compilés avec SageMaker Neo dans une région différente, cette configuration n'est pas liée à la région de compilation de modèles.
+ `sagemaker_edge_core_root_certs_path` : le chemin absolu du dossier vers les certificats racine. Ceci est utilisé pour valider l'appareil avec le AWS compte correspondant.
+ `sagemaker_edge_provider_aws_ca_cert_file`: chemin absolu vers le certificat Amazon Root CA (AmazonRootCA1.pem). Ceci est utilisé pour valider l'appareil avec le AWS compte correspondant. `AmazonCA`est un certificat détenu par AWS.
+ `sagemaker_edge_provider_aws_cert_file`: chemin absolu pour AWS IoT signer le certificat racine (`*.pem.crt`).
+ `sagemaker_edge_provider_aws_cert_pk_file`: chemin absolu vers la clé AWS IoT privée. (`*.pem.key`).
+ `sagemaker_edge_provider_aws_iot_cred_endpoint`: le point de terminaison AWS IoT des informations d'identification (*identifier*.iot. *region*.amazonaws.com). Ce point de terminaison est utilisé pour la validation des informations d'identification. Pour plus d’informations, consultez [Connexion d’appareils à AWS IoT](https://docs.aws.amazon.com/iot/latest/developerguide/iot-connect-devices.html).
+ `sagemaker_edge_provider_provider` : indique l'implémentation de l'interface fournisseur utilisée. L'interface fournisseur communique avec les services réseau finaux pour les chargements, les pulsations et la validation de l'enregistrement. La valeur par défaut est `"Aws"`. Nous autorisons des implémentations personnalisées de l'interface fournisseur. Peut être défini sur `None` pour aucun fournisseur ou sur `Custom` pour une implémentation personnalisée avec le chemin d'objet partagé approprié fourni.
+ `sagemaker_edge_provider_provider_path` : fournit le chemin d'accès absolu à l'objet partagé d'implémentation du fournisseur (fichier .so ou .dll). Le fichier .dll ou .so du fournisseur `"Aws"` est fourni avec la version de l'agent. Ce champ est obligatoire.
+ `sagemaker_edge_provider_s3_bucket_name` : le nom de votre compartiment Amazon S3 (pas l'URI du compartiment Amazon S3). Le nom du compartiment doit contenir une chaîne `sagemaker`.
+ `sagemaker_edge_log_verbose` (booléen) : facultatif. Cela définit le journal de débogage. Sélectionnez `True` ou `False`.
+ `sagemaker_edge_telemetry_libsystemd_path` : pour Linux uniquement, `systemd` implémente la métrique du compteur d'incidents de l'agent. Définissez le chemin absolu de libsystemd pour activer la métrique du compteur d'incidents. Vous pouvez trouver le chemin par défaut de libsystemd en exécutant `whereis libsystemd` dans le terminal de l'appareil.
+ `sagemaker_edge_core_capture_data_destination` : la destination pour le téléchargement des données de capture. Choisissez `"Cloud"` ou `"Disk"`. La valeur par défaut est définie sur `"Disk"`. Lui attribuer la valeur `"Disk"` entraîne l'écriture des données du ou des tenseurs d'entrée et sortie et des données auxiliaires dans le système de fichiers local à l'emplacement de votre choix. Lors de l'écriture dans `"Cloud"`, utilisez le nom de compartiment Amazon S3 fourni dans la configuration `sagemaker_edge_provider_s3_bucket_name`.
+ `sagemaker_edge_core_capture_data_disk_path` : définissez le chemin absolu dans le système de fichiers local, dans lequel les fichiers de données de capture sont écrits quand `"Disk"` est la destination. Ce champ n'est pas utilisé lorsque `"Cloud"` est spécifié comme destination.
+ `sagemaker_edge_core_folder_prefix` : préfixe parent dans Amazon S3 où les données capturées sont stockées lorsque vous spécifiez `"Cloud"` comme destination des données de capture (`sagemaker_edge_core_capture_data_disk_path)`). Les données capturées sont stockées dans un sous-dossier sous `sagemaker_edge_core_capture_data_disk_path` si `"Disk"` est défini comme destination des données.
+ `sagemaker_edge_core_capture_data_buffer_size` (valeur entière) : taille du tampon circulaire des données de capture. Cela indique le nombre maximal de demandes stockées dans la mémoire tampon.
+ `sagemaker_edge_core_capture_data_batch_size` (valeur entière) : taille du lot de données de capture. Cela indique la taille d'un lot de demandes traitées à partir de la mémoire tampon. Elle doit être inférieure ou égale à `sagemaker_edge_core_capture_data_buffer_size`. La moitié de la taille du tampon au maximum est recommandé pour la taille du lot.
+ `sagemaker_edge_core_capture_data_push_period_seconds` (valeur entière) : période de transmission des données de capture, en secondes. Un lot de demandes dans la mémoire tampon est traité lorsqu'il y a des demandes de taille de lot dans la mémoire tampon, ou lorsque cette période se termine (selon la première éventualité). Cette configuration définit cette période.
+ `sagemaker_edge_core_capture_data_base64_embed_limit` : la limite de téléchargement des données de capture, en octets. Valeur d'entier
Votre fichier de configuration doit ressembler à l'exemple suivant (avec vos valeurs spécifiques indiquées). Cet exemple utilise le AWS fournisseur par défaut (`"Aws"`) et ne spécifie pas de téléchargement périodique.
```
{
"sagemaker_edge_core_device_name": "device-name",
"sagemaker_edge_core_device_fleet_name": "fleet-name",
"sagemaker_edge_core_region": "region",
"sagemaker_edge_core_root_certs_path": "",
"sagemaker_edge_provider_provider": "Aws",
"sagemaker_edge_provider_provider_path" : "/path/to/libprovider_aws.so",
"sagemaker_edge_provider_aws_ca_cert_file": "/AmazonRootCA1.pem",
"sagemaker_edge_provider_aws_cert_file": "/device.pem.crt",
"sagemaker_edge_provider_aws_cert_pk_file": "/private.pem.key",
"sagemaker_edge_provider_aws_iot_cred_endpoint": "https://",
"sagemaker_edge_core_capture_data_destination": "Cloud",
"sagemaker_edge_provider_s3_bucket_name": "sagemaker-bucket-name",
"sagemaker_edge_core_folder_prefix": "Amazon S3 folder prefix",
"sagemaker_edge_core_capture_data_buffer_size": 30,
"sagemaker_edge_core_capture_data_batch_size": 10,
"sagemaker_edge_core_capture_data_push_period_seconds": 4000,
"sagemaker_edge_core_capture_data_base64_embed_limit": 2,
"sagemaker_edge_log_verbose": false
}
```
L'artefact de version inclut un fichier binaire exécutable appelé `sagemaker_edge_agent_binary` dans le répertoire `/bin`. Pour exécuter le fichier binaire, utilisez le fanion `-a` pour créer un descripteur de fichier socket (.sock) dans un répertoire de votre choix, et spécifiez le chemin d'accès du fichier de configuration JSON de l'agent que vous avez créé avec le fanion `-c`.
```
./sagemaker_edge_agent_binary -a -c
```
L'exemple suivant montre l'extrait de code avec un répertoire et un chemin de fichier spécifiés :
```
./sagemaker_edge_agent_binary -a /tmp/sagemaker_edge_agent_example.sock -c sagemaker_edge_config.json
```
Dans cet exemple, un descripteur de fichier socket nommé `sagemaker_edge_agent_example.sock` est créé dans le répertoire `/tmp` et pointe vers un fichier de configuration situé dans le même répertoire de travail que l'agent appelé `sagemaker_edge_config.json`.
# Déploiement du package Model et de l'agent Edge Manager avec AWS IoT Greengrass
SageMaker Edge Manager intègre AWS IoT Greengrass la version 2 pour simplifier l'accès, la maintenance et le déploiement de l'agent et du modèle Edge Manager sur vos appareils. Sans la AWS IoT Greengrass version V2, la configuration de vos appareils et de vos flottes pour utiliser SageMaker Edge Manager vous oblige à copier manuellement l'agent Edge Manager depuis un compartiment de version Amazon S3. Vous utilisez l'agent pour réaliser des prédictions avec des modèles chargés sur vos dispositifs périphériques. Avec l'intégration de la AWS IoT Greengrass V2 et de l' SageMaker Edge Manager, vous pouvez utiliser les composants AWS IoT Greengrass V2. Les composants sont des modules logiciels prédéfinis qui peuvent connecter vos appareils périphériques à des AWS services ou à des services tiers via AWS IoT Greengrass.
Vous devez installer le logiciel AWS IoT Greengrass Core sur votre ou vos appareils si vous souhaitez utiliser la AWS IoT Greengrass version 2 pour déployer l'agent Edge Manager et votre modèle. Pour plus d'informations sur les exigences relatives aux appareils et sur la façon de configurer vos appareils, consultez la section [Configuration des appareils AWS IoT Greengrass principaux](https://docs.aws.amazon.com/greengrass/v2/developerguide/setting-up.html) dans la AWS IoT Greengrass documentation.
Vous utilisez les trois composants suivants pour déployer l'agent Edge Manager :
+ *Un composant public prédéfini* : SageMaker AI gère le composant public Edge Manager.
+ *Un composant privé généré automatiquement* : le composant privé est généré automatiquement lorsque vous empaquetez votre modèle de machine learning avec l'API [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEdgePackagingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEdgePackagingJob.html) et que vous spécifiez `GreengrassV2Component` dans le champ d'API Edge Manager `PresetDeploymentType`.
+ *Un composant personnalisé* : il s'agit de l'application d'inférence qui est chargée du prétraitement et des inférences sur votre appareil. Vous devez créer ce composant. Consultez la documentation SageMaker Edge Manager ou [Créer des AWS IoT Greengrass composants personnalisés](https://docs.aws.amazon.com/greengrass/v2/developerguide/create-components.html) dans la AWS IoT Greengrass documentation pour plus d'informations sur la création de composants personnalisés. [Créer un composant personnalisé Hello World](edge-greengrass-custom-component.md#edge-greengrass-create-custom-component-how)
# Conditions préalables pour déployer l’agent Edge Manager
SageMaker Edge Manager utilise la AWS IoT Greengrass version V2 pour simplifier le déploiement de l'agent Edge Manager, de vos modèles d'apprentissage automatique et de votre application d'inférence sur vos appareils à l'aide de composants. Pour faciliter la gestion de vos rôles AWS IAM, Edge Manager vous permet de réutiliser votre alias de AWS IoT rôle existant. Si vous n'en avez pas, Edge Manager génère un alias de rôle dans le cadre de la tâche d'empaquetage Edge Manager. Il n'est plus nécessaire d'associer à votre rôle un alias de AWS IoT rôle généré à partir de la tâche d'empaquetage d' SageMaker Edge Manager.
Avant de commencer, vous devez remplir les conditions préalables suivantes :
1. Installez le logiciel AWS IoT Greengrass Core. Pour des informations détaillées, voir [Installer le logiciel AWS IoT Greengrass Core](https://docs.aws.amazon.com/greengrass/v2/developerguide/getting-started.html#install-greengrass-v2).
1. Configurez la AWS IoT Greengrass V2. Pour plus d'informations, voir [Installer le logiciel AWS IoT Greengrass Core avec provisionnement manuel des ressources](https://docs.aws.amazon.com/greengrass/v2/developerguide/manual-installation.html).
**Note**
Assurez-vous que le nom de l' AWS IoT objet est entièrement en minuscules et qu'il ne contient pas de caractères sauf (éventuellement) des tirets (). `‐`
Le rôle IAM doit commencer par `SageMaker*`.
1. Associez l'autorisation et la politique en ligne suivantes au rôle IAM créé lors de la configuration de la AWS IoT Greengrass version 2.
+ Accédez à la console IAM. [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)
+ Recherchez le rôle que vous avez créé en saisissant son nom dans le champ **Search (Recherche)**.
+ Choisissez votre rôle.
+ Ensuite, choisissez **Attach Policies (Attacher des politiques)**.
+ Recherchez **AmazonSageMakerEdgeDeviceFleetPolicy**.
+ Sélectionnez **AmazonSageMakerFullAccess**(il s'agit d'une étape facultative qui vous permet de réutiliser plus facilement ce rôle IAM dans la compilation et le packaging des modèles).
+ Ajoutez les autorisations requises à la politique d'autorisation d'un rôle. N'associez pas de politiques intégrées aux utilisateurs IAM.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Sid":"GreengrassComponentAccess",
"Effect":"Allow",
"Action":[
"greengrass:CreateComponentVersion",
"greengrass:DescribeComponent"
],
"Resource":"*"
}
]
}
```
------
+ Choisissez **Attach policy** (Attacher la politique).
+ Choisissez **Trust Relationships** (Relations d'approbation).
+ Choisissez **Modifier la relation d’approbation**.
+ Remplacez le contenu par défaut par ce qui suit.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "credentials.iot.amazonaws.com"
},
"Action": "sts:AssumeRole"
},
{
"Effect": "Allow",
"Principal": {
"Service": "sagemaker.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
1. Créer une flotte de dispositifs Edge Manager. Pour plus d’informations sur la création d’une flotte, consultez [Configuration des appareils et des flottes dans SageMaker Edge Manager](edge-device-fleet.md).
1. Enregistrez votre appareil sous le même nom que celui que vous avez AWS IoT créé lors de la configuration de la AWS IoT Greengrass V2.
1. Créez au moins un AWS IoT Greengrass composant privé personnalisé. Ce composant est l'application qui exécute l'inférence sur le dispositif. Pour de plus amples informations, consultez [Créer un composant personnalisé Hello World](edge-greengrass-custom-component.md#edge-greengrass-create-custom-component-how).
**Note**
L' SageMaker Edge Manager et AWS IoT Greengrass l'intégration ne fonctionnent que pour la AWS IoT Greengrass version 2.
Le nom de votre AWS IoT objet et le nom de votre appareil Edge Manager doivent être identiques.
SageMaker Edge Manager ne charge pas les AWS IoT certificats locaux et n'appelle pas directement le point de terminaison du fournisseur AWS IoT d'informations d'identification. SageMaker Edge Manager utilise plutôt la AWS IoT Greengrass version v2 TokenExchangeService et récupère une information d'identification temporaire depuis un point de terminaison TES.
# Création des composants de la AWS IoT Greengrass V2
AWS IoT Greengrass utilise des *composants*, un module logiciel déployé et exécuté sur un périphérique AWS IoT Greengrass principal. Vous avez besoin (au moins) de trois composants :
1. * AWS IoT Greengrass Composant public de l'agent Edge Manager* qui déploie le binaire de l'agent Edge Manager.
1. *Composant de modèle* généré automatiquement lorsque vous empaquetez votre modèle d'apprentissage automatique avec l' AWS SDK pour Python (Boto3) API ou avec la console SageMaker AI. Pour plus d'informations, consultez [Création d'un composant généré automatiquement](#edge-greengrass-autogenerate-component-how).
1. *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 plus d'informations sur la création d'un composant personnalisé, voir [Création d'un composant généré automatiquement](#edge-greengrass-autogenerate-component-how) ou [Créer des AWS IoT Greengrass composants personnalisés](https://docs.aws.amazon.com/greengrass/v2/developerguide/create-components.html).
## Création d'un composant généré automatiquement
Générez le composant du modèle avec l'[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEdgePackagingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEdgePackagingJob.html)API et spécifiez le champ API `GreengrassV2Component` de la tâche d'empaquetage SageMaker Edge Manager`PresetDeploymentType`. Lorsque vous appelez l'`CreateEdgePackagingJob`API, Edge Manager utilise votre modèle compilé par SageMaker AI 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 AWS IoT console. [https://console.aws.amazon.com/iot/](https://console.aws.amazon.com/greengrass/) Sélectionnez **Greengrass**, puis **Core**. La page contient une liste des AWS IoT Greengrass principaux appareils 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 spécifier à Edge Manager de créer un composant AWS IoT Greengrass V2 avec l'`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=)
# Replace with your IAM Role ARN
sagemaker_role_arn = "arn:aws:iam:::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\"}"
}
)
```
Vous pouvez également créer le composant généré automatiquement avec la console SageMaker AI. Suivez les étapes 1 à 6 dans [Package d'un modèle (Amazon SageMaker AI Console)](edge-packaging-job-console.md).
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)**.
1. Spécifiez le nom du composant dans le champ **Component name (Nom du composant)**.
1. 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.
1. Sélectionnez **Soumettre**.
## 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](https://grpc.io/). 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.
1. É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 = ''
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()
```
Ensure `model_path` pointe vers le nom du AWS IoT Greengrass composant contenant le modèle si vous utilisez le même exemple de code client.
Vous pouvez créer votre composant Hello World AWS IoT Greengrass V2 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 de 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:
- URI:
- URI:
```
Pour obtenir des informations détaillées sur la création d'une recette Hello World, consultez la section [Création de votre premier composant](https://docs.aws.amazon.com/greengrass/v2/developerguide/getting-started.html#create-first-component) dans la AWS IoT Greengrass documentation.
# Déploiement des composants sur votre appareil
Déployez vos composants avec la AWS IoT console ou avec le AWS CLI.
## Pour déployer vos composants (console)
Déployez vos AWS IoT Greengrass composants à l'aide de la AWS IoT console.
1. Dans le menu de [https://console.aws.amazon.com/iot/](https://console.aws.amazon.com/greengrass/)navigation de la AWS IoT Greengrass console, sélectionnez **Déploiements.**
1. Sur la page **Components (Composants)**, sous l'onglet **Public components (Composants publics)**, choisissez `aws.greengrass.SageMakerEdgeManager`.
1. Sur la page `aws.greengrass.SageMakerEdgeManager`, choisissez **Deploy (Déployer)**.
1. À partir de `Add to deployment`, choisissez l'une des options suivantes :
1. Pour fusionner ce composant avec un déploiement existant sur votre dispositif cible, choisissez **Add to existing deployment (Ajouter à un déploiement existant)**, puis sélectionnez le déploiement à réviser.
1. Pour créer un nouveau déploiement sur votre dispositif cible, choisissez **Create new deployment (Créer un déploiement)**. S'il existe un déploiement sur votre dispositif et que vous choisissez cette étape, le déploiement existant sera remplacé.
1. Sur la page **Specify target (Spécifier une cible)**, procédez comme suit :
1. Sous **Deployment information (Informations sur le déploiement)**, saisissez ou modifiez le nom convivial de votre déploiement.
1. Sous **Deployment targets (Cibles de déploiement)**, sélectionnez une cible pour votre déploiement, puis choisissez **Next (Suivant)**. Vous ne pouvez pas modifier la cible de déploiement si vous révisez un déploiement existant.
1. Sur la page **Select components (Sélectionner des composants)**, sous **My components (Mes composants)**, choisissez :
+ com. **
+ `aws.greengrass.SageMakerEdgeManager`
+ SagemakerEdgeManager.**
1. Sur la page **Configurer les composants**, choisissez **com.greengrass. SageMakerEdgeManager**, puis procédez comme suit.
1. Choisissez **Configure component (Configurer un composant)**.
1. Sous **Configuration update (Mise à jour de la configuration)**, dans **Configuration to merge (Configuration à fusionner)**, saisissez la configuration suivante.
```
{
"DeviceFleetName": "device-fleet-name",
"BucketName": "bucket-name"
}
```
Remplacez *`device-fleet-name`* par le nom de la flotte de dispositifs périphériques que vous avez créée et remplacez *`bucket-name`* par le nom du compartiment Amazon S3 qui est associé à votre flotte de dispositifs.
1. Choisissez **Confirm (Confirmer)**, puis **Next (Suivant)**.
1. Sur la page **Configure advanced settings (Configurer les paramètres avancés)**, conservez les paramètres de configuration par défaut et choisissez **Next (Suivant)**.
1. Sur la page **Review (Révision)**, choisissez **Deploy (Déployer)**.
## Pour déployer vos composants (AWS CLI)
1. Créez un ` deployment.json` fichier pour définir la configuration de déploiement de vos composants SageMaker Edge Manager. Ce fichier doit ressembler à l'exemple suivant.
```
{
"targetArn":"targetArn",
"components": {
"aws.greengrass.SageMakerEdgeManager": {
"componentVersion": 1.0.0,
"configurationUpdate": {
"merge": {
"DeviceFleetName": "device-fleet-name",
"BucketName": "bucket-name"
}
}
},
"com.greengrass.SageMakerEdgeManager.ImageClassification": {
"componentVersion": 1.0.0,
"configurationUpdate": {
}
},
"com.greengrass.SageMakerEdgeManager.ImageClassification.Model": {
"componentVersion": 1.0.0,
"configurationUpdate": {
}
},
}
}
```
+ Dans le champ `targetArn`, remplacez *`targetArn`* par l'Amazon Resource Name (ARN) de l'objet ou du groupe d'objets à cibler pour le déploiement, au format suivant :
+ Objet : `arn:aws:iot:region:account-id:thing/thingName`
+ Groupe d'objets : `arn:aws:iot:region:account-id:thinggroup/thingGroupName`
+ Dans le champ `merge`, remplacez *`device-fleet-name`* par le nom de la flotte d'appareils périphériques que vous avez créée et remplacez *`bucket-name`* par le nom du compartiment Amazon S3 qui est associé à votre flotte d'appareils.
+ Remplacez les versions de composant de chaque composant par la dernière version disponible.
1. Exécutez la commande suivante pour déployer les composants sur le périphérique :
```
aws greengrassv2 create-deployment \
--cli-input-json file://path/to/deployment.json
```
L'exécution du déploiement peut prendre plusieurs minutes. À l'étape suivante, vérifiez le journal des composants pour vous assurer que le déploiement s'est terminé avec succès et afficher les résultats des inférences.
Pour plus d'informations sur le déploiement de composants sur des appareils individuels ou des groupes d'appareils, voir [Déployer AWS IoT Greengrass des composants sur des appareils](https://docs.aws.amazon.com/greengrass/v2/developerguide/manage-deployments.html).
# Déployez le Package du modèle directement avec l'API de déploiement d' SageMaker Edge Manager
SageMaker Edge Manager fournit une API de déploiement que vous pouvez utiliser pour déployer des modèles sur des appareils cibles sans AWS IoT Greengrass. Elle est utile lorsque vous souhaitez mettre à jour des modèles indépendamment des mises à jour du microprogramme ou des mécanismes de déploiement d'applications. Vous pouvez utiliser l'API pour intégrer vos déploiements périphériques dans un CI/CD flux de travail afin de déployer automatiquement les modèles une fois que vous avez validé la précision de votre modèle. L'API propose également des options pratiques de restauration et de déploiement par étapes qui vous permettent de vous assurer que les modèles fonctionnent correctement dans un environnement particulier avant un déploiement plus large.
Pour utiliser l'API de déploiement Edge Manager, commencez par compiler et empaqueter votre modèle. Pour obtenir des informations sur la compilation et l'empaquetage de votre modèle, consultez [Préparation de votre modèle pour le déploiement](edge-getting-started-step2.md). Les sections suivantes de ce guide montrent comment créer des déploiements Edge à l'aide de l' SageMaker API, après avoir compilé et empaqueté vos modèles.
**Topics**
+ [Création d'un plan de déploiement en périphérie](#create-edge-deployment-plan)
+ [Lancement du déploiement en périphérie](#start-edge-deployment-stage)
+ [Vérification du statut du déploiement](#describe-edge-deployment-status)
## Création d'un plan de déploiement en périphérie
Vous pouvez créer un plan de déploiement en périphérie à l'aide de l'API [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEdgeDeploymentPlan.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEdgeDeploymentPlan.html). Ce plan de déploiement peut comporter plusieurs phases. Vous pouvez configurer chaque phase pour réaliser le déploiement sur un sous-ensemble d'appareils périphériques (par pourcentage ou par nom d'appareil). Vous pouvez également configurer la manière de gérer les échecs de déploiement dans chaque phase.
L'extrait de code suivant montre comment créer un plan de déploiement en périphérie comportant 1 phase pour déployer un modèle compilé et empaqueté sur 2 appareils périphériques spécifiques :
```
import boto3
client = boto3.client("sagemaker")
client.create_edge_deployment_plan(
EdgeDeploymentPlanName="edge-deployment-plan-name",
DeviceFleetName="device-fleet-name",
ModelConfigs=[
{
"EdgePackagingJobName": "edge-packaging-job-name",
"ModelHandle": "model-handle"
}
],
Stages=[
{
"StageName": "stage-name",
"DeviceSelectionConfig": {
"DeviceSubsetType": "SELECTION",
"DeviceNames": ["device-name-1", "device-name-2"]
},
"DeploymentConfig": {
"FailureHandlingPolicy": "ROLLBACK_ON_FAILURE"
}
}
]
)
```
Au lieu d'appareils spécifiques, si vous souhaitez déployer sur un pourcentage des appareils de votre flotte, définissez la valeur de `DeviceSubsetType` sur `"PERCENTAGE"` et remplacez `"DeviceNames": ["device-name-1", "device-name-2"]` par `"Percentage": desired-percentage` dans l'exemple ci-dessus.
Les étapes peuvent être ajoutées une fois le plan de déploiement créé avec l'[CreateEdgeDeploymentStage](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEdgeDeploymentStage.html)API, au cas où vous souhaiteriez commencer à déployer de nouvelles étapes après avoir validé le succès de votre déploiement de test. Pour plus d'informations sur les étapes de déploiement, consultez [DeploymentStage.](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeploymentStage.html)
## Lancement du déploiement en périphérie
Après avoir créé le plan de déploiement et les phases de déploiement, vous pouvez commencer le déploiement avec l'API [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_StartEdgeDeploymentStage.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_StartEdgeDeploymentStage.html).
```
client.start_edge_deployment_stage(
EdgeDeploymentPlanName="edge-deployment-plan-name",
StageName="stage-name"
)
```
## Vérification du statut du déploiement
Vous pouvez vérifier l'état du déploiement Edge à l'aide de l'[DescribeEdgeDeploymentPlan](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEdgeDeploymentPlan.html)API.
```
client.describe_edge_deployment_plan(
EdgeDeploymentPlanName="edge-deployment-plan-name"
)
```