Etapa 4: desenvolver e testar um componente em seu dispositivo

Um componente é um módulo de software executado em dispositivos AWS IoT Greengrass principais. Os componentes permitem que você crie e gerencie aplicativos complexos como blocos de construção discretos que você pode reutilizar de um dispositivo principal do Greengrass para outro. Cada componente é composto por uma receita e artefatos.

Receitas

Cada componente contém um arquivo de receita, que define seus metadados. A receita também especifica os parâmetros de configuração do componente, as dependências do componente, o ciclo de vida e a compatibilidade da plataforma. O ciclo de vida do componente define os comandos que instalam, executam e desligam o componente. Para ter mais informações, consulte AWS IoT Greengrass referência da receita do componente.

Você pode definir receitas no formato JSON ou YAML.
Artefatos

Os componentes podem ter qualquer número de artefatos, que são binários de componentes. Os artefatos podem incluir scripts, código compilado, recursos estáticos e quaisquer outros arquivos que um componente consuma. Os componentes também podem consumir artefatos das dependências dos componentes.

Com AWS IoT Greengrass, você pode usar a CLI do Greengrass para desenvolver e testar componentes localmente em um dispositivo principal do Greengrass sem interação com a nuvem. AWS Ao concluir seu componente local, você pode usar a receita e os artefatos do componente para criar esse componente no AWS IoT Greengrass serviço na AWS nuvem e, em seguida, implantá-lo em todos os seus dispositivos principais do Greengrass. Para obter mais informações sobre componentes, consulte Desenvolva AWS IoT Greengrass componentes.

Nesta seção, você aprenderá a criar e executar um componente básico do Hello World localmente em seu dispositivo principal.

Para desenvolver um componente Hello World em seu dispositivo

Crie uma pasta para seus componentes com subpastas para receitas e artefatos. Execute os comandos a seguir em seu dispositivo principal do Greengrass para criar essas pastas e mudar para a pasta do componente. Substitua ~/greengrassv2 ou %USERPROFILE%\ greengrassv2 pelo caminho para a pasta a ser usada no desenvolvimento local.
Linux or Unix
```
mkdir -p ~/greengrassv2/{recipes,artifacts}
cd ~/greengrassv2
```
Windows Command Prompt (CMD)
```
mkdir %USERPROFILE%\greengrassv2\\recipes, %USERPROFILE%\greengrassv2\\artifacts
cd %USERPROFILE%\greengrassv2
```
PowerShell
```
mkdir ~/greengrassv2/recipes, ~/greengrassv2/artifacts
cd ~/greengrassv2
```
Use um editor de texto para criar um arquivo de receita que defina os metadados, os parâmetros, as dependências, o ciclo de vida e a capacidade da plataforma do seu componente. Inclua a versão do componente no nome do arquivo da receita para que você possa identificar qual receita reflete qual versão do componente. Você pode escolher o formato YAML ou JSON para sua receita.

Por exemplo, em um sistema baseado em Linux, você pode executar o seguinte comando para usar o GNU nano para criar o arquivo.
JSON
```
nano recipes/com.example.HelloWorld-1.0.0.json
```
YAML
```
nano recipes/com.example.HelloWorld-1.0.0.yaml
```
nota
AWS IoT Greengrass usa versões semânticas para componentes. As versões semânticas seguem um sistema de numeração principal.secundária.patch. Por exemplo, a versão 1.0.0 representa a primeira versão principal de um componente. Para obter mais informações, consulte a especificação da versão semântica.

Cole a seguinte receita no arquivo.

A ComponentConfiguration seção desta receita define um parâmetro,Message, cujo padrão é. world A Manifests seção define um manifesto, que é um conjunto de instruções e artefatos do ciclo de vida de uma plataforma. Você pode definir vários manifestos para especificar instruções de instalação diferentes para várias plataformas, por exemplo. No manifesto, a Lifecycle seção instrui o dispositivo principal do Greengrass a executar o script Hello World com Message o valor do parâmetro como argumento.

Execute o comando a seguir para criar uma pasta para os artefatos do componente.
Linux or Unix
```
mkdir -p artifacts/com.example.HelloWorld/1.0.0
```
Windows Command Prompt (CMD)
```
mkdir artifacts\com.example.HelloWorld\1.0.0
```
PowerShell
```
mkdir artifacts\com.example.HelloWorld\1.0.0
```
Importante
Você deve usar o seguinte formato para o caminho da pasta de artefatos. Inclua o nome e a versão do componente que você especificar na receita.
```
artifacts/componentName/componentVersion/
```
Use um editor de texto para criar um arquivo de artefato de script Python para seu componente Hello World.

Por exemplo, em um sistema baseado em Linux, você pode executar o seguinte comando para usar o GNU nano para criar o arquivo.
```
nano artifacts/com.example.HelloWorld/1.0.0/hello_world.py
```
Copie e cole o seguinte script Python no arquivo.
```
import sys

message = "Hello, %s!" % sys.argv[1]

# Print the message to stdout, which Greengrass saves in a log file.
print(message)
```
Use a AWS IoT Greengrass CLI local para gerenciar componentes em seu dispositivo principal do Greengrass.

Execute o comando a seguir para implantar o componente no AWS IoT Greengrass núcleo. Substitua /greengrass/v2 ou C:\greengrass\v2 pela pasta AWS IoT Greengrass V2 raiz e substitua ~/greengrassv2 ou %USERPROFILE%\ greengrassv2 pela pasta de desenvolvimento de componentes.
Linux or Unix
```
sudo /greengrass/v2/bin/greengrass-cli deployment create \
  --recipeDir ~/greengrassv2/recipes \
  --artifactDir ~/greengrassv2/artifacts \
  --merge "com.example.HelloWorld=1.0.0"
```
Windows Command Prompt (CMD)
```
C:\greengrass\v2\bin\greengrass-cli deployment create ^
  --recipeDir %USERPROFILE%\greengrassv2\recipes ^
  --artifactDir %USERPROFILE%\greengrassv2\artifacts ^
  --merge "com.example.HelloWorld=1.0.0"
```
PowerShell
```
C:\greengrass\v2\bin\greengrass-cli deployment create `
  --recipeDir ~/greengrassv2/recipes `
  --artifactDir ~/greengrassv2/artifacts `
  --merge "com.example.HelloWorld=1.0.0"
```
Esse comando adiciona o componente que usa a receita em recipes e o script Python em. artifacts A --merge opção adiciona ou atualiza o componente e a versão que você especificar.
O software AWS IoT Greengrass Core salva o stdout do processo do componente em arquivos de log na logs pasta. Execute o comando a seguir para verificar se o componente Hello World é executado e imprime mensagens.
Linux or Unix
```
sudo tail -f /greengrass/v2/logs/com.example.HelloWorld.log
```
Windows Command Prompt (CMD)
```
type C:\greengrass\v2\logs\com.example.HelloWorld.log
```
O type comando grava o conteúdo do arquivo no terminal. Execute esse comando várias vezes para observar as alterações no arquivo.
PowerShell
```
gc C:\greengrass\v2\logs\com.example.HelloWorld.log -Tail 10 -Wait
```
Você deve ver mensagens semelhantes ao exemplo a seguir.
```
Hello, world!
```
nota
Se o arquivo não existir, a implantação local talvez ainda não tenha sido concluída. Se o arquivo não existir em 15 segundos, a implantação provavelmente falhou. Isso pode ocorrer se sua receita não for válida, por exemplo. Execute o comando a seguir para visualizar o arquivo de log AWS IoT Greengrass principal. Esse arquivo inclui registros do serviço de implantação do dispositivo principal do Greengrass.
Linux or Unix

sudo tail -f /greengrass/v2/logs/greengrass.log

Windows Command Prompt (CMD)

type C:\greengrass\v2\logs\greengrass.log

O type comando grava o conteúdo do arquivo no terminal. Execute esse comando várias vezes para observar as alterações no arquivo.

PowerShell

gc C:\greengrass\v2\logs\greengrass.log -Tail 10 -Wait
Modifique o componente local para iterar e testar seu código. Abra hello_world.py em um editor de texto e adicione o código a seguir na linha 4 para editar a mensagem que o AWS IoT Greengrass núcleo registra.
```
message += " Greetings from your first Greengrass component."
```
O hello_world.py script agora deve ter o seguinte conteúdo.
```
import sys

message = "Hello, %s!" % sys.argv[1]
message += " Greetings from your first Greengrass component."

# Print the message to stdout, which Greengrass saves in a log file.
print(message)
```

Execute o comando a seguir para atualizar o componente com suas alterações.

Esse comando atualiza o com.example.HelloWorld componente com o artefato Hello World mais recente.

Execute o comando a seguir para reiniciar o componente. Quando você reinicia um componente, o dispositivo principal usa as alterações mais recentes.

Verifique o registro novamente para verificar se o componente Hello World imprime a nova mensagem.
Linux or Unix
```
sudo tail -f /greengrass/v2/logs/com.example.HelloWorld.log
```
Windows Command Prompt (CMD)
```
type C:\greengrass\v2\logs\com.example.HelloWorld.log
```
O type comando grava o conteúdo do arquivo no terminal. Execute esse comando várias vezes para observar as alterações no arquivo.
PowerShell
```
gc C:\greengrass\v2\logs\com.example.HelloWorld.log -Tail 10 -Wait
```
Você deve ver mensagens semelhantes ao exemplo a seguir.
```
Hello, world! Greetings from your first Greengrass component.
```
Você pode atualizar os parâmetros de configuração do componente para testar configurações diferentes. Ao implantar um componente, você pode especificar uma atualização de configuração, que define como modificar a configuração do componente no dispositivo principal. Você pode especificar quais valores de configuração serão redefinidos para os valores padrão e os novos valores de configuração a serem mesclados no dispositivo principal. Para ter mais informações, consulte Atualizar configurações de componentes.

Faça o seguinte:
1. Use um editor de texto para criar um arquivo chamado hello-world-config-update.json para conter a atualização de configuração
  
  Por exemplo, em um sistema baseado em Linux, você pode executar o seguinte comando para usar o GNU nano para criar o arquivo.
```
nano hello-world-config-update.json
```
2. Copie e cole o seguinte objeto JSON no arquivo. Esse objeto JSON define uma atualização de configuração que mescla o valor friend ao Message parâmetro para atualizar seu valor. Essa atualização de configuração não especifica nenhum valor a ser redefinido. Você não precisa redefinir o Message parâmetro porque a atualização de mesclagem substitui o valor existente.
```
{
  "com.example.HelloWorld": {
    "MERGE": {
      "Message": "friend"
    }
  }
}
```
3. Execute o comando a seguir para implantar a atualização de configuração no componente Hello World.
  Linux or Unix
  sudo /greengrass/v2/bin/greengrass-cli deployment create \ --merge "com.example.HelloWorld=1.0.0" \ --update-config hello-world-config-update.json
  Windows Command Prompt (CMD)
  C:\greengrass\v2\bin\greengrass-cli deployment create ^ --merge "com.example.HelloWorld=1.0.0" ^ --update-config hello-world-config-update.json
  PowerShell
  C:\greengrass\v2\bin\greengrass-cli deployment create ` --merge "com.example.HelloWorld=1.0.0" ` --update-config hello-world-config-update.json
4. Verifique o registro novamente para verificar se o componente Hello World gera a nova mensagem.
  Linux or Unix
  sudo tail -f /greengrass/v2/logs/com.example.HelloWorld.log
  Windows Command Prompt (CMD)
  type C:\greengrass\v2\logs\com.example.HelloWorld.log
  
  O type comando grava o conteúdo do arquivo no terminal. Execute esse comando várias vezes para observar as alterações no arquivo.
  PowerShell
  gc C:\greengrass\v2\logs\com.example.HelloWorld.log -Tail 10 -Wait
  Você deve ver mensagens semelhantes ao exemplo a seguir.
```
Hello, friend! Greetings from your first Greengrass component.
```
Depois de terminar de testar seu componente, remova-o do seu dispositivo principal. Execute o seguinte comando .
Linux or Unix
```
sudo /greengrass/v2/bin/greengrass-cli deployment create --remove="com.example.HelloWorld"
```
Windows Command Prompt (CMD)
```
C:\greengrass\v2\bin\greengrass-cli deployment create --remove="com.example.HelloWorld"
```
PowerShell
```
C:\greengrass\v2\bin\greengrass-cli deployment create --remove="com.example.HelloWorld"
```
Importante
Essa etapa é necessária para que você implante o componente de volta no dispositivo principal depois de carregá-lo no AWS IoT Greengrass. Caso contrário, a implantação falhará com um erro de compatibilidade de versão porque a implantação local especifica uma versão diferente do componente.

Execute o comando a seguir e verifique se o com.example.HelloWorld componente não aparece na lista de componentes do seu dispositivo.
Linux or Unix
```
sudo /greengrass/v2/bin/greengrass-cli component list
```
Windows Command Prompt (CMD)
```
C:\greengrass\v2\bin\greengrass-cli component list
```
PowerShell
```
C:\greengrass\v2\bin\greengrass-cli component list
```

Seu componente Hello World está completo e agora você pode carregá-lo no serviço de AWS IoT Greengrass nuvem. Em seguida, você pode implantar o componente nos dispositivos principais do Greengrass.

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Verifique a instalação da CLI do Greengrass no dispositivo

Etapa 5: Crie seu componente no AWS IoT Greengrass serviço

Etapa 4: desenvolver e testar um componente em seu dispositivo

Para desenvolver um componente Hello World em seu dispositivo

nota

Importante

nota

Importante