As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá. # O agente do Edge Manager O agente do Edge Manager é um mecanismo de inferência para seus dispositivos de borda. Use o agente para fazer predições com modelos carregados em seus dispositivos de borda. O agente também coleta métricas do modelo e captura dados em intervalos específicos. Os dados de amostra são armazenados no bucket do Amazon S3. Há dois métodos para instalar e implantar o agente do Edge Manager em seus dispositivos de borda: 1. Faça o download do agente como um binário do bucket de lançamento do Amazon S3. Para obter mais informações, consulte [Baixe e configure o agente do Edge Manager manualmente](edge-device-fleet-manual.md). 1. Use o console AWS IoT Greengrass V2 ou o AWS CLI para `aws.greengrass.SageMakerEdgeManager` implantar. Consulte [Crie os componentes AWS IoT Greengrass V2](edge-greengrass-custom-component.md). # Baixe e configure o agente do Edge Manager manualmente Baixe o agente do Edge Manager com base em seu sistema operacional, arquitetura e região AWS . O agente é atualizado periodicamente, então você tem a opção de escolher seu agente com base nas datas e versões de lançamento. Depois de ter o agente, crie um arquivo de configuração JSON. Especifique o nome do dispositivo de IoT, o nome da frota, as credenciais do dispositivo e outros pares de valores-chave. Veja [Instalando o agente do Edge Manager](#edge-device-fleet-running-agent) a lista completa das chaves que você deve especificar no arquivo de configuração. Você pode executar o agente como um binário executável ou vinculá-lo como um objeto compartilhado dinâmico (DSO). ## Como o agente trabalha O agente é executado na CPU dos seus dispositivos. O agente executa inferência na framework e no hardware do dispositivo de destino que você especificou durante o trabalho de compilação. Por exemplo, se você compilou seu modelo para o Jetson Nano, o agente oferece apoio à GPU no [Tempo de execução do aprendizado profundo](https://github.com/neo-ai/neo-ai-dlr) (Aprendizado Profundo Runtime, DLR) fornecido. O agente é lançado em formato binário para sistemas operacionais compatíveis. Verifique se seu sistema operacional é compatível e atende aos requisitos mínimos de sistema operacional na tabela a seguir: ------ #### [ Linux ] **Versão:** Ubuntu 18.04 **Formatos binários suportados:** x86-64 bits (binário ELF) e ARMv8 64 bits (binário ELF) ------ #### [ Windows ] **Versão:** Windows 10 versão 1909 **Formatos binários compatíveis:** x86-32 bits (DLL) e x86-64 bits (DLL) ------ ## Instalando o agente do Edge Manager Para usar o agente do Edge Manager, primeiro você deve obter os artefatos de lançamento e um certificado raiz. Os artefatos de lançamento são armazenados em um bucket do Amazon S3 na região `us-west-2`. Para baixar os artefatos, especifique seu sistema operacional (``) e o ``. Com base no seu sistema operacional, `` substitua por um dos seguintes procedimentos: | Windows 32 bits | Windows 64 bits | Linux x86-64 | Linux ARMv8 | | --- | --- | --- | --- | | windows-x86 | windows-x64 | linux-x64 | linux-armv8 | O `VERSION` é dividido em três componentes: `.-`, onde: + ``: a versão de lançamento. A versão de lançamento está atualmente definida como `1`. + ``: a carimbo de data/hora da liberação do artefato. + ``: o ID de confirmação do repositório a partir do qual a versão foi criada. Você deve fornecer o `` e o carimbo de data/hora no formato `YYYY-MM-DD`. Sugerimos que você use o carimbo de data/hora de lançamento do artefato mais recente. Execute o seguinte na sua linha de comando para obter o carimbo de data/hora mais recente: Substitua `` pelo seu sistema operacional: ``` aws s3 ls s3://sagemaker-edge-release-store-us-west-2-/Releases/ | sort -r ``` Por exemplo, se você tiver um sistema operacional Windows de 32 bits, execute: ``` aws s3 ls s3://sagemaker-edge-release-store-us-west-2-windows-x86/Releases/ | sort -r ``` Isso retorna: ``` 2020-12-01 23:33:36 0 PRE 1.20201218.81f481f/ PRE 1.20201207.02d0e97/ ``` A saída de retorno neste exemplo mostra dois artefatos de lançamento. O primeiro arquivo de artefato de lançamento indica que a versão de lançamento tem uma versão principal de`1`, um registro de data e hora `20201218` (em YYYY-MM-DD formato) e um ID de confirmação do `81f481f` SHA-7. **nota** O comando anterior pressupõe que você tenha configurado o AWS Command Line Interface. Para obter mais informações sobre como definir as configurações que o AWS CLI usa para interagir AWS, consulte [Configurando a AWS CLI](https://docs.aws.amazon.com//cli/latest/userguide/cli-chap-configure.html). Com base no seu sistema operacional, use os seguintes comandos para instalar os artefatos: ------ #### [ 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 . ``` ------ Você também deve baixar um certificado raiz. Esse certificado valida os artefatos do modelo assinados por AWS antes de carregá-los em seus dispositivos periféricos. Substitua o `` correspondente à sua plataforma na lista de sistemas operacionais compatíveis e `` substitua pela sua AWS região. ``` aws s3 cp s3://sagemaker-edge-release-store-us-west-2-/Certificates//.pem . ``` ## Instalando o agente do Edge Manager Você pode executar o agente do SageMaker AI Edge Manager como um processo autônomo na forma de um binário executável de formato executável e vinculável (ELF) ou vincular a ele como um objeto compartilhado dinâmico (.dll). O Linux é compatível com executá-lo como um binário executável independente e é o modo preferido. O Windows oferece apoio para executá-lo como um objeto compartilhado (.dll). No Linux, recomendamos que você execute o binário por meio de um serviço que faz parte do seu sistema initialization (`init`). Se quiser executar o binário diretamente, você pode fazê-lo em um terminal, conforme mostrado no exemplo a seguir. Se você tiver um sistema operacional moderno, não serão necessárias outras instalações antes de executar o agente, pois todos os requisitos são incorporados estaticamente no executável. Isso lhe dá flexibilidade para executar o agente no terminal, como um serviço ou dentro de um contêiner. Para executar o agente, crie um arquivo de configuração JSON. Especifique os seguintes pares de chave-valor: + `sagemaker_edge_core_device_name`: o nome do dispositivo. Esse nome de dispositivo precisa ser registrado junto com a frota de dispositivos no console do SageMaker Edge Manager. + `sagemaker_edge_core_device_fleet_name`: o nome da frota ao qual o dispositivo pertence. + `sagemaker_edge_core_region`: A AWS região associada ao dispositivo, à frota e aos buckets do Amazon S3. Isso corresponde à região em que o dispositivo está registrado e onde o bucket do Amazon S3 é criado (espera-se que sejam os mesmos). Os modelos em si podem ser compilados com SageMaker o Neo em uma região diferente, essa configuração não está relacionada à região de compilação do modelo. + `sagemaker_edge_core_root_certs_path`: o caminho absoluto da pasta para os certificados raiz. Isso é usado para validar o dispositivo com a AWS conta relevante. + `sagemaker_edge_provider_aws_ca_cert_file`: O caminho absoluto para o certificado Amazon Root CA (AmazonRootCA1.pem). Isso é usado para validar o dispositivo com a AWS conta relevante. `AmazonCA`é um certificado de propriedade de AWS. + `sagemaker_edge_provider_aws_cert_file`: o caminho absoluto para AWS IoT assinar o certificado raiz (`*.pem.crt`). + `sagemaker_edge_provider_aws_cert_pk_file`: O caminho absoluto para a chave AWS IoT privada. (`*.pem.key`). + `sagemaker_edge_provider_aws_iot_cred_endpoint`: O endpoint de AWS IoT credenciais (*identifier*.iot. *region*.amazonaws.com). Esse endpoint é usado para validação de credenciais. Consulte [Conectar dispositivos ao AWS IoT](https://docs.aws.amazon.com/iot/latest/developerguide/iot-connect-devices.html) para obter mais informações. + `sagemaker_edge_provider_provider`: indica a implementação da interface do provedor que está sendo usada. A interface do provedor se comunica com os serviços de rede final para uploads, pulsações e validação de registro. Por padrão, isso é definido como `"Aws"`. Nós permitimos implementações personalizadas da interface do provedor. Ele pode ser definido como `None` para nenhum provedor ou `Custom` para implementação personalizada com o caminho relevante do objeto compartilhado fornecido. + `sagemaker_edge_provider_provider_path`: fornece o caminho absoluto para o objeto compartilhado de implementação do provedor. (arquivo.so ou.dll). O arquivo .dll ou .so do provedor `"Aws"` é fornecido com a versão do agente. Este campo é obrigatório. + `sagemaker_edge_provider_s3_bucket_name`: o nome do bucket do Amazon S3 (não o URI do bucket do Amazon S3). O bucket deve ter uma string `sagemaker` em seu nome. + `sagemaker_edge_log_verbose` (Booliano): opcional. Isso define o log de depuração. Selecione um `True` ou `False`. + `sagemaker_edge_telemetry_libsystemd_path`: somente para Linux, `systemd` implementa a métrica do contador de falhas do agente. Defina o caminho absoluto do libsystemd para ativar a métrica do contador de falhas. Você pode descobrir que o caminho padrão do libsystemd pode ser encontrado executando `whereis libsystemd` no terminal do dispositivo. + `sagemaker_edge_core_capture_data_destination`: o destino para o upload dos dados de captura. Escolha `"Cloud"` ou `"Disk"`. O padrão é definido como `"Disk"`. Configurá-lo para `"Disk"` gravar o(s) tensor(es) de entrada e saída e os dados auxiliares no sistema de arquivos local em sua localização preferida. Ao escrever para `"Cloud"` usar o nome do bucket do Amazon S3 fornecido na `sagemaker_edge_provider_s3_bucket_name` configuração. + `sagemaker_edge_core_capture_data_disk_path`: defina o caminho absoluto no sistema de arquivos local, no qual os arquivos de dados de captura são gravados quando `"Disk"` for o destino. Esse campo não é usado quando `"Cloud"` for especificado como destino. + `sagemaker_edge_core_folder_prefix`: o prefixo principal no Amazon S3 em que os dados capturados são armazenados quando você `"Cloud"` especifica como destino dos dados de captura (`sagemaker_edge_core_capture_data_disk_path)`. Os dados capturados são armazenados em uma subpasta em `sagemaker_edge_core_capture_data_disk_path` se `"Disk"` estiver definido como o destino dos dados. + `sagemaker_edge_core_capture_data_buffer_size` (Valor inteiro): o tamanho do buffer circular dos dados de captura. Indica o número máximo de solicitações armazenadas no buffer. + `sagemaker_edge_core_capture_data_batch_size` (Valor inteiro): o tamanho do lote de dados de captura. Indica o tamanho de um lote de solicitações que são tratadas a partir do buffer. Esse valor deve ser igual ou menor que `sagemaker_edge_core_capture_data_buffer_size`. Recomenda-se no máximo metade do tamanho do buffer para o tamanho do lote. + `sagemaker_edge_core_capture_data_push_period_seconds` (Valor inteiro): o período de envio dos dados de captura em segundos. Um lote de solicitações no buffer é tratado quando há solicitações de tamanho de lote no buffer ou quando esse período é concluído (o que ocorrer primeiro). Essa configuração define esse período de tempo. + `sagemaker_edge_core_capture_data_base64_embed_limit`: o limite para carregar dados de captura em bytes. Valor inteiro. O arquivo de configuração deve ser semelhante ao exemplo a seguir (com seus valores específicos especificados). Este exemplo usa o AWS provedor padrão (`"Aws"`) e não especifica um upload periódico. ``` { "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 } ``` O artefato de lançamento inclui um executável binário chamado `sagemaker_edge_agent_binary` no `/bin` diretório. Para executar o binário, use o `-a` sinalizador para criar um descritor de arquivo de soquete (.sock) em um diretório de sua escolha e especifique o caminho do arquivo de configuração JSON do agente que você criou com o sinalizador `-c`. ``` ./sagemaker_edge_agent_binary -a -c ``` O seguinte exemplo mostra o trecho de código com um diretório e um caminho de arquivo especificados: ``` ./sagemaker_edge_agent_binary -a /tmp/sagemaker_edge_agent_example.sock -c sagemaker_edge_config.json ``` Neste exemplo, um descritor de arquivo de soquete chamado `sagemaker_edge_agent_example.sock` é criado no `/tmp` diretório e aponta para um arquivo de configuração que está no mesmo diretório de trabalho do agente chamado `sagemaker_edge_config.json`. # Implantação do Model Package e do Edge Manager Agent com AWS IoT Greengrass SageMaker O Edge Manager integra a AWS IoT Greengrass versão 2 para simplificar o acesso, a manutenção e a implantação do agente e modelo do Edge Manager em seus dispositivos. Sem a AWS IoT Greengrass V2, configurar seus dispositivos e frotas para usar o SageMaker Edge Manager exige que você copie manualmente o agente do Edge Manager de um bucket de lançamento do Amazon S3. Você usa o agente para fazer predições com modelos carregados em seus dispositivos de borda. Com a integração AWS IoT Greengrass V2 e SageMaker Edge Manager, você pode usar componentes AWS IoT Greengrass V2. Os componentes são módulos de software pré-construídos que podem conectar seus dispositivos de ponta a AWS serviços ou serviços de terceiros por meio AWS IoT Greengrass de. Você deve instalar o software AWS IoT Greengrass Core em seus dispositivos se quiser usar a AWS IoT Greengrass V2 para implantar o agente do Edge Manager e seu modelo. Para obter mais informações sobre os requisitos do dispositivo e como configurar seus dispositivos, consulte [Configurando dispositivos AWS IoT Greengrass principais](https://docs.aws.amazon.com/greengrass/v2/developerguide/setting-up.html) na AWS IoT Greengrass documentação. Você usa os três componentes a seguir para implantar o agente do Edge Manager: + *Um componente público pré-construído: a SageMaker IA mantém o componente* público do Edge Manager. + *Um componente privado gerado automaticamente: o componente* privado é gerado automaticamente quando você empacota seu modelo de machine learning com a API [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEdgePackagingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEdgePackagingJob.html) e especifica `GreengrassV2Component` para o campo API do Edge Manager `PresetDeploymentType`. + *Um componente personalizado*: esse é a aplicação de inferência responsável por pré-processar e fazer inferências em seu dispositivo. Você deve criar esse componente. Consulte a documentação do SageMaker Edge Manager ou [Criar AWS IoT Greengrass componentes personalizados](https://docs.aws.amazon.com/greengrass/v2/developerguide/create-components.html) na AWS IoT Greengrass documentação para obter mais informações sobre como criar componentes personalizados. [Crie um componente personalizado do Hello World](edge-greengrass-custom-component.md#edge-greengrass-create-custom-component-how) # Preencha os pré-requisitos para implantar o agente do Edge Manager. SageMaker O Edge Manager usa a AWS IoT Greengrass V2 para simplificar a implantação do agente do Edge Manager, seus modelos de aprendizado de máquina e seu aplicativo de inferência em seus dispositivos com o uso de componentes. Para facilitar a manutenção de suas funções AWS do IAM, o Edge Manager permite que você reutilize seu alias de AWS IoT função existente. Se você ainda não tiver um, o Edge Manager gera um alias de função como parte do trabalho de empacotamento do Edge Manager. Você não precisa mais associar um alias de função gerado a partir da tarefa de empacotamento do SageMaker Edge Manager à sua AWS IoT função. Antes de começar, você deve concluir os seguintes pré-requisitos: 1. Instale o software AWS IoT Greengrass Core. Para obter informações detalhadas, consulte [Instalar o software AWS IoT Greengrass principal](https://docs.aws.amazon.com/greengrass/v2/developerguide/getting-started.html#install-greengrass-v2). 1. Configure a AWS IoT Greengrass V2. Para obter mais informações, consulte [Instalar o software AWS IoT Greengrass principal com provisionamento manual de recursos](https://docs.aws.amazon.com/greengrass/v2/developerguide/manual-installation.html). **nota** Certifique-se de que o nome da AWS IoT coisa esteja todo em minúsculas e não contenha caracteres, exceto (opcionalmente) traços (). `‐` O perfil do IAM deve começar com `SageMaker*` 1. Anexe a permissão e a política em linha a seguir à função do IAM criada durante a configuração da AWS IoT Greengrass V2. + Navegue até o console do IAM [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/). + Pesquise a função que você criou digitando o nome da função no campo **Pesquisa**. + Escolha sua função. + Em seguida, escolha **Anexar políticas**. + Pesquise por **AmazonSageMakerEdgeDeviceFleetPolicy**. + Selecionar **AmazonSageMakerFullAccess**(essa é uma etapa opcional que facilita a reutilização dessa função do IAM na compilação e empacotamento do modelo). + Adicione as permissões necessárias à política de permissões de uma função, não anexe políticas embutidas aos usuários do IAM. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement":[ { "Sid":"GreengrassComponentAccess", "Effect":"Allow", "Action":[ "greengrass:CreateComponentVersion", "greengrass:DescribeComponent" ], "Resource":"*" } ] } ``` ------ + Escolha **Anexar política**. + Escolha **Relações de confiança**. + Selecione **Editar relação de confiança**. + Substitua o conteúdo pelo seguinte: ------ #### [ 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. Crie uma frota de dispositivos do Edge Manager. Para obter informações sobre como criar uma frota, consulte [Configuração para dispositivos e frotas no SageMaker Edge Manager](edge-device-fleet.md). 1. Registre seu dispositivo com o mesmo nome do seu AWS IoT item criado durante a configuração da AWS IoT Greengrass V2. 1. Crie pelo menos um AWS IoT Greengrass componente privado personalizado. Esse componente é a aplicação que executa a inferência no dispositivo. Para obter mais informações, consulte [Crie um componente personalizado do Hello World](edge-greengrass-custom-component.md#edge-greengrass-create-custom-component-how). **nota** O SageMaker Edge Manager e a AWS IoT Greengrass integração só funcionam para a AWS IoT Greengrass v2. Tanto o nome da sua AWS IoT coisa quanto o nome do dispositivo Edge Manager devem ser iguais. SageMaker O Edge Manager não carrega AWS IoT certificados locais e chama diretamente o endpoint do provedor de AWS IoT credenciais. Em vez disso, o SageMaker Edge Manager usa a AWS IoT Greengrass v2 TokenExchangeService e busca uma credencial temporária de um endpoint TES. # Crie os componentes AWS IoT Greengrass V2 AWS IoT Greengrass usa *componentes*, um módulo de software que é implantado e executado em um dispositivo AWS IoT Greengrass principal. Você precisa (no mínimo) de três componentes: 1. *Um AWS IoT Greengrass componente público do Edge Manager Agent* que implanta o Edge Manager agentbinary. 1. *Um componente de modelo* que é gerado automaticamente quando você empacota seu modelo de aprendizado de máquina com a AWS SDK para Python (Boto3) API ou com o console de SageMaker IA. Para mais informações, consulte [Crie um componente gerado automaticamente](#edge-greengrass-autogenerate-component-how). 1. *Um componente privado e personalizado* para implementar a aplicação cliente do agente do Edge Manager e fazer qualquer pré-processamento e pós-processamento dos resultados da inferência. Para obter mais informações sobre como criar um componente personalizado, consulte [Crie um componente gerado automaticamente](#edge-greengrass-autogenerate-component-how) [Criar AWS IoT Greengrass componentes personalizados](https://docs.aws.amazon.com/greengrass/v2/developerguide/create-components.html). ## Crie um componente gerado automaticamente Gere o componente do modelo com a [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEdgePackagingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEdgePackagingJob.html)API e especifique `GreengrassV2Component` para o campo API do trabalho de empacotamento do SageMaker Edge Manager`PresetDeploymentType`. Quando você chama a `CreateEdgePackagingJob` API, o Edge Manager pega seu modelo SageMaker AI Neo compilado no Amazon S3 e cria um componente de modelo. O componente do modelo é armazenado automaticamente em sua conta. Você pode visualizar qualquer um dos seus componentes navegando até o AWS IoT console [https://console.aws.amazon.com/iot/](https://console.aws.amazon.com/greengrass/). Selecione **Greengrass** e, em seguida, selecione **dispositivos de núcleo**. A página tem uma lista dos AWS IoT Greengrass principais dispositivos associados à sua conta. Se o nome de um componente do modelo não for especificado em `PresetDeploymentConfig`, o nome padrão gerado consistirá em `"SagemakerEdgeManager"` e no nome do seu trabalho de empacotamento do agente do Edge Manager. O exemplo a seguir demonstra como especificar que o Edge Manager crie um componente AWS IoT Greengrass V2 com a `CreateEdgePackagingJob` API. ``` import sagemaker import boto3 # Create a SageMaker client object to make it easier to interact with other AWS services. sagemaker_client = boto3.client('sagemaker', region=) # 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\"}" } ) ``` Você também pode criar o componente gerado automaticamente com o console de SageMaker IA. Seguir as etapas de 1 a 6 em [Package um modelo (Amazon SageMaker AI Console)](edge-packaging-job-console.md) Insira o URI do bucket do Amazon S3 em que deseja armazenar a saída do trabalho de empacotamento e a chave de criptografia opcional. Preencha o seguinte para criar o componente do modelo: 1. Escolha **Implantação predefinida**. 1. Especifique o nome do componente no campo **Nome do componente**. 1. Opcionalmente, forneça uma descrição do componente, da versão do componente, do sistema operacional da plataforma ou da arquitetura da plataforma para a **descrição do componente**, a **versão do componente**, o **sistema operacional da plataforma** e a **arquitetura da plataforma**, respectivamente. 1. Selecione **Enviar**. ## Crie um componente personalizado do Hello World O componente de aplicação personalizado é usado para realizar inferência no dispositivo de borda. O componente é responsável por carregar modelos no SageMaker Edge Manager, invocar o agente do Edge Manager para inferência e descarregar o modelo quando o componente é desligado. Antes de criar seu componente, certifique-se de que o agente e a aplicação possam se comunicar com o Edge Manager. Para fazer isso, configure o [gRPC](https://grpc.io/). O agente do Edge Manager usa métodos definidos no Protobuf Buffers e no servidor gRPC para estabelecer comunicação com a aplicação cliente no dispositivo de borda e na nuvem. Para usar o gRPC, você deve: 1. Crie um stub gRPC usando o arquivo .proto fornecido ao fazer download do agente do Edge Manager do bucket de lançamento do Amazon S3. 1. Escreva o código do cliente com o idioma de sua preferência. Você não precisa definir o serviço em um arquivo .proto. Os arquivos service .proto são incluídos no arquivo TAR compactado quando você baixa o binário de versão do agente do Edge Manager do bucket de lançamento do Amazon S3. Instale o gRPC e outras ferramentas necessárias em seu computador host e crie os stubs do gRPC `agent_pb2_grpc.py` e `agent_pb2.py` em Python. Verifique se você tem `agent.proto` em seu diretório local. ``` %%bash pip install grpcio pip install grpcio-tools python3 -m grpc_tools.protoc --proto_path=. --python_out=. --grpc_python_out=. agent.proto ``` O código anterior gera as interfaces de cliente e servidor gRPC a partir da sua definição do serviço .proto. Em outras palavras, ele cria o modelo gRPC em Python. O diretório da API contém a especificação Protobuf para comunicação com o agente. Em seguida, use a API gRPC para escrever um cliente e um servidor para seu serviço (2). O script de exemplo a seguir, `edge_manager_python_example.py`, usa Python para carregar, listar e descarregar um modelo `yolov3` no dispositivo de borda. ``` import grpc from PIL import Image import agent_pb2 import agent_pb2_grpc import os model_path = '' agent_socket = 'unix:///tmp/aws.greengrass.SageMakerEdgeManager.sock' agent_channel = grpc.insecure_channel(agent_socket, options=(('grpc.enable_http_proxy', 0),)) agent_client = agent_pb2_grpc.AgentStub(agent_channel) def list_models(): return agent_client.ListModels(agent_pb2.ListModelsRequest()) def list_model_tensors(models): return { model.name: { 'inputs': model.input_tensor_metadatas, 'outputs': model.output_tensor_metadatas } for model in list_models().models } def load_model(model_name, model_path): load_request = agent_pb2.LoadModelRequest() load_request.url = model_path load_request.name = model_name return agent_client.LoadModel(load_request) def unload_model(name): unload_request = agent_pb2.UnLoadModelRequest() unload_request.name = name return agent_client.UnLoadModel(unload_request) def predict_image(model_name, image_path): image_tensor = agent_pb2.Tensor() image_tensor.byte_data = Image.open(image_path).tobytes() image_tensor_metadata = list_model_tensors(list_models())[model_name]['inputs'][0] image_tensor.tensor_metadata.name = image_tensor_metadata.name image_tensor.tensor_metadata.data_type = image_tensor_metadata.data_type for shape in image_tensor_metadata.shape: image_tensor.tensor_metadata.shape.append(shape) predict_request = agent_pb2.PredictRequest() predict_request.name = model_name predict_request.tensors.append(image_tensor) predict_response = agent_client.Predict(predict_request) return predict_response def main(): try: unload_model('your-model') except: pass print('LoadModel...', end='') try: load_model('your-model', model_path) print('done.') except Exception as e: print() print(e) print('Model already loaded!') print('ListModels...', end='') try: print(list_models()) print('done.') except Exception as e: print() print(e) print('List model failed!') print('Unload model...', end='') try: unload_model('your-model') print('done.') except Exception as e: print() print(e) print('unload model failed!') if __name__ == '__main__': main() ``` Certifique-se de `model_path` apontar para o nome do AWS IoT Greengrass componente que contém o modelo se você usar o mesmo exemplo de código de cliente. Você pode criar seu componente AWS IoT Greengrass V2 Hello World depois de gerar seus stubs gRPC e ter seu código Hello World pronto. Para fazer isso: + Faça o upload do seu `edge_manager_python_example.py`, `agent_pb2_grpc.py` e `agent_pb2.py` para o seu bucket do Amazon S3 e anote o caminho do Amazon S3. + Crie um componente privado no console AWS IoT Greengrass V2 e defina a receita para seu componente. Especifique o URI do Amazon S3 para sua aplicação Hello World e o stub gRPC na fórmula a seguir. ``` --- 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: ``` Para obter informações detalhadas sobre como criar uma receita do Hello World, consulte [Criar seu primeiro componente](https://docs.aws.amazon.com/greengrass/v2/developerguide/getting-started.html#create-first-component) na AWS IoT Greengrass documentação. # Implante os componentes em seu dispositivo Implante seus componentes com o AWS IoT console ou com AWS CLI o. ## Para implantar seus componentes (console) Implante seus AWS IoT Greengrass componentes com o AWS IoT console. 1. No AWS IoT Greengrass console, no menu [https://console.aws.amazon.com/iot/](https://console.aws.amazon.com/greengrass/)de navegação, escolha **Implantações.** 1. Na página **Componentes**, na guia **Componentes públicos**, escolha `aws.greengrass.SageMakerEdgeManager`. 1. Na página `aws.greengrass.SageMakerEdgeManager`, escolha **Implantar**. 1. Do `Add to deployment`, escolha uma das seguintes opções: 1. Para mesclar esse componente a uma implantação existente em seu dispositivo de destino, escolha **Adicionar à implantação existente** e selecione a implantação que você deseja revisar. 1. Para criar uma nova implantação em seu dispositivo de destino, escolha **Criar nova implantação**. Se você tiver uma implantação existente em seu dispositivo, escolher essa etapa substituirá a implantação existente. 1. Na página **Especificar destino**, faça o seguinte: 1. Em **Informações de implantação**, insira ou modifique o nome amigável para sua implantação. 1. Em **Destinos de implantação**, selecione um alvo para sua implantação e escolha **Avançar**. Você não pode alterar o destino de implantação se estiver revisando uma implantação existente. 1. Na página **Selecionar componentes**, em **Meus componentes**, escolha: + com. ** + `aws.greengrass.SageMakerEdgeManager` + SagemakerEdgeManager.** 1. Na página **Configurar componentes**, escolha **com.greengrass. SageMakerEdgeManager**e faça o seguinte. 1. Escolha **Configurar componente**. 1. Em **Atualização de configuração**, em **Configuração a ser mesclada**, insira a configuração a seguir. ``` { "DeviceFleetName": "device-fleet-name", "BucketName": "bucket-name" } ``` Substitua *`device-fleet-name`* pelo nome da frota de dispositivos de borda que você criou e *`bucket-name`*substitua pelo nome do bucket do Amazon S3 que está associado à sua frota de dispositivos. 1. Escolha **Confirmar** e, em seguida, **Avançar**. 1. Na página **Definir configurações avançadas**, mantenha as configurações padrão e escolha **Avançar**. 1. Na página **Pré-visualizar**, escolha **Implantar**. ## Para implantar seus componentes (AWS CLI) 1. Crie um ` deployment.json` arquivo para definir a configuração de implantação dos componentes do SageMaker Edge Manager. Esse arquivo deve se parecer com o exemplo a seguir. ``` { "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": { } }, } } ``` + No campo `targetArn`, substitua *`targetArn`* pelo nome do recurso da Amazon (ARN) da coisa ou do grupo de coisas do destino da implantação, no seguinte formato: + Coisa: `arn:aws:iot:region:account-id:thing/thingName` + Grupo de coisas: `arn:aws:iot:region:account-id:thinggroup/thingGroupName` + No campo `merge`, substitua *`device-fleet-name`* pelo nome da frota de dispositivos de borda que você criou e substitua *`bucket-name`* pelo nome do bucket do Amazon S3 que está associado à sua frota de dispositivos. + Substitua as versões dos componentes de cada componente pela versão mais recente disponível. 1. Execute o seguinte comando para implantar os componentes no dispositivo: ``` aws greengrassv2 create-deployment \ --cli-input-json file://path/to/deployment.json ``` A implantação pode levar vários minutos para ser concluída. Na próxima etapa, verifique o log do componente para verificar se a implantação foi concluída com êxito e para ver os resultados da inferência. Para obter mais informações sobre a implantação de componentes em dispositivos individuais ou grupos de dispositivos, consulte [Implantar AWS IoT Greengrass componentes em dispositivos](https://docs.aws.amazon.com/greengrass/v2/developerguide/manage-deployments.html). # Implante o Model Package diretamente com a API de implantação do SageMaker Edge Manager SageMaker O Edge Manager fornece uma API de implantação que você pode usar para implantar modelos em alvos de dispositivos sem AWS IoT Greengrass. É útil em situações em que você deseja atualizar modelos independentemente das atualizações de firmware ou dos mecanismos de implantação de aplicações. Você pode usar a API para integrar suas implantações de borda em um CI/CD fluxo de trabalho para implantar modelos automaticamente depois de validar seu modelo quanto à precisão. A API também possui opções convenientes de reversão e implementação gradual para garantir que os modelos funcionem bem em um ambiente específico antes de uma implementação mais ampla. Para usar a API de implantação do Edge Manager, primeiro compile e empacote seu modelo. Para obter informações sobre como compilar e empacotar seu modelo, consulte [Prepare o modelo para implantação](edge-getting-started-step2.md). As seções a seguir deste guia mostram como você pode criar implantações de borda usando a SageMaker API, depois de compilar e empacotar seus modelos. **Topics** + [Crie um plano de implantação de borda](#create-edge-deployment-plan) + [Iniciar a implantação da borda](#start-edge-deployment-stage) + [Verifique o status da implantação](#describe-edge-deployment-status) ## Crie um plano de implantação de borda Você pode criar um plano de implantação da borda com a API [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEdgeDeploymentPlan.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEdgeDeploymentPlan.html). O plano de implantação pode ter vários estágios. Você pode configurar cada estágio para implantar a implantação em um subconjunto de dispositivos de borda (por porcentagem ou por nome do dispositivo). Você também pode configurar como as falhas de implantação são tratadas em cada estágio. O trecho de código a seguir mostra como você pode criar um plano de implantação de borda com 1 estágio para implantar um modelo compilado e empacotado em dois dispositivos de borda específicos: ``` 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" } } ] ) ``` Em vez de dispositivos específicos, se você quiser implantar o modelo em uma porcentagem de dispositivos em sua frota, defina o valor de `DeviceSubsetType` como `"PERCENTAGE"` e substitua `"DeviceNames": ["device-name-1", "device-name-2"]` por `"Percentage": desired-percentage` no exemplo acima. Os estágios podem ser adicionados após a criação do plano de implantação com a [CreateEdgeDeploymentStage](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEdgeDeploymentStage.html)API, caso você queira começar a implementar novos estágios após validar o sucesso do lançamento do teste. Para obter mais informações sobre os estágios de implantação, consulte [DeploymentStage.](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeploymentStage.html) ## Iniciar a implantação da borda Depois de criar o plano de implantação e os estágios de implantação, você pode iniciar a implantação com a 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" ) ``` ## Verifique o status da implantação Você pode verificar o status da implantação periférica com a [DescribeEdgeDeploymentPlan](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEdgeDeploymentPlan.html)API. ``` client.describe_edge_deployment_plan( EdgeDeploymentPlanName="edge-deployment-plan-name" ) ```