Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà. # L'agente Edge Manager L'agente Edge Manager è un motore di inferenza per i dispositivi edge. Usa l'agente per fare previsioni con modelli caricati sui tuoi dispositivi edge. L'agente raccoglie anche i parametri dei modelli e acquisisce i dati a intervalli specifici. Dati di esempio vengono archiviati nel tuo bucket Amazon S3. Esistono due metodi per installare e distribuire l'agente Edge Manager sui dispositivi edge: 1. Scarica l'agente come file binario dal bucket di rilascio di Amazon S3. Per ulteriori informazioni, consulta [Scarica e configura manualmente l'agente Edge Manager](edge-device-fleet-manual.md). 1. Utilizza la console AWS IoT Greengrass V2 o il comando per la AWS CLI distribuzione. `aws.greengrass.SageMakerEdgeManager` Per informazioni, consulta [Crea i componenti V2 AWS IoT Greengrass](edge-greengrass-custom-component.md). # Scarica e configura manualmente l'agente Edge Manager Scarica l'agente Edge Manager in base al sistema operativo, all'architettura e alla Regione AWS . L'agente viene aggiornato periodicamente, quindi hai la possibilità di scegliere il tuo agente in base alle date e alle versioni di rilascio. Una volta che hai l'agente, crea un file di configurazione JSON. Specifica il nome dell'oggetto IoT del dispositivo, il nome del parco, le credenziali del dispositivo e altre coppie chiave-valore. Vedi [Esecuzione dell'agente Edge Manager](#edge-device-fleet-running-agent) per l'intero elenco delle chiavi che devi specificare nel file di configurazione. È possibile eseguire l'agente come file binario eseguibile o collegarsi ad esso come oggetto condiviso dinamico (DSO). ## Come funziona l'agente L'agente viene eseguito sulla CPU dei tuoi dispositivi. L'agente esegue l'inferenza sul framework e sull'hardware del dispositivo di destinazione specificato durante il processo di compilazione. Ad esempio, se hai compilato il modello per Jetson Nano, l'agente supporta la GPU nel [Deep Learning Runtime](https://github.com/neo-ai/neo-ai-dlr) (DLR) fornito. L'agente viene rilasciato in formato binario per i sistemi operativi supportati. Verifica che il tuo sistema operativo sia supportato e soddisfi i requisiti minimi del sistema operativo indicati nella tabella seguente: ------ #### [ Linux ] **Versione:** Ubuntu 18.04 **Formati binari supportati:** x86-64 bit (binario ELF) e ARMv8 64 bit (binario ELF) ------ #### [ Windows ] **Versione:** Windows 10 versione 1909 **Formati binari supportati:** x86-32 bit (DLL) e x86-64 bit (DLL) ------ ## Installazione dell'agente Edge Manager Per utilizzare l'agente Edge Manager, è necessario innanzitutto ottenere gli artefatti di rilascio e un certificato root. Gli artefatti di rilascio sono archiviati in un bucket Amazon S3 presente nella Regione `us-west-2`. Per scaricare gli artefatti, specifica il tuo sistema operativo (``) e la ``. In base al sistema operativo in uso, sostituisci `` con uno dei seguenti: | Windows 32-bit | Windows 64-bit | Linux x86-64 | Linux ARMv8 | | --- | --- | --- | --- | | windows-x86 | windows-x64 | Linux-x64 | linux-armv8 | `VERSION` è suddiviso in tre componenti: `.-` dove: + ``: la versione del rilascio La versione del rilascio è attualmente impostata su `1`. + ``: Il timestamp del rilascio degli artefatti. + ``: L'ID commit del repository da cui viene creato il rilascio. È necessario fornire il `` e il timestamp nel formato `YYYY-MM-DD`. Ti suggeriamo di utilizzare il timestamp di rilascio dell'ultimo artefatto. Esegui quanto segue nella riga di comando per ottenere il timestamp più recente. Sostituisci `` con il tuo sistema operativo: ``` aws s3 ls s3://sagemaker-edge-release-store-us-west-2-/Releases/ | sort -r ``` Ad esempio, se disponi di un sistema operativo Windows a 32 bit, esegui: ``` aws s3 ls s3://sagemaker-edge-release-store-us-west-2-windows-x86/Releases/ | sort -r ``` Viene restituito: ``` 2020-12-01 23:33:36 0 PRE 1.20201218.81f481f/ PRE 1.20201207.02d0e97/ ``` L'output restituito in questo esempio mostra due artefatti di rilascio. Il file artifact della prima release rileva che la versione di rilascio ha una versione di release principale di`1`, un timestamp di `20201218` (in YYYY-MM-DD formato) e un ID di commit `81f481f` SHA-7. **Nota** Il comando precedente presuppone che tu abbia configurato il AWS Command Line Interface. Per ulteriori informazioni su come configurare le impostazioni con cui gli AWS CLI utenti interagiscono AWS, consulta [Configurazione della AWS CLI](https://docs.aws.amazon.com//cli/latest/userguide/cli-chap-configure.html). In base al sistema operativo in uso, utilizza i seguenti comandi per installare gli artefatti: ------ #### [ 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 . ``` ------ È inoltre necessario scaricare un certificato root. Questo certificato convalida gli artefatti del modello firmati da AWS prima di caricarli sui dispositivi periferici. Sostituisci `` corrispondente alla tua piattaforma dall'elenco dei sistemi operativi supportati e sostituisci `` con la tua Regione AWS . ``` aws s3 cp s3://sagemaker-edge-release-store-us-west-2-/Certificates//.pem . ``` ## Esecuzione dell'agente Edge Manager Puoi eseguire l'agente SageMaker AI Edge Manager come processo autonomo sotto forma di un file binario eseguibile ELF (Executable and Linkable Format) oppure puoi collegarlo come oggetto condiviso dinamico (.dll). Linux supporta l'esecuzione come binario eseguibile autonomo ed è la modalità preferita. Windows supporta l'esecuzione come oggetto condiviso (.dll). Su Linux, ti consigliamo di eseguire il file binario tramite un servizio che fa parte del tuo sistema di inizializzazione (`init`). Se desideri eseguire il file binario direttamente, puoi farlo in un terminale come mostrato nell'esempio seguente. Se disponi di un sistema operativo moderno, non sono necessarie altre installazioni prima di eseguire l'agente, poiché tutti i requisiti sono incorporati staticamente nell'eseguibile. Ciò offre la flessibilità necessaria per eseguire l'agente sul terminale, come servizio o all'interno di un container. Per eseguire l'agente, crea innanzitutto un file di configurazione JSON. Specifica le seguenti coppie chiave-valore: + `sagemaker_edge_core_device_name`: il nome del dispositivo. Questo nome del dispositivo deve essere registrato insieme al parco dispositivi nella console SageMaker Edge Manager. + `sagemaker_edge_core_device_fleet_name`: il nome del parco dispositivi a cui appartiene il dispositivo. + `sagemaker_edge_core_region`: la AWS regione associata al dispositivo, alla flotta e ai bucket Amazon S3. Corrisponde alla Regione in cui è registrato il dispositivo e in cui viene creato il bucket Amazon S3 (dovrebbero corrispondere). I modelli stessi possono essere compilati con SageMaker Neo in una regione diversa, questa configurazione non è correlata alla regione di compilazione del modello. + `sagemaker_edge_core_root_certs_path`: Il percorso assoluto della cartella verso i certificati root. Viene utilizzato per convalidare il dispositivo con l'account pertinente AWS . + `sagemaker_edge_provider_aws_ca_cert_file`: il percorso assoluto verso il certificato Amazon Root CA (AmazonRootCA1.pem). Viene utilizzato per convalidare il dispositivo con l'account pertinente. AWS `AmazonCA`è un certificato di proprietà di AWS. + `sagemaker_edge_provider_aws_cert_file`: Il percorso assoluto per AWS IoT firmare il certificato radice (`*.pem.crt`). + `sagemaker_edge_provider_aws_cert_pk_file`: Il percorso assoluto della chiave AWS IoT privata. (`*.pem.key`). + `sagemaker_edge_provider_aws_iot_cred_endpoint`: L'endpoint AWS IoT delle credenziali (*identifier*.iot. *region*.amazonaws.com). Questo endpoint viene utilizzato per la convalida delle credenziali. Per ulteriori informazioni vedere [Collegamento dei dispositivi a AWS IoT](https://docs.aws.amazon.com/iot/latest/developerguide/iot-connect-devices.html). + `sagemaker_edge_provider_provider`: indica l'implementazione dell'interfaccia del provider utilizzata. L'interfaccia del provider comunica con i servizi di rete finali per i caricamenti, gli heartbeat e la convalida della registrazione. Per impostazione predefinita, il valore è `"Aws"`. Consentiamo implementazioni personalizzate dell'interfaccia del provider. Può essere impostato su `None` per nessun provider o `Custom` per un'implementazione personalizzata con il relativo percorso dell'oggetto condiviso fornito. + `sagemaker_edge_provider_provider_path`: fornisce il percorso assoluto all'oggetto condiviso di implementazione del provider. (file .so o .dll). Il file .dll o. so del provider `"Aws"` viene fornito con la versione dell'agente. Questo campo è obbligatorio. + `sagemaker_edge_provider_s3_bucket_name`: il nome del bucket Amazon S3 (non l'URI del bucket Amazon S3). Il bucket deve contenere una stringa `sagemaker` all'interno del nome. + `sagemaker_edge_log_verbose` (booleano): Facoltativo. Questo imposta il registro di debug. Seleziona `True` o `False`. + `sagemaker_edge_telemetry_libsystemd_path`: solo per Linux, `systemd` implementa il parametro contatore degli arresti anomali dell'agente. Imposta il percorso assoluto di libsystemd per attivare il parametro contatore degli arresti anomali. È possibile trovare il percorso libsystemd predefinito eseguendolo `whereis libsystemd` nel terminale del dispositivo. + `sagemaker_edge_core_capture_data_destination`: la destinazione del caricamento dei dati di acquisizione. Scegliere `"Cloud"` o `"Disk"`. Il valore predefinito è impostato su `"Disk"`. Impostandolo su `"Disk"` scrivere i tensori di input e output e i dati ausiliari nel file system locale nella posizione preferita. Quando si scrive a `"Cloud"` utilizzare il nome del bucket Amazon S3 fornito nella configurazione `sagemaker_edge_provider_s3_bucket_name`. + `sagemaker_edge_core_capture_data_disk_path`: imposta il percorso assoluto nel file system locale, in cui vengono scritti i file di dati di acquisizione quando `"Disk"` è la destinazione. Questo campo non viene utilizzato quando `"Cloud"` è specificato come destinazione. + `sagemaker_edge_core_folder_prefix`: il prefisso principale in Amazon S3 in cui vengono archiviati i dati acquisiti quando si specifica `"Cloud"` come destinazione dei dati di acquisizione (`sagemaker_edge_core_capture_data_disk_path)`). I dati acquisiti vengono archiviati in una sottocartella sotto `sagemaker_edge_core_capture_data_disk_path` nel caso in cui `"Disk"` sia impostato come destinazione dei dati. + `sagemaker_edge_core_capture_data_buffer_size`(Valore intero): la dimensione circolare del buffer dei dati di acquisizione. Indica il numero massimo di richieste memorizzate nel buffer. + `sagemaker_edge_core_capture_data_batch_size` (Valore intero): la dimensione del batch di dati di acquisizione. Indica la dimensione di un batch di richieste gestite dal buffer. Questo valore deve essere minore di `sagemaker_edge_core_capture_data_buffer_size`. Per le dimensioni del batch, si consiglia di utilizzare al massimo la metà della dimensione del buffer. + `sagemaker_edge_core_capture_data_push_period_seconds` (Valore intero): il periodo di invio dei dati di acquisizione in secondi. Un batch di richieste nel buffer viene gestito quando nel buffer sono presenti richieste di dimensioni batch o quando questo periodo di tempo è completato (a seconda dell'evento che si verifica per primo). Questa configurazione imposta tale periodo di tempo. + `sagemaker_edge_core_capture_data_base64_embed_limit`: il limite per il caricamento dei dati di acquisizione in byte. Un valore intero. Il file di configurazione dovrebbe essere simile all'esempio seguente (con i valori specifici). Questo esempio utilizza il AWS provider predefinito (`"Aws"`) e non specifica un caricamento periodico. ``` { "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'elemento di rilascio include un eseguibile binario chiamato `sagemaker_edge_agent_binary` nella directory `/bin`. Per eseguire il file binario, utilizza il flag `-a` per creare un descrittore di file socket (.sock) in una directory di tua scelta e specifica il percorso del file di configurazione JSON dell'agente creato con il flag `-c`. ``` ./sagemaker_edge_agent_binary -a -c ``` L'esempio seguente mostra il frammento di codice con una directory e un percorso di file specificati: ``` ./sagemaker_edge_agent_binary -a /tmp/sagemaker_edge_agent_example.sock -c sagemaker_edge_config.json ``` In questo esempio, un descrittore di file socket denominato `sagemaker_edge_agent_example.sock` viene creato nella directory `/tmp` e punta a un file di configurazione che si trova nella stessa directory del processo dell'agente chiamato `sagemaker_edge_config.json`. # Implementazione di Model Package e Edge Manager Agent con AWS IoT Greengrass SageMaker Edge Manager integra la AWS IoT Greengrass versione 2 per semplificare l'accesso, la manutenzione e la distribuzione dell'agente e del modello Edge Manager sui dispositivi. Senza la AWS IoT Greengrass V2, la configurazione di dispositivi e flotte per l'utilizzo di SageMaker Edge Manager richiede la copia manuale dell'agente Edge Manager da un bucket di release di Amazon S3. Per fare previsioni con modelli caricati sui tuoi dispositivi edge utilizzi l'agente. Con l'integrazione tra AWS IoT Greengrass V2 ed SageMaker Edge Manager, puoi utilizzare i componenti V2. AWS IoT Greengrass I componenti sono moduli software predefiniti che possono connettere i dispositivi edge a AWS servizi o servizi di terze parti tramite. AWS IoT Greengrass È necessario installare il software AWS IoT Greengrass Core sui dispositivi se si desidera utilizzare la versione AWS IoT Greengrass 2 per distribuire l'agente Edge Manager e il modello. Per ulteriori informazioni sui requisiti dei dispositivi e su come configurare i dispositivi, vedere [Configurazione dei dispositivi AWS IoT Greengrass principali](https://docs.aws.amazon.com/greengrass/v2/developerguide/setting-up.html) nella AWS IoT Greengrass documentazione. Per distribuire l'agente Edge Manager si utilizzano i seguenti tre componenti: + *Un componente pubblico predefinito*: SageMaker AI mantiene il componente pubblico Edge Manager. + *Un componente privato generato automaticamente*: il componente privato viene generato automaticamente quando si impacchetta il modello di machine learning con l'API [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEdgePackagingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEdgePackagingJob.html) e si specifica `GreengrassV2Component` per il campo API Edge Manager `PresetDeploymentType`. + *Un componente personalizzato*: questa è l'applicazione di inferenza responsabile della preelaborazione e della creazione di inferenze sul dispositivo. Questo componente deve essere creato. Per ulteriori informazioni su come [creare AWS IoT Greengrass componenti personalizzati](https://docs.aws.amazon.com/greengrass/v2/developerguide/create-components.html), AWS IoT Greengrass consulta la documentazione di SageMaker Edge Manager o Crea componenti personalizzati nella documentazione. [Crea un componente personalizzato Hello World](edge-greengrass-custom-component.md#edge-greengrass-create-custom-component-how) # Prerequisiti completi per l’implementazione dell’agente Edge Manager SageMaker Edge Manager utilizza la AWS IoT Greengrass versione 2 per semplificare l'implementazione dell'agente Edge Manager, dei modelli di machine learning e dell'applicazione di inferenza sui dispositivi con l'uso di componenti. Per semplificare la gestione dei ruoli AWS IAM, Edge Manager consente di riutilizzare l'alias di ruolo esistente AWS IoT . Se non ne hai ancora uno, Edge Manager genera un alias ruolo come parte del processo di creazione pacchetti di Edge Manager. Non è più necessario associare al ruolo un alias di ruolo generato dal processo di packaging di SageMaker Edge Manager. AWS IoT Prima di iniziare, è necessario completare i seguenti prerequisiti: 1. Installa il software AWS IoT Greengrass Core. Per informazioni dettagliate, consulta [Installare il software AWS IoT Greengrass Core](https://docs.aws.amazon.com/greengrass/v2/developerguide/getting-started.html#install-greengrass-v2). 1. Configura AWS IoT Greengrass V2. Per ulteriori informazioni, consulta [Installazione del software AWS IoT Greengrass Core con provisioning manuale delle risorse](https://docs.aws.amazon.com/greengrass/v2/developerguide/manual-installation.html). **Nota** Assicurati che il nome dell' AWS IoT oggetto sia tutto minuscolo e non contenga caratteri tranne (facoltativamente) i trattini (). `‐` Il ruolo IAM deve iniziare con `SageMaker*` 1. Allega la seguente autorizzazione e la policy in linea al ruolo IAM creato durante la configurazione della V2. AWS IoT Greengrass + Vai alla console IAM. [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) + Cerca il ruolo creato digitando il nome del ruolo nel campo **Cerca**. + Scegli il tuo ruolo. + Quindi, scegli **Collega policy**. + Cercare **AmazonSageMakerEdgeDeviceFleetPolicy**. + Seleziona **AmazonSageMakerFullAccess**(si tratta di un passaggio facoltativo che semplifica il riutilizzo di questo ruolo IAM nella compilazione e nel packaging dei modelli). + Aggiungi le autorizzazioni necessarie alla policy di autorizzazione di un ruolo, non collegare agli utenti IAM le policy inline. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement":[ { "Sid":"GreengrassComponentAccess", "Effect":"Allow", "Action":[ "greengrass:CreateComponentVersion", "greengrass:DescribeComponent" ], "Resource":"*" } ] } ``` ------ + Scegli **Collega policy**. + Scegli **Relazione di attendibilità**. + Seleziona **Modifica relazione di attendibilità**. + Sostituisci il contenuto con il seguente: ------ #### [ 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. Crea un Edge Manager del parco dispositivi. Per informazioni su come creare i parchi, consulta [Configurazione per dispositivi e flotte in Edge Manager SageMaker](edge-device-fleet.md). 1. Registra il dispositivo con lo stesso nome del nome dell' AWS IoT oggetto creato durante la configurazione della AWS IoT Greengrass V2. 1. Crea almeno un AWS IoT Greengrass componente privato personalizzato. Questo componente è l'applicazione che esegue l'inferenza sul dispositivo. Per ulteriori informazioni, consulta [Crea un componente personalizzato Hello World](edge-greengrass-custom-component.md#edge-greengrass-create-custom-component-how) **Nota** L' SageMaker Edge Manager e AWS IoT Greengrass l'integrazione funzionano solo per la AWS IoT Greengrass versione 2. Il nome dell' AWS IoT oggetto e il nome del dispositivo Edge Manager devono coincidere. SageMaker Edge Manager non carica AWS IoT i certificati locali e chiama direttamente l'endpoint del provider di AWS IoT credenziali. SageMaker Edge Manager utilizza invece la versione AWS IoT Greengrass v2 TokenExchangeService e recupera una credenziale temporanea da un endpoint TES. # Crea i componenti V2 AWS IoT Greengrass AWS IoT Greengrass utilizza *components*, un modulo software che viene distribuito e eseguito su un dispositivo AWS IoT Greengrass principale. Sono necessari (almeno) tre componenti: 1. *Un AWS IoT Greengrass componente pubblico di Edge Manager Agent* che distribuisce l'agente binario di Edge Manager. 1. *Un componente del modello* che viene generato automaticamente quando si impacchetta il modello di machine learning con l' AWS SDK per Python (Boto3) API o con la console AI. SageMaker Per informazioni, consulta [Creare un componente generato automaticamente](#edge-greengrass-autogenerate-component-how). 1. *Un componente privato e personalizzato* per implementare l'applicazione client dell'agente Edge Manager ed eseguire qualsiasi preelaborazione e post-elaborazione dei risultati dell'inferenza. Per ulteriori informazioni su come creare un componente personalizzato, consulta [Creare un componente generato automaticamente](#edge-greengrass-autogenerate-component-how) la sezione [Creare](https://docs.aws.amazon.com/greengrass/v2/developerguide/create-components.html) componenti personalizzati. AWS IoT Greengrass ## Creare un componente generato automaticamente Genera il componente del modello con l'[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEdgePackagingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEdgePackagingJob.html)API e specifica `GreengrassV2Component` il campo API del processo di imballaggio di SageMaker Edge Manager`PresetDeploymentType`. Quando chiami l'`CreateEdgePackagingJob`API, Edge Manager prende il tuo modello compilato con SageMaker AI NEO in Amazon S3 e crea un componente del modello. Il componente del modello viene automaticamente archiviato nel tuo account. Puoi visualizzare qualsiasi componente accedendo alla console. AWS IoT [https://console.aws.amazon.com/iot/](https://console.aws.amazon.com/greengrass/) Seleziona **Greengrass**, quindi seleziona **Dispositivi core**. La pagina contiene un elenco dei dispositivi AWS IoT Greengrass principali associati al tuo account. Se il nome di un componente del modello non è specificato in `PresetDeploymentConfig`, il nome predefinito generato è costituito da `"SagemakerEdgeManager"` e dal nome del processo di creazione pacchetti dell'agente Edge Manager. L'esempio seguente mostra come specificare a Edge Manager di creare un componente AWS IoT Greengrass V2 con 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\"}" } ) ``` Puoi anche creare il componente generato automaticamente con la console AI. SageMaker Segui le fasi da 1 a 6 descritte in [Package a modello (Amazon SageMaker AI Console)](edge-packaging-job-console.md). Inserisci l'URI del bucket Amazon S3 in cui desideri memorizzare l'output del processo di creazione pacchetti e la chiave di crittografia opzionale. Completa quanto segue per creare il componente del modello: 1. Scegli **Implementazione preimpostata**. 1. Specifica il nome del componente nel campo **Nome del componente**. 1. Facoltativamente, fornisci una descrizione del componente, della versione del componente, del sistema operativo della piattaforma o dell'architettura della piattaforma rispettivamente per la **Descrizione del componente**, la **Versione del componente**, il **Sistema operativo della piattaforma** e l'**Architettura della piattaforma**. 1. Seleziona **Invia**. ## Crea un componente personalizzato Hello World Il componente dell'applicazione personalizzato viene utilizzato per eseguire inferenze sul dispositivo edge. Il componente è responsabile del caricamento dei modelli su SageMaker Edge Manager, della chiamata all'agente Edge Manager per l'inferenza e dello scaricamento del modello quando il componente viene spento. Prima di creare il componente, assicurati che l'agente e l'applicazione possano comunicare con Edge Manager. Per fare ciò, configura [gRPC](https://grpc.io/). L'agente Edge Manager utilizza i metodi definiti in Protobuf Buffers e nel server gRPC per stabilire la comunicazione con l'applicazione client sul dispositivo edge e sul cloud. Per usare gRPC, devi: 1. Creare uno stub gRPC utilizzando il file.proto fornito quando scarichi l'agente Edge Manager dal bucket di rilascio di Amazon S3. 1. Scrivere il codice client con la lingua che preferisci. Non è necessario definire il servizio in un file .proto. I file di servizio .proto sono inclusi nel file TAR compresso quando scarichi il file binario della versione dell'agente Edge Manager dal bucket di rilascio di Amazon S3. Installa gRPC e altri strumenti necessari sulla tua macchina host e crea gli stub gRPC `agent_pb2_grpc.py` e `agent_pb2.py` in Python. Assicurati di avere `agent.proto` nella tua directory locale. ``` %%bash pip install grpcio pip install grpcio-tools python3 -m grpc_tools.protoc --proto_path=. --python_out=. --grpc_python_out=. agent.proto ``` Il codice precedente genera le interfacce client e server gRPC dalla definizione del servizio .proto. In altre parole, crea il modello gRPC in Python. La directory API contiene la specifica Protobuf per comunicare con l'agente. Successivamente, usa l'API gRPC per scrivere un client e un server per il servizio (2). Lo script di esempio seguente `edge_manager_python_example.py` utilizza Python per caricare, elencare e scaricare un modello `yolov3` sul dispositivo edge. ``` 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() ``` Assicuratevi che `model_path` indichi il nome del AWS IoT Greengrass componente contenente il modello se utilizzate lo stesso esempio di codice client. Puoi creare il tuo componente Hello World AWS IoT Greengrass V2 dopo aver generato i tuoi stub gRPC e aver pronto il codice Hello World. A tale scopo: + Carica il tuo `edge_manager_python_example.py`, `agent_pb2_grpc.py` e `agent_pb2.py` nel tuo bucket Amazon S3 e annota il loro percorso Amazon S3. + Crea un componente privato nella console AWS IoT Greengrass V2 e definisci la ricetta per il tuo componente. Specifica l'URI di Amazon S3 per l'applicazione Hello World e lo stub gRPC nella seguente ricetta. ``` --- 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: ``` Per informazioni dettagliate sulla creazione di una ricetta Hello World, vedi [Creare il tuo primo componente](https://docs.aws.amazon.com/greengrass/v2/developerguide/getting-started.html#create-first-component) nella AWS IoT Greengrass documentazione. # Distribuire i componenti nel proprio dispositivo. Distribuisci i componenti con la AWS IoT console o con. AWS CLI ## Per distribuire i componenti (console) Implementa i tuoi AWS IoT Greengrass componenti con la AWS IoT console. 1. Nel menu di [https://console.aws.amazon.com/iot/](https://console.aws.amazon.com/greengrass/)navigazione della AWS IoT Greengrass console, scegli **Implementazioni**. 1. Nella pagina **Componenti**, nella scheda **Componenti pubblici**, scegli `aws.greengrass.SageMakerEdgeManager`. 1. Nella pagina `aws.greengrass.SageMakerEdgeManager`, scegli **(Distribuisci)**. 1. Da `Add to deployment`, scegli una delle seguenti opzioni: 1. Per unire questo componente a una distribuzione esistente sul dispositivo di destinazione, scegli **Aggiungi alla distribuzione esistente**, quindi seleziona la distribuzione che desideri modificare. 1. Per creare una nuova distribuzione sul dispositivo di destinazione, scegli **Crea nuova distribuzione**. Se hai un’implementazione esistente sul tuo dispositivo, la scelta di questa fase sostituisce l’implementazione esistente. 1. Nella pagina **Specifica destinazione**, procedi come segue: 1. In **Informazioni sulla distribuzione**, inserisci o modifica il nome descrittivo della distribuzione. 1. In **Destinazione della distribuzione**, seleziona una destinazione della distribuzione e scegli **Avanti**. Non è possibile modificare la destinazione della distribuzione se si sta revisionando una distribuzione esistente. 1. Nella pagina **Seleziona componenti**, in **I miei componenti**, scegli: + com. ** + `aws.greengrass.SageMakerEdgeManager` + SagemakerEdgeManager.** 1. Nella pagina **Configura componenti**, scegli **com.greengrass. SageMakerEdgeManager**ed esegui le seguenti operazioni. 1. Scegli **Configura componente**. 1. In **Aggiornamento della configurazione**, in **Configurazione da unire**, inserisci la seguente configurazione. ``` { "DeviceFleetName": "device-fleet-name", "BucketName": "bucket-name" } ``` Sostituisci *`device-fleet-name`* con il nome del parco dispositivi edge che hai creato e sostituisci *`bucket-name`* con il nome del bucket Amazon S3 associato al tuo parco dispositivi. 1. Seleziona **Conferma** e scegli **Avanti**. 1. Nella pagina **Configura impostazioni avanzate**, mantieni le impostazioni di configurazione predefinite e scegli **Avanti**. 1. Nella pagina **Review (Verifica)**, scegli **Deploy (Distribuisci)**. ## Per distribuire i componenti (AWS CLI) 1. Crea un ` deployment.json` file per definire la configurazione di distribuzione per i componenti di SageMaker Edge Manager. Questo file dovrebbe essere simile all'esempio seguente. ``` { "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": { } }, } } ``` + Nel campo `targetArn`, sostituisci *`targetArn`* con il nome della risorsa Amazon (ARN) dell'oggetto o del gruppo di oggetti a cui destinare la distribuzione, nel seguente formato: + Oggetto: `arn:aws:iot:region:account-id:thing/thingName` + Gruppo di oggetti: `arn:aws:iot:region:account-id:thinggroup/thingGroupName` + Nel campo `merge` sostituisci *`device-fleet-name`* con il nome del parco dispositivi edge che hai creato e sostituisci *`bucket-name`* con il nome del bucket Amazon S3 associato al tuo parco dispositivi. + Sostituisci le versioni dei componenti di ogni componente con l'ultima versione disponibile. 1. Eseguire comando seguente per distribuire i componenti sul dispositivo: ``` aws greengrassv2 create-deployment \ --cli-input-json file://path/to/deployment.json ``` La distribuzione può richiedere alcuni minuti. Nella fase successiva, controlla il registro dei componenti per verificare che l’implementazione sia stata completata correttamente e per visualizzare i risultati dell'inferenza. Per ulteriori informazioni sulla distribuzione dei componenti su singoli dispositivi o gruppi di dispositivi, consulta [Distribuire AWS IoT Greengrass i componenti](https://docs.aws.amazon.com/greengrass/v2/developerguide/manage-deployments.html) sui dispositivi. # Implementa il Model Package direttamente con l'API di distribuzione SageMaker Edge Manager SageMaker Edge Manager fornisce un'API di distribuzione che è possibile utilizzare per distribuire modelli su destinazioni di dispositivi senza. AWS IoT GreengrassÈ utile in situazioni in cui si desidera aggiornare i modelli indipendentemente dagli aggiornamenti del firmware o dai meccanismi di distribuzione delle applicazioni. È possibile utilizzare l'API per integrare le implementazioni edge in un CI/CD flusso di lavoro per distribuire automaticamente i modelli dopo aver convalidato la precisione del modello. L'API offre anche comode opzioni di rollback e un'implementazione graduale che consentono di garantire il corretto funzionamento dei modelli in un ambiente particolare prima di un'implementazione più ampia. Per utilizzare l'API di distribuzione di Edge Manager, per prima cosa, compila e creai il pacchetto del tuo modello. Per informazioni su come compilare e creare il pacchetto del tuo modello, consulta [Preparazione del modello per l’implementazione](edge-getting-started-step2.md). Le seguenti sezioni di questa guida mostrano come creare implementazioni edge utilizzando l' SageMaker API, dopo aver compilato e impacchettato i modelli. **Topics** + [Creare un piano di implementazione edge](#create-edge-deployment-plan) + [Avvia l'implementazione edge.](#start-edge-deployment-stage) + [Controllare lo stato dell'implementazione](#describe-edge-deployment-status) ## Creare un piano di implementazione edge Con l'API [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEdgeDeploymentPlan.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEdgeDeploymentPlan.html) è possibile creare un piano di implementazione edge. Il piano di implementazione può avere più fasi. È possibile configurare ogni fase per implementare la distribuzione su un sottoinsieme di dispositivi edge (in base alla percentuale o al nome del dispositivo). È inoltre possibile configurare la modalità di gestione degli errori di implementazione in ogni fase. Il seguente frammento di codice mostra come è possibile creare un piano di implementazione edge con 1 fase per distribuire un modello compilato e impacchettato su 2 dispositivi edge specifici: ``` 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" } } ] ) ``` Invece di dispositivi specifici, se desideri eseguire l'implementazione al modello su una percentuale di dispositivi del tuo parco dispositivi, imposta il valore `DeviceSubsetType` a `"PERCENTAGE"` e sostituisci `"DeviceNames": ["device-name-1", "device-name-2"]` con `"Percentage": desired-percentage` come illustrato nell'esempio precedente. Le fasi possono essere aggiunte dopo aver creato il piano di implementazione con l'[CreateEdgeDeploymentStage](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEdgeDeploymentStage.html)API, nel caso in cui si desideri iniziare a implementare nuove fasi dopo aver verificato il successo dell'implementazione del test. [Per ulteriori informazioni sulle fasi di distribuzione, consulta. DeploymentStage](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeploymentStage.html) ## Avvia l'implementazione edge. Dopo aver creato il piano e le fasi di implementazione, puoi iniziare la distribuzione con 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" ) ``` ## Controllare lo stato dell'implementazione Puoi controllare lo stato dell'implementazione edge con l'[DescribeEdgeDeploymentPlan](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEdgeDeploymentPlan.html)API. ``` client.describe_edge_deployment_plan( EdgeDeploymentPlanName="edge-deployment-plan-name" ) ```