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á.
# Tutorial: Conceitos básicos do AWS IoT Greengrass V2
Conclua este tutorial de introdução para aprender os atributos básicos do AWS IoT Greengrass V2. Neste tutorial, você faz o seguinte:
1. Instale e configure o software AWS IoT Greengrass Core em um dispositivo Linux, como um Raspberry Pi ou um dispositivo Windows. Este é um dispositivo principal do Greengrass.
1. Desenvolva um componente Hello World no dispositivo principal do Greengrass. Os componentes são softwares executados nos dispositivos principais do Greengrass.
1. Faça o upload desse componente para o AWS IoT Greengrass V2 na Nuvem AWS.
1. Implante esse componente da Nuvem AWS para o dispositivo principal do Greengrass.
**nota**
Este tutorial descreve como configurar um ambiente de desenvolvimento e explorar os atributos do AWS IoT Greengrass. Para mais informações sobre como instalar e configurar dispositivos de produção, consulte o seguinte:
[Configurando dispositivos AWS IoT Greengrass principais](setting-up.md)
[Instalar o software do AWS IoT Greengrass Core](install-greengrass-core-v2.md)
Você deve levar de 20 a 30 minutos para concluir este tutorial.
**Topics**
+ [Pré-requisitos](getting-started-prerequisites.md)
+ [Etapa 1: configurar uma AWS conta](getting-started-set-up-aws-account.md)
+ [Etapa 2: configurar o ambiente](getting-started-set-up-environment.md)
+ [Etapa 3: instalar o software AWS IoT Greengrass principal](install-greengrass-v2.md)
+ [Etapa 4: desenvolver e testar um componente no dispositivo](create-first-component.md)
+ [Etapa 5: Crie seu componente no AWS IoT Greengrass serviço](upload-first-component.md)
+ [Etapa 6: implantar seu componente](deploy-first-component.md)
+ [Próximas etapas](getting-started-next-steps.md)
# Pré-requisitos
Para concluir este tutorial de conceitos básicos, você precisa:
+ Um Conta da AWS. Se você não tiver uma, consulte [Etapa 1: configurar uma AWS conta](getting-started-set-up-aws-account.md).
+ O uso de uma [Região da AWS](https://en.wikipedia.org/wiki/Amazon_Web_Services#Availability_and_topology) que ofereça suporte ao AWS IoT Greengrass V2. Para obter a lista de regiões compatíveis, consulte [Endpoints e cotas do AWS IoT Greengrass V2](https://docs.aws.amazon.com/general/latest/gr/greengrassv2.html) no *Referência geral da AWS*.
+ Um usuário do AWS Identity and Access Management (IAM) com permissões de administrador.
+ Um dispositivo a ser configurado como um dispositivo principal do Greengrass, como um Raspberry Pi com [sistema operacional Raspberry Pi](https://www.raspberrypi.org/downloads/) (anteriormente chamado de Raspbian) ou um dispositivo Windows 10. É preciso ter permissões de administrador neste dispositivo ou ter a capacidade de adquirir privilégios de administrador, como por meio de `sudo`. Este dispositivo precisa ter uma conexão com a internet.
Também é possível optar por usar um dispositivo diferente que atenda aos requisitos para instalar e executar o software AWS IoT Greengrass Core.
Se o seu computador de desenvolvimento atender a esses requisitos, será possível configurá-lo como seu dispositivo principal do Greengrass neste tutorial.
+ O [Python](https://www.python.org/downloads/) versão 3.5 ou posterior instalado para todos os usuários no dispositivo e adicionado à variável de ambiente `PATH`. No Windows, você também precisa ter o Python Launcher para Windows instalado para todos os usuários.
**Importante**
No Windows, por padrão, o Python não é instalado para todos os usuários. Ao instalar o Python, é preciso personalizar a instalação para configurá-la de modo que o software AWS IoT Greengrass Core execute scripts em Python. Por exemplo, se você usar o instalador gráfico do Python, é preciso fazer o seguinte:
Selecione **Instalar inicializador para todos os usuários (recomendado)**.
Selecione **Customize installation**.
Selecione **Next**.
Selecione **Install for all users**.
Selecione **Add Python to environment variables**.
Escolha **Instalar**.
Para mais informações, consulte [Como usar o Python no Windows](https://docs.python.org/3/using/windows.html) na *documentação do Python 3*.
+ A AWS Command Line Interface(AWS CLI) instalada e configurada com credenciais no computador de desenvolvimento e no dispositivo. Certifique-se de usar a mesma Região da AWS para configurar a AWS CLI em ambos. Para usar o AWS IoT Greengrass V2 com a AWS CLI, é preciso ter uma das seguintes versões ou posteriores:
+ Versão mínima da AWS CLI V1: v1.18.197
+ Versão mínima da AWS CLI V2: v2.1.11
**dica**
É possível executar o comando a seguir para verificar a versão da AWS CLI que você tem.
```
aws --version
```
Para mais informações, consulte [Instalar, atualizar e desinstalar a AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html) e [Configuração da AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html) no *Guia do usuário da AWS Command Line Interface*.
**nota**
Se você utiliza um dispositivo ARM de 32 bits, como um Raspberry Pi com sistema operacional de 32 bits, instale a AWS CLI V1. AWS CLI A V2 não está disponível para dispositivos ARM de 32 bits. Para obter mais informações, consulte [Instalar, atualizar e desinstalar a AWS CLI versão 1](https://docs.aws.amazon.com/cli/latest/userguide/install-cliv1.html).
# Etapa 1: configurar uma AWS conta
## Inscreva-se para um Conta da AWS
Se você não tiver um Conta da AWS, conclua as etapas a seguir para criar um.
**Para se inscrever em um Conta da AWS**
1. Abra a [https://portal.aws.amazon.com/billing/inscrição.](https://portal.aws.amazon.com/billing/signup)
1. Siga as instruções online.
Parte do procedimento de inscrição envolve receber uma chamada telefônica ou uma mensagem de texto e inserir um código de verificação pelo teclado do telefone.
Quando você se inscreve em um Conta da AWS, um *Usuário raiz da conta da AWS*é criado. O usuário-raiz tem acesso a todos os Serviços da AWS e recursos na conta. Como prática recomendada de segurança, atribua o acesso administrativo a um usuário e use somente o usuário-raiz para executar [tarefas que exigem acesso de usuário-raiz](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks).
AWS envia um e-mail de confirmação após a conclusão do processo de inscrição. A qualquer momento, você pode visualizar a atividade atual da sua conta e gerenciar sua conta acessando [https://aws.amazon.com/e](https://aws.amazon.com/) escolhendo **Minha conta**.
## Criar um usuário com acesso administrativo
Depois de se inscrever em um Conta da AWS, proteja seu Usuário raiz da conta da AWS Centro de Identidade do AWS IAM, habilite e crie um usuário administrativo para que você não use o usuário root nas tarefas diárias.
**Proteja seu Usuário raiz da conta da AWS**
1. Faça login [Console de gerenciamento da AWS](https://console.aws.amazon.com/)como proprietário da conta escolhendo **Usuário raiz** e inserindo seu endereço de Conta da AWS e-mail. Na próxima página, insira a senha.
Para obter ajuda ao fazer login usando o usuário-raiz, consulte [Fazer login como usuário-raiz](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial) no *Guia do usuário do Início de Sessão da AWS *.
1. Habilite a autenticação multifator (MFA) para o usuário-raiz.
Para obter instruções, consulte [Habilitar um dispositivo de MFA virtual para seu usuário Conta da AWS raiz (console) no Guia](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html) do *usuário do IAM*.
**Criar um usuário com acesso administrativo**
1. Habilita o Centro de Identidade do IAM.
Para obter instruções, consulte [Habilitar o Centro de Identidade do AWS IAM](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html) no *Guia do usuário do Centro de Identidade do AWS IAM *.
1. No Centro de Identidade do IAM, conceda o acesso administrativo a um usuário.
Para ver um tutorial sobre como usar o Diretório do Centro de Identidade do IAM como fonte de identidade, consulte [Configurar o acesso do usuário com o padrão Diretório do Centro de Identidade do IAM](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html) no *Guia Centro de Identidade do AWS IAM do usuário*.
**Iniciar sessão como o usuário com acesso administrativo**
+ Para fazer login com o seu usuário do Centro de Identidade do IAM, use o URL de login enviado ao seu endereço de e-mail quando o usuário do Centro de Identidade do IAM foi criado.
Para obter ajuda para fazer login usando um usuário do IAM Identity Center, consulte Como [fazer login no portal de AWS acesso](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html) no *Guia Início de Sessão da AWS do usuário*.
**Atribuir acesso a usuários adicionais**
1. No Centro de Identidade do IAM, crie um conjunto de permissões que siga as práticas recomendadas de aplicação de permissões com privilégio mínimo.
Para obter instruções, consulte [Criar um conjunto de permissões](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html) no *Guia do usuário do Centro de Identidade do AWS IAM *.
1. Atribua usuários a um grupo e, em seguida, atribua o acesso de autenticação única ao grupo.
Para obter instruções, consulte [Adicionar grupos](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html) no *Guia do usuário do Centro de Identidade do AWS IAM *.
# Etapa 2: configurar o ambiente
**nota**
Essas etapas não se aplicam ao nucleus lite.
Siga as etapas nesta seção para configurar um dispositivo Linux ou Windows para usar como dispositivo principal do AWS IoT Greengrass .
## Configurar um dispositivo Linux (Raspberry Pi)
Essas etapas pressupõem que você use um Raspberry Pi com o sistema operacional Raspberry Pi. Se você usar um dispositivo ou sistema operacional diferente, consulte a documentação relevante para seu dispositivo.
**Para configurar um Raspberry Pi para AWS IoT Greengrass V2**
1. Configure o SSH no seu Raspberry Pi para se conectar remotamente a ele. Para mais informações, consulte [SSH (Secure shell)](https://www.raspberrypi.com/documentation/computers/remote-access.html#ssh) na *documentação do Raspberry Pi*.
1. Encontre o endereço IP do seu Raspberry Pi para se conectar a ele com o SSH. Para fazer isso, execute o seguinte comando no seu Raspberry Pi.
```
hostname -I
```
1. Conecte-se ao seu Raspberry Pi com o SSH.
Execute o comando a seguir no computador de desenvolvimento. *username*Substitua pelo nome do usuário a ser conectado e *pi-ip-address* substitua pelo endereço IP que você encontrou na etapa anterior.
```
ssh username@pi-ip-address
```
**Importante**
Se seu computador de desenvolvimento usa uma versão anterior do Windows, talvez você não tenha o comando `ssh` ou tenha `ssh`, mas não consiga se conectar ao seu Raspberry Pi. Para se conectar ao seu Raspberry Pi, você pode instalar e configurar o [PuTTY](https://www.chiark.greenend.org.uk/~sgtatham/putty/latest.html), que é um cliente SSH gratuito e de código aberto. Consulte a [documentação do PuTTY](https://tartarus.org/~simon/putty-snapshots/htmldoc/Chapter2.html#gs) para se conectar ao seu Raspberry Pi.
1. Instale o Java Runtime, que o software AWS IoT Greengrass Core exige para ser executado. No seu Raspberry Pi, use os seguintes comandos para instalar o Java 11.
```
sudo apt install default-jdk
```
Quando a instalação estiver concluída, execute o seguinte comando para verificar se o Java é executado no seu Raspberry Pi.
```
java -version
```
O comando imprime a versão do Java que é executada no dispositivo. O resultado pode ser semelhante ao seguinte exemplo.
```
openjdk version "11.0.9.1" 2020-11-04
OpenJDK Runtime Environment (build 11.0.9.1+1-post-Debian-1deb10u2)
OpenJDK 64-Bit Server VM (build 11.0.9.1+1-post-Debian-1deb10u2, mixed mode)
```
**Dica: defina os parâmetros do kernel em um Raspberry Pi**
Se o seu dispositivo for um Raspberry Pi, será possível concluir as etapas a seguir para visualizar e atualizar os parâmetros do kernel Linux:
Abra o arquivo `/boot/cmdline.txt`. Esse arquivo especifica os parâmetros do kernel Linux a serem aplicados quando o Raspberry Pi for inicializado.
Por exemplo, em um sistema baseado em Linux, você pode executar o comando a seguir para usar o GNU nano para abrir o arquivo.
```
sudo nano /boot/cmdline.txt
```
Verifique se o arquivo `/boot/cmdline.txt` contém os parâmetros do kernel a seguir. O parâmetro `systemd.unified_cgroup_hierarchy=0` especifica o uso de cgroups v1 em vez de cgroups v2.
```
cgroup_enable=memory cgroup_memory=1 systemd.unified_cgroup_hierarchy=0
```
Se o arquivo `/boot/cmdline.txt` não contiver esses parâmetros ou contiver esses parâmetros com valores diferentes, atualize o arquivo para conter esses parâmetros e valores.
Se você atualizou o arquivo `/boot/cmdline.txt`, reinicie o Raspberry Pi para aplicar as alterações.
```
sudo reboot
```
## Configurar um dispositivo Linux (outro)
**Para configurar um dispositivo Linux para AWS IoT Greengrass V2**
1. Instale o Java Runtime, que o software AWS IoT Greengrass Core exige para ser executado. Recomendamos que você use as versões de suporte de longo prazo do [Amazon Corretto](https://aws.amazon.com/corretto/) ou do [OpenJDK](https://openjdk.java.net/). A versão 8 ou superior é obrigatória. Os seguintes comandos mostram como instalar o OpenJDK no dispositivo.
+ Para distribuições com base em Debian ou em Ubuntu:
```
sudo apt install default-jdk
```
+ Para distribuições com base em Red Hat:
```
sudo yum install java-11-openjdk-devel
```
+ Para Amazon Linux 2:
```
sudo amazon-linux-extras install java-openjdk11
```
+ Para Amazon Linux 2023:
```
sudo dnf install java-11-amazon-corretto -y
```
Quando a instalação for concluída, execute o seguinte comando para verificar se o Java é executado no dispositivo Linux.
```
java -version
```
O comando imprime a versão do Java que é executada no dispositivo. Por exemplo, em uma distribuição baseada em Debian, o resultado pode ser semelhante ao seguinte exemplo.
```
openjdk version "11.0.9.1" 2020-11-04
OpenJDK Runtime Environment (build 11.0.9.1+1-post-Debian-1deb10u2)
OpenJDK 64-Bit Server VM (build 11.0.9.1+1-post-Debian-1deb10u2, mixed mode)
```
1. (Opcional) Crie o usuário e o grupo padrão do sistema que executa componentes no dispositivo. Você também pode optar por permitir que o instalador do software AWS IoT Greengrass Core crie esse usuário e grupo durante a instalação com o argumento do `--component-default-user` instalador. Para obter mais informações, consulte [Argumentos de instalação](configure-installer.md).
```
sudo useradd --system --create-home ggc_user
sudo groupadd --system ggc_group
```
1. Verifique se o usuário que executa o software AWS IoT Greengrass Core (normalmente`root`) tem permissão para executar `sudo` com qualquer usuário e qualquer grupo.
1. Execute o seguinte comando para abrir o arquivo `/etc/sudoers`.
```
sudo visudo
```
1. Verifique se a permissão do usuário se parece com o seguinte exemplo.
```
root ALL=(ALL:ALL) ALL
```
1. (Opcional) Para [executar funções do Lambda em contêineres](run-lambda-functions.md), habilite [cgroups](https://en.wikipedia.org/wiki/Cgroups) v1 e habilite e monte os cgroups de *memória* e *dispositivos*. Se você não planeja executar funções do Lambda em contêineres, ignore esta etapa.
Para habilitar essas opções de cgroups, inicialize o dispositivo com os seguintes parâmetros do kernel do Linux.
```
cgroup_enable=memory cgroup_memory=1 systemd.unified_cgroup_hierarchy=0
```
Para mais informações sobre como visualizar e definir parâmetros do kernel para o dispositivo, consulte a documentação do sistema operacional e do carregador de inicialização. Siga as instruções para definir permanentemente os parâmetros do kernel.
1. Instale todas as outras dependências necessárias no dispositivo, conforme indicado na lista de requisitos em [Requisitos do dispositivo](greengrass-nucleus-component.md#greengrass-v2-requirements).
## Configurar um dispositivo Windows
**Para configurar um dispositivo Windows para AWS IoT Greengrass V2**
1. Instale o Java Runtime, que o software AWS IoT Greengrass Core exige para ser executado. Recomendamos que você use as versões de suporte de longo prazo do [Amazon Corretto](https://aws.amazon.com/corretto/) ou do [OpenJDK](https://openjdk.java.net/). A versão 8 ou superior é obrigatória.
1. Verifique se o Java está disponível na variável de sistema [PATH](https://en.wikipedia.org/wiki/PATH_(variable)) e, caso contrário, adicione. A LocalSystem conta executa o software AWS IoT Greengrass Core, então você deve adicionar Java à variável de sistema PATH em vez da variável de usuário PATH para seu usuário. Faça o seguinte:
1. Pressione a tecla Windows para abrir o menu Iniciar.
1. Digite **environment variables** para pesquisar as opções do sistema no menu Iniciar.
1. Nos resultados da pesquisa do menu Iniciar, escolha **Editar as variáveis de ambiente do sistema** para abrir a janela **Propriedades do sistema**.
1. Escolha **Variáveis de ambiente...** para abrir a janela **Variáveis de ambiente**.
1. Em **Variáveis de Sistema**, selecione a variável **Path** e em seguida **Editar**. Na janela **Editar variável de ambiente**, você visualiza cada caminho em uma linha separada.
1. Verifique se o caminho para a pasta `bin` da instalação do Java está presente. O arquivo pode ser semelhante ao seguinte exemplo.
```
C:\\Program Files\\Amazon Corretto\\jdk11.0.13_8\\bin
```
1. Se a pasta `bin` da instalação do Java estiver ausente do **Path**, selecione **Novo** para adicioná-la e, em seguida, selecione **OK**.
1. Abra o prompt de comando do Windows (`cmd.exe`) como um administrador.
1. Crie o usuário padrão na LocalSystem conta no dispositivo Windows. *password*Substitua por uma senha segura.
```
net user /add ggc_user password
```
**dica**
Dependendo da configuração do Windows, a senha do usuário pode ser definida para expirar em uma data futura. Para garantir que as aplicações Greengrass continuem operando, monitore quando a senha expira e atualize-a antes disso. Também é possível definir que a senha nunca expire.
Para verificar quando um usuário e senha expiram, execute o comando a seguir.
```
net user ggc_user | findstr /C:expires
```
Para definir que a senha de um usuário nunca expire, execute o seguinte comando.
```
wmic UserAccount where "Name='ggc_user'" set PasswordExpires=False
```
Se você estiver usando o Windows 10 ou posterior, onde o [`wmic`comando está obsoleto](https://learn.microsoft.com/en-us/windows/win32/wmisdk/wmic), execute o comando a seguir. PowerShell
```
Get-CimInstance -Query "SELECT * from Win32_UserAccount WHERE name = 'ggc_user'" | Set-CimInstance -Property @{PasswordExpires="False"}
```
1. Baixe e instale o [PsExecutilitário](https://docs.microsoft.com/en-us/sysinternals/downloads/psexec) da Microsoft no dispositivo.
1. Use o PsExec utilitário para armazenar o nome de usuário e a senha do usuário padrão na instância do Credential Manager da LocalSystem conta. *password*Substitua pela senha do usuário que você definiu anteriormente.
```
psexec -s cmd /c cmdkey /generic:ggc_user /user:ggc_user /pass:password
```
Se **PsExec License Agreement** abrir, selecione **Accept** para concordar com a licença e execute o comando.
**nota**
Em dispositivos Windows, a LocalSystem conta executa o núcleo Greengrass, e você deve usar o PsExec utilitário para armazenar as informações padrão do usuário na conta. LocalSystem O uso do aplicativo Credential Manager armazena essas informações na conta do Windows do usuário atualmente conectado, em vez da LocalSystem conta.
# Etapa 3: instalar o software AWS IoT Greengrass principal
**dica**
Recomendamos que você experimente o [AWS IoT Greengrass AI Agents Context Pack](https://github.com/aws-greengrass/greengrass-agent-context-pack) para configurar e experimentar rapidamente o IoT Greengrass. AWS O pacote de contexto do agente permitirá que os agentes de IA configurem o Greengrass Nucleus e o Nucleus Lite, implantem componentes e solucionem problemas comuns.
Siga as etapas nesta seção para configurar seu Raspberry Pi como um dispositivo AWS IoT Greengrass principal que você pode usar para desenvolvimento local. Nesta seção, você baixa e executa um instalador que faz o seguinte para configurar o software AWS IoT Greengrass Core para seu dispositivo:
+ Instala o componente do núcleo do Greengrass. O núcleo é um componente obrigatório e é o requisito mínimo para executar o software AWS IoT Greengrass Core em um dispositivo. Para obter mais informações, consulte [Componente de núcleo do Greengrass](greengrass-nucleus-component.md).
+ Registra seu dispositivo como uma AWS IoT coisa e baixa um certificado digital que permite que seu dispositivo se conecte a. AWS Para obter mais informações, consulte [Autenticação e autorização de dispositivos para AWS IoT Greengrass](device-auth.md).
+ Adiciona a AWS IoT coisa do dispositivo a um grupo de coisas, que é um grupo ou frota de AWS IoT coisas. Thing groups permitem que você gerencie frotas de dispositivos principais do Greengrass. Ao implantar componentes de software em seus dispositivos, você pode optar por implantar em dispositivos individuais ou em grupos de dispositivos. Para obter mais informações, consulte [Managing devices with AWS IoT](https://docs.aws.amazon.com/iot/latest/developerguide/iot-thing-management.html) no *Guia do desenvolvedor do AWS IoT Core *.
+ Cria a função do IAM que permite que seu dispositivo principal do Greengrass interaja com AWS os serviços. Por padrão, essa função permite que seu dispositivo interaja AWS IoT e envie registros para o Amazon CloudWatch Logs. Para obter mais informações, consulte [Autorize os dispositivos principais a interagir com os serviços AWS](device-service-role.md).
+ Instala a interface de linha de AWS IoT Greengrass comando (`greengrass-cli`), que você pode usar para testar componentes personalizados que você desenvolve no dispositivo principal. Para obter mais informações, consulte [Interface de linha de comando do Greengrass](gg-cli.md).
# Instalar o software AWS IoT Greengrass Core (console)
1. Faça login no [console do AWS IoT Greengrass](https://console.aws.amazon.com/greengrass).
1. Em **Conceitos básicos do Greengrass**, escolha **Configuração de um dispositivo principal**.
1. Em **Etapa 1: Registrar um dispositivo principal do Greengrass**, em **Nome do dispositivo principal**, insira o nome do dispositivo AWS IoT principal do Greengrass. Se o objeto não existir, o instalador o cria.
1. Em **Etapa 2: Adicionar a um grupo de coisas para aplicar uma implantação contínua**, em **Thing group**, escolha o grupo de AWS IoT coisas ao qual você deseja adicionar seu dispositivo principal.
+ Se você selecionar **Inserir um novo nome de grupo**, em **Nome do grupo Thing**, insira o nome do novo grupo a ser criado. O instalador cria o novo grupo para você.
+ Se você **selecionar Selecionar um grupo existente**, em **Nome do grupo Thing**, escolha o grupo existente que você deseja usar.
+ Se você selecionar **Nenhum grupo**, o instalador não adicionará o dispositivo principal a um grupo de coisas.
1. Em **Etapa 3: Instalar o software Greengrass Core**, conclua as etapas a seguir.
------
#### [ Nucleus classic ]
1. Escolha **Nucleus classic** como o runtime do software do seu dispositivo principal.
1. Escolha o sistema operacional do seu dispositivo principal: **Linux** ou **Windows**.
1. Forneça as credenciais da AWS ao dispositivo para que o instalador possa provisionar os recursos do IAM e da AWS IoT necessários. Para aumentar a segurança, recomendamos que você obtenha credenciais temporárias para um perfil do IAM que habilite somente as permissões mínimas necessárias para provisionar. Para obter mais informações, consulte [Política mínima de IAM para o instalador provisionar recursos](provision-minimal-iam-policy.md).
**nota**
O instalador não salva nem armazena suas credenciais.
No seu dispositivo, faça o seguinte para recuperar as credenciais e disponibilizá-las para o instalador do software AWS IoT Greengrass Core:
+ (Recomendado) Use credenciais temporárias do Centro de Identidade do AWS IAM
1. Forneça o ID da chave de acesso, a chave de acesso secreta e o token de sessão do IAM Identity Center. Para obter mais informações, consulte **Atualização manual de credenciais** em [Como conseguir e atualizar credenciais temporárias](https://docs.aws.amazon.com/singlesignon/latest/userguide/howtogetcredentials.html#how-to-get-temp-credentials) no *Guia do usuário do Centro de Identidade do IAM*.
1. Use os comandos a seguir para fornecer credenciais ao software AWS IoT Greengrass Core.
------
#### [ Linux or Unix ]
```
export AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
export AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
export AWS_SESSION_TOKEN=AQoDYXdzEJr1K...o5OytwEXAMPLE=
```
------
#### [ Windows Command Prompt (CMD) ]
```
set AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
set AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
set AWS_SESSION_TOKEN=AQoDYXdzEJr1K...o5OytwEXAMPLE=
```
------
#### [ PowerShell ]
```
$env:AWS_ACCESS_KEY_ID="AKIAIOSFODNN7EXAMPLE"
$env:AWS_SECRET_ACCESS_KEY="wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
$env:AWS_SESSION_TOKEN="AQoDYXdzEJr1K...o5OytwEXAMPLE="
```
------
+ Use credenciais de segurança temporárias de um perfil do IAM:
1. Forneça o ID da chave de acesso, a chave de acesso secreta e o token de sessão do perfil do IAM que você assume. Para obter mais informações sobre como recuperar essas credenciais, consulte [Solicitação de credenciais de segurança temporárias](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html) no *Guia do usuário do IAM*.
1. Use os comandos a seguir para fornecer credenciais ao software AWS IoT Greengrass Core.
------
#### [ Linux or Unix ]
```
export AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
export AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
export AWS_SESSION_TOKEN=AQoDYXdzEJr1K...o5OytwEXAMPLE=
```
------
#### [ Windows Command Prompt (CMD) ]
```
set AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
set AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
set AWS_SESSION_TOKEN=AQoDYXdzEJr1K...o5OytwEXAMPLE=
```
------
#### [ PowerShell ]
```
$env:AWS_ACCESS_KEY_ID="AKIAIOSFODNN7EXAMPLE"
$env:AWS_SECRET_ACCESS_KEY="wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
$env:AWS_SESSION_TOKEN="AQoDYXdzEJr1K...o5OytwEXAMPLE="
```
------
+ Use credenciais de segurança de longo prazo de um usuário do IAM:
1. Forneça o ID da chave de acesso e a chave de acesso secreta para seu usuário do IAM. É possível criar um usuário do IAM para provisionamento que será excluído posteriormente. Para ver a política do IAM a ser fornecida ao usuário, consulte [Política mínima de IAM para o instalador provisionar recursos](provision-minimal-iam-policy.md). Para obter mais informações sobre como recuperar credenciais de longo prazo, consulte [Como gerenciar chaves de acesso para usuários do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html) no *Guia do usuário do IAM*.
1. Use os comandos a seguir para fornecer credenciais ao software AWS IoT Greengrass Core.
------
#### [ Linux or Unix ]
```
export AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
export AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
```
------
#### [ Windows Command Prompt (CMD) ]
```
set AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
set AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
```
------
#### [ PowerShell ]
```
$env:AWS_ACCESS_KEY_ID="AKIAIOSFODNN7EXAMPLE"
$env:AWS_SECRET_ACCESS_KEY="wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
```
------
1. (Opcional) Se você criou um usuário do IAM para provisionar seu dispositivo Greengrass, exclua o usuário.
1. (Opcional) Se você usou o ID da chave de acesso e a chave de acesso secreta de um usuário do IAM existente, atualize as chaves do usuário para que elas não sejam mais válidas. Para obter mais informações, consulte [Atualização de chaves de acesso](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html#Using_RotateAccessKey) no *Guia de usuário do AWS Identity and Access Management*.
1. Em **Executar o instalador**, conclua as etapas a seguir.
1. Em **Baixar o instalador**, escolha **Copiar** e execute o comando copiado no seu dispositivo principal. Esse comando baixa a versão mais recente do software AWS IoT Greengrass Core e a descompacta no seu dispositivo.
1. Em **Executar o instalador**, escolha **Copiar** e execute o comando copiado no seu dispositivo principal. Esse comando usa os nomes de AWS IoT coisas e grupos de coisas que você especificou anteriormente para executar o instalador do software AWS IoT Greengrass Core e configurar AWS recursos para seu dispositivo principal.
Esse comando também faz o seguinte:
+ Configure o software AWS IoT Greengrass Core como um serviço do sistema que é executado na inicialização. Em dispositivos Linux, isso requer o sistema init [Systemd](https://en.wikipedia.org/wiki/Systemd).
**Importante**
Nos dispositivos principais do Windows, é preciso configurar o software AWS IoT Greengrass Core como um serviço do sistema.
+ Implante o [componente AWS IoT Greengrass CLI](gg-cli.md), que é uma ferramenta de linha de comando que permite desenvolver componentes personalizados do Greengrass no dispositivo principal.
+ Especifique o uso do usuário do sistema `ggc_user` para executar componentes de software no dispositivo principal. Em dispositivos Linux, esse comando também especifica o uso do grupo do sistema `ggc_group` e o instalador cria o usuário e o grupo do sistema para você.
Ao executar esse comando, é necessário ver as seguintes mensagens para indicar que o instalador foi bem-sucedido.
```
Successfully configured Nucleus with provisioned resource details!
Configured Nucleus to deploy aws.greengrass.Cli component
Successfully set up Nucleus as a system service
```
**nota**
Se você tiver um dispositivo Linux e ele não tiver [systemd](https://en.wikipedia.org/wiki/Systemd), o instalador não configurará o software como um serviço do sistema e você não verá a mensagem de sucesso da configuração do núcleo como um serviço do sistema.
------
#### [ Nucleus lite ]
1. Escolha **Nucleus lite** como o runtime do software do seu dispositivo principal.
1. Selecione o método de configuração do seu dispositivo para provisionar seu dispositivo em um dispositivo principal do Greengrass.
**Opção 1: configurar um dispositivo com download de pacote (aproximadamente 1 MB)**
1. Crie uma coisa de AWS IoT e o perfil do Greengrass.
1. Baixe o arquivo zip que contém os recursos de AWS IoT os quais seu dispositivo precisa conectar à AWS IoT:
+ Um certificado e uma chave privada gerados usando a autoridade de certificação de AWS IoT.
+ Um arquivo de esquema para iniciar a instalação do Greengrass em seu dispositivo.
1. Baixe o pacote que instalará o runtime mais recente do Greengrass nucleus lite em seu Raspberry Pi.
1. Provisione seu dispositivo para se tornar um dispositivo AWS IoT Greengrass Core e conecte-o à AWS IoT:
1. a. Transfira o pacote Greengrass e o kit de conexão para o seu dispositivo usando um pen drive USB, SCP/FTP ou cartões SD.
1. b. Descompacte o arquivo greengrass-package.zip no diretório /GreengrassInstaller no dispositivo.
1. c. Descompacte o arquivo zip do kit de conexão no /diretório no dispositivo.
1. d. Execute o comando fornecido no dispositivo para instalar o AWS IoT Greengrass
1. Em seguida, escolha **Exibir dispositivos principais**.
**Opção 2: configurar um dispositivo com um download de imagem de amostra de disco inteiro pré-configurada (aproximadamente 100 MB)**
1. Crie uma coisa de AWS IoT e o perfil do Greengrass.
1. Baixe o arquivo zip que contém os recursos de AWS IoT os quais seu dispositivo precisa conectar à AWS IoT:
+ Um certificado e uma chave privada gerados usando a autoridade de certificação de AWS IoT.
+ Um arquivo de esquema para iniciar a instalação do Greengrass em seu dispositivo.
1. Faça o download da imagem de amostra de disco inteiro pré-configurada que contém o Greengrass e o sistema operacional.
1. Para transferir o kit de conexão e atualizar a imagem para o dispositivo, siga o arquivo readme baixado com a imagem.
1. Para iniciar a instalação do Greengrass, ligue e inicialize o dispositivo a partir da imagem descarregada
1. Em seguida, escolha **Exibir dispositivos principais**.
**Opção 3: configurar um dispositivo com sua própria compilação personalizada**
1. Crie uma coisa de AWS IoT e o perfil do Greengrass.
1. Baixe o arquivo zip que contém os recursos de AWS IoT os quais seu dispositivo precisa conectar à AWS IoT:
+ Um certificado e uma chave privada gerados usando a autoridade de certificação de AWS IoT.
+ Um arquivo de esquema para iniciar a instalação do Greengrass em seu dispositivo.
1. Para personalizar e criar sua própria imagem usando o Yocto a partir do código-fonte e, em seguida, usar o kit de conexão para instalar o nucleus lite, siga as instruções no GitHub.
1. Em seguida, escolha **Exibir dispositivos principais**.
------
# Instalar o software do AWS IoT Greengrass Core (CLI)
**nota**
Essas etapas não se aplicam ao nucleus lite.
**Para instalar e configurar o software AWS IoT Greengrass Core**
1. No seu dispositivo principal do Greengrass, execute o comando a seguir para alternar para o diretório de início.
------
#### [ Linux or Unix ]
```
cd ~
```
------
#### [ Windows Command Prompt (CMD) ]
```
cd %USERPROFILE%
```
------
#### [ PowerShell ]
```
cd ~
```
------
1. No dispositivo principal, baixe o software AWS IoT Greengrass Core para um arquivo chamado `greengrass-nucleus-latest.zip`.
------
#### [ Linux or Unix ]
```
curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip > greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
```
curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip > greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
```
iwr -Uri https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip -OutFile greengrass-nucleus-latest.zip
```
------
Ao fazer download desse software, você concorda com o [Contrato de licença do software do Greengrass Core](https://greengrass-release-license.s3.us-west-2.amazonaws.com/greengrass-license-v1.pdf).
1. Descompacte o software AWS IoT Greengrass Core em uma pasta no dispositivo. Substitua o *GreengrassInstaller* pela pasta que você deseja usar.
------
#### [ Linux or Unix ]
```
unzip greengrass-nucleus-latest.zip -d GreengrassInstaller && rm greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
```
mkdir GreengrassInstaller && tar -xf greengrass-nucleus-latest.zip -C GreengrassInstaller && del greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
```
Expand-Archive -Path greengrass-nucleus-latest.zip -DestinationPath .\\GreengrassInstaller
rm greengrass-nucleus-latest.zip
```
------
1. Execute o comando a seguir para iniciar o instalador do software AWS IoT Greengrass Core. Esse comando faz o seguinte:
+ Crie os recursos da AWS que o dispositivo principal precisa para operar.
+ Configure o software AWS IoT Greengrass Core como um serviço do sistema que é executado na inicialização. Em dispositivos Linux, isso requer o sistema init [Systemd](https://en.wikipedia.org/wiki/Systemd).
**Importante**
Nos dispositivos principais do Windows, é preciso configurar o software AWS IoT Greengrass Core como um serviço do sistema.
+ Implante o [componente AWS IoT Greengrass CLI](gg-cli.md), que é uma ferramenta de linha de comando que permite desenvolver componentes personalizados do Greengrass no dispositivo principal.
+ Especifique o uso do usuário do sistema `ggc_user` para executar componentes de software no dispositivo principal. Em dispositivos Linux, esse comando também especifica o uso do grupo do sistema `ggc_group` e o instalador cria o usuário e o grupo do sistema para você.
Substitua os valores dos argumentos no comando da seguinte maneira.
1. `/greengrass/v2` ou *C:\$1greengrass\$1v2*: o caminho para a pasta raiz a ser usada para instalar o software AWS IoT Greengrass Core.
1. *GreengrassInstaller*. O caminho para a pasta em que você descompactou o instalador do software AWS IoT Greengrass Core.
1. *region*. A região Região da AWS na qual encontrar ou criar recursos.
1. *MyGreengrassCore*. O nome do objeto da AWS IoT para seu dispositivo principal do Greengrass. Se o objeto não existir, o instalador o cria. O instalador baixa os certificados para autenticar o objeto da AWS IoT. Para obter mais informações, consulte [Autenticação e autorização de dispositivos para AWS IoT Greengrass](device-auth.md).
**nota**
O nome do objeto não pode conter caracteres de dois pontos (`:`).
1. *MyGreengrassCoreGroup*. O nome do objeto da AWS IoT para seu dispositivo principal do Greengrass. Se o grupo de objetos não existir, o instalador o cria e adiciona o objeto a ele. Se o grupo de objetos existir e tiver uma implantação ativa, o dispositivo principal baixará e executará o software especificado pela implantação.
**nota**
O nome do grupo de objetos não pode conter caracteres de dois pontos (`:`).
1. *GreengrassV2IoTThingPolicy*. O nome da política do AWS IoT que permite que os dispositivos principais do Greengrass se comuniquem com AWS IoT e AWS IoT Greengrass. Se a política do AWS IoT não existir, o instalador cria uma política permissiva do AWS IoT com esse nome. É possível restringir as permissões dessa política para seu caso de uso. Para obter mais informações, consulte [AWS IoT Política mínima para dispositivos AWS IoT Greengrass V2 principais](device-auth.md#greengrass-core-minimal-iot-policy).
1. *GreengrassV2TokenExchangeRole*. O nome do perfil do IAM que permite que o dispositivo principal do Greengrass obtenha credenciais temporárias da AWS. Se a função não existir, o instalador a criará e criará e anexará uma política chamada `GreengrassV2TokenExchangeRoleAccess`. Para obter mais informações, consulte [Autorize os dispositivos principais a interagir com os serviços AWS](device-service-role.md).
1. *GreengrassCoreTokenExchangeRoleAlias*. O alias para o perfil do IAM que permite que o dispositivo principal do Greengrass obtenha credenciais temporárias posteriormente. Se o alias do perfil não existir, o instalador o cria e o aponta para o perfil do IAM especificado por você. Para obter mais informações, consulte [Autorize os dispositivos principais a interagir com os serviços AWS](device-service-role.md).
------
#### [ Linux or Unix ]
```
sudo -E java -Droot="/greengrass/v2" -Dlog.store=FILE \
-jar ./GreengrassInstaller/lib/Greengrass.jar \
--aws-region region \
--thing-name MyGreengrassCore \
--thing-group-name MyGreengrassCoreGroup \
--thing-policy-name GreengrassV2IoTThingPolicy \
--tes-role-name GreengrassV2TokenExchangeRole \
--tes-role-alias-name GreengrassCoreTokenExchangeRoleAlias \
--component-default-user ggc_user:ggc_group \
--provision true \
--setup-system-service true \
--deploy-dev-tools true
```
------
#### [ Windows Command Prompt (CMD) ]
```
java -Droot="C:\greengrass\v2" "-Dlog.store=FILE" ^
-jar ./GreengrassInstaller/lib/Greengrass.jar ^
--aws-region region ^
--thing-name MyGreengrassCore ^
--thing-group-name MyGreengrassCoreGroup ^
--thing-policy-name GreengrassV2IoTThingPolicy ^
--tes-role-name GreengrassV2TokenExchangeRole ^
--tes-role-alias-name GreengrassCoreTokenExchangeRoleAlias ^
--component-default-user ggc_user ^
--provision true ^
--setup-system-service true ^
--deploy-dev-tools true
```
------
#### [ PowerShell ]
```
java -Droot="C:\greengrass\v2" "-Dlog.store=FILE" `
-jar ./GreengrassInstaller/lib/Greengrass.jar `
--aws-region region `
--thing-name MyGreengrassCore `
--thing-group-name MyGreengrassCoreGroup `
--thing-policy-name GreengrassV2IoTThingPolicy `
--tes-role-name GreengrassV2TokenExchangeRole `
--tes-role-alias-name GreengrassCoreTokenExchangeRoleAlias `
--component-default-user ggc_user `
--provision true `
--setup-system-service true `
--deploy-dev-tools true
```
------
**nota**
Se você estiver executando o AWS IoT Greengrass em um dispositivo com memória limitada, poderá controlar a quantidade de memória que o software AWS IoT Greengrass Core usa. Para controlar a alocação de memória, é possível definir as opções de tamanho do heap do JVM no parâmetro de configuração `jvmOptions` no componente do núcleo. Para obter mais informações, consulte [Controlar a alocação de memória com opções de JVM](configure-greengrass-core-v2.md#jvm-tuning).
Ao executar esse comando, é necessário ver as seguintes mensagens para indicar que o instalador foi bem-sucedido.
```
Successfully configured Nucleus with provisioned resource details!
Configured Nucleus to deploy aws.greengrass.Cli component
Successfully set up Nucleus as a system service
```
**nota**
Se você tiver um dispositivo Linux e ele não tiver [systemd](https://en.wikipedia.org/wiki/Systemd), o instalador não configurará o software como um serviço do sistema e você não verá a mensagem de sucesso da configuração do núcleo como um serviço do sistema.
# (Opcional) Execute o software Greengrass (Linux)
**nota**
Essas etapas não se aplicam ao nucleus lite.
Se você instalou o software como um serviço do sistema, o instalador executa o software para você. Caso contrário, será necessário executar o software. Para ver se o instalador configurou o software como um serviço do sistema, procure a seguinte linha na saída do instalador.
```
Successfully set up Nucleus as a system service
```
Caso não veja essa mensagem, faça o seguinte para executar o software:
1. Execute o comando a seguir para executar o software.
```
sudo /greengrass/v2/alts/current/distro/bin/loader
```
O software imprime a seguinte mensagem se for iniciado com êxito.
```
Launched Nucleus successfully.
```
1. Você deve deixar o shell de comando atual aberto para manter o software AWS IoT Greengrass Core em execução. Se você usa SSH para se conectar ao dispositivo principal, execute o comando a seguir em seu computador de desenvolvimento para abrir uma segunda sessão SSH que você pode usar para executar comandos adicionais no dispositivo principal. *username*Substitua pelo nome do usuário a ser conectado e *pi-ip-address* substitua pelo endereço IP do dispositivo.
```
ssh username@pi-ip-address
```
Para obter mais informações sobre como interagir com o serviço do sistema Greengrass, consulte [Configurar o Greengrass nucleus como um serviço do sistema](configure-greengrass-core-v2.md#configure-system-service).
# Verificar a instalação da CLI do Greengrass no dispositivo
**nota**
Essas etapas não se aplicam ao nucleus lite.
A implantação da CLI do Greengrass pode levar até um minuto. Execute o comando a seguir para obter o status da implantação. *MyGreengrassCore*Substitua pelo nome do seu dispositivo principal.
```
aws greengrassv2 list-effective-deployments --core-device-thing-name MyGreengrassCore
```
O `coreDeviceExecutionStatus` indica o status da implantação no dispositivo principal. Quando o status é `SUCCEEDED`, execute o comando abaixo para verificar se a CLI do Greengrass está instalada e em execução. Substitua `/greengrass/v2` pelo caminho para a pasta raiz.
------
#### [ Linux or Unix ]
```
/greengrass/v2/bin/greengrass-cli help
```
------
#### [ Windows Command Prompt (CMD) ]
```
C:\greengrass\v2\bin\greengrass-cli help
```
------
#### [ PowerShell ]
```
C:\greengrass\v2\bin\greengrass-cli help
```
------
O comando retorna informações de ajuda sobre a CLI do Greengrass. Se a `greengrass-cli` não for encontrada, talvez a implantação não tenha conseguido instalar a CLI do Greengrass. Para obter mais informações, consulte [Solução de problemas AWS IoT Greengrass V2](troubleshooting.md).
Você também pode executar o comando a seguir para implantar manualmente a AWS IoT Greengrass CLI no seu dispositivo.
+ *region*Substitua pelo Região da AWS que você usa. Certifique-se de usar o mesmo Região da AWS que você usou para configurar o AWS CLI em seu dispositivo.
+ *account-id*Substitua pelo seu Conta da AWS ID.
+ *MyGreengrassCore*Substitua pelo nome do seu dispositivo principal.
------
#### [ Linux, macOS, or Unix ]
```
aws greengrassv2 create-deployment \
--target-arn "arn:aws:iot:region:account-id:thing/MyGreengrassCore" \
--components '{
"aws.greengrass.Cli": {
"componentVersion": "2.16.1"
}
}'
```
------
#### [ Windows Command Prompt (CMD) ]
```
aws greengrassv2 create-deployment ^
--target-arn "arn:aws:iot:region:account-id:thing/MyGreengrassCore" ^
--components "{\"aws.greengrass.Cli\":{\"componentVersion\":\"2.16.1\"}}"
```
------
#### [ PowerShell ]
```
aws greengrassv2 create-deployment `
--target-arn "arn:aws:iot:region:account-id:thing/MyGreengrassCore" `
--components '{\"aws.greengrass.Cli\":{\"componentVersion\":\"2.16.1\"}}'
```
------
**dica**
É possível adicionar `/greengrass/v2/bin` (Linux) ou `C:\greengrass\v2\bin` (Windows) à variável de ambiente `PATH` para executar a `greengrass-cli` sem o caminho absoluto.
O software AWS IoT Greengrass principal e as ferramentas de desenvolvimento local são executados em seu dispositivo. Em seguida, você pode desenvolver um AWS IoT Greengrass componente Hello World em seu dispositivo.
# Etapa 4: desenvolver e testar um componente no dispositivo
Um componente é um módulo de software executado em dispositivos AWS IoT Greengrass principais. Os componentes permitem que você crie e gerencie aplicações complexas como componentes básicos que você pode reutilizar de um dispositivo principal do Greengrass para outro. Cada componente é composto por uma *fórmula* e *artefatos*.
+ **Fórmulas**
Cada componente contém um arquivo de fórmula, que define os metadados dele. A fórmula também especifica os parâmetros de configuração, 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 obter mais informações, consulte [AWS IoT Greengrass referência da receita do componente](component-recipe-reference.md).
Você pode definir fórmulas no formato [JSON](https://en.wikipedia.org/wiki/JSON) ou [YAML](https://en.wikipedia.org/wiki/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 deles.
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 [Desenvolver componentes do AWS IoT Greengrass](develop-greengrass-components.md).
Nesta seção, você aprende a criar e executar um componente básico do Hello World localmente no dispositivo principal.
**Para desenvolver um componente Hello World no seu dispositivo**
1. Crie uma pasta para seus componentes com subpastas para fórmulas 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 *\$1/greengrassv2* ou *%USERPROFILE%\$1greengrassv2* 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
```
------
1. Use um editor de texto para criar um arquivo de fórmula que defina os metadados, parâmetros, dependências, o ciclo de vida e a capacidade de plataforma do componente. Inclua a versão do componente no nome do arquivo da fórmula para que você possa identificar qual fórmula reflete qual versão do componente. Você pode escolher o formato YAML ou JSON para sua fórmula.
Por exemplo, em um sistema baseado em Linux, você pode executar o comando a seguir 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 mais informações, consulte a [especificação de versão semântica](https://semver.org/).
1. Cole a seguinte fórmula no arquivo.
------
#### [ JSON ]
```
{
"RecipeFormatVersion": "2020-01-25",
"ComponentName": "com.example.HelloWorld",
"ComponentVersion": "1.0.0",
"ComponentDescription": "My first AWS IoT Greengrass component.",
"ComponentPublisher": "Amazon",
"ComponentConfiguration": {
"DefaultConfiguration": {
"Message": "world"
}
},
"Manifests": [
{
"Platform": {
"os": "linux"
},
"Lifecycle": {
"run": "python3 -u {artifacts:path}/hello_world.py {configuration:/Message}"
}
},
{
"Platform": {
"os": "windows"
},
"Lifecycle": {
"run": "py -3 -u {artifacts:path}/hello_world.py {configuration:/Message}"
}
}
]
}
```
------
#### [ YAML ]
```
---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.HelloWorld
ComponentVersion: '1.0.0'
ComponentDescription: My first AWS IoT Greengrass component.
ComponentPublisher: Amazon
ComponentConfiguration:
DefaultConfiguration:
Message: world
Manifests:
- Platform:
os: linux
Lifecycle:
run: |
python3 -u {artifacts:path}/hello_world.py "{configuration:/Message}"
- Platform:
os: windows
Lifecycle:
run: |
py -3 -u {artifacts:path}/hello_world.py "{configuration:/Message}"
```
------
A seção `ComponentConfiguration` desta fórmula define um parâmetro, `Message`, cujo padrão é `world`. A seção `Manifests` define um *manifesto*, que é um conjunto de instruções e artefatos do ciclo de vida de uma plataforma. Por exemplo, é possível definir vários manifestos para especificar instruções de instalação diferentes para várias plataformas. No manifesto, a seção `Lifecycle` instrui o dispositivo principal do Greengrass a executar o script Hello World com o valor do parâmetro `Message` como argumento.
1. 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 formato a seguir para o caminho da pasta de artefatos. Inclua o nome e a versão do componente que você especificar na fórmula.
```
artifacts/componentName/componentVersion/
```
1. Use um editor de texto para criar um arquivo de artefato de script do Python para o componente Hello World.
Por exemplo, em um sistema baseado em Linux, você pode executar o comando a seguir 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)
```
1. 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:\$1greengrass\$1v2* por sua pasta AWS IoT Greengrass V2 raiz e substitua *\$1/greengrassv2* ou *%USERPROFILE%\$1greengrassv2* por sua 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 fórmula em `recipes` e o script Python em `artifacts`. A opção `--merge` adiciona ou atualiza o componente e a versão que você especificar.
1. 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 executa 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 comando `type` 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ê verá mensagens semelhantes ao exemplo a seguir.
```
Hello, world!
```
**nota**
Se o arquivo não existir, talvez a implantação local ainda não esteja concluída. Se o arquivo não existir em 15 segundos, a implantação provavelmente falhou. Isso pode ocorrer se sua fórmula 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 logs do serviço de implantação do dispositivo principal do Greengrass.
```
sudo tail -f /greengrass/v2/logs/greengrass.log
```
```
type C:\greengrass\v2\logs\greengrass.log
```
O comando `type` grava o conteúdo do arquivo no terminal. Execute esse comando várias vezes para observar as alterações no arquivo.
```
gc C:\greengrass\v2\logs\greengrass.log -Tail 10 -Wait
```
1. 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."
```
Agora, o script `hello_world.py` 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)
```
1. Execute o comando a seguir para atualizar o componente com as alterações.
------
#### [ 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 atualiza o componente `com.example.HelloWorld` com o artefato Hello World mais recente.
1. Execute o seguinte comando para reiniciar o componente. Quando você reinicia um componente, o dispositivo principal usa as alterações mais recentes.
------
#### [ Linux or Unix ]
```
sudo /greengrass/v2/bin/greengrass-cli component restart \
--names "com.example.HelloWorld"
```
------
#### [ Windows Command Prompt (CMD) ]
```
C:\greengrass\v2\bin\greengrass-cli component restart ^
--names "com.example.HelloWorld"
```
------
#### [ PowerShell ]
```
C:\greengrass\v2\bin\greengrass-cli component restart `
--names "com.example.HelloWorld"
```
------
1. Verifique o log 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 comando `type` 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ê verá mensagens semelhantes ao exemplo a seguir.
```
Hello, world! Greetings from your first Greengrass component.
```
1. Você pode atualizar os parâmetros de configuração do componente para testar configurações diferentes. Ao implantar um componente, é possível 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 obter mais informações, consulte [Atualizar configurações do componente](update-component-configurations.md).
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 comando a seguir para usar o GNU nano para criar o arquivo.
```
nano hello-world-config-update.json
```
1. Copie e cole o seguinte objeto JSON no arquivo. Esse objeto JSON define uma atualização de configuração que mescla o valor de `friend` ao parâmetro `Message` para atualizar o valor. Essa atualização de configuração não especifica nenhum valor a ser redefinido. Você não precisa redefinir o parâmetro `Message` porque a atualização de mesclagem substitui o valor existente.
```
{
"com.example.HelloWorld": {
"MERGE": {
"Message": "friend"
}
}
}
```
1. 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
```
------
1. Verifique o log 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 comando `type` 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ê verá mensagens semelhantes ao exemplo a seguir.
```
Hello, friend! Greetings from your first Greengrass component.
```
1. Depois de terminar de testar seu componente, remova-o do seu dispositivo principal. Execute o comando a seguir.
------
#### [ 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 componente `com.example.HelloWorld` não aparece na lista de componentes do 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.
# Etapa 5: Crie seu componente no AWS IoT Greengrass serviço
Ao concluir o desenvolvimento de um componente no dispositivo principal, você pode carregá-lo para o serviço AWS IoT Greengrass na Nuvem AWS. Você também pode criar o componente diretamente no [console do AWS IoT Greengrass](https://console.aws.amazon.com/greengrass). O AWS IoT Greengrass oferece um serviço de gerenciamento que hospeda seus componentes para que você possa implantá-los em dispositivos individuais ou em frotas de dispositivos. Para carregar um componente para o AWS IoT Greengrass serviço, você conclui as seguintes etapas:
+ Carregue os artefatos de componente em um bucket do S3.
+ Adicione o URI do Amazon Simple Storage Service (Amazon S3) de cada artefato à fórmula do componente.
+ Crie um componente a AWS IoT Greengrass partir da receita do componente.
Nesta seção, você conclui essas etapas em seu dispositivo principal do Greengrass para carregar seu componente Hello World no AWS IoT Greengrass serviço.
## Crie seu componente em AWS IoT Greengrass (console)
1. Use um bucket do S3 em sua AWS conta para hospedar artefatos de AWS IoT Greengrass componentes. Quando você implanta o componente em um dispositivo principal, o dispositivo faz download dos artefatos do componente do bucket.
Você pode usar um bucket do S3 existente ou criar um novo.
1. No [console do Amazon S3](https://console.aws.amazon.com/s3), em **Buckets**, escolha **Criar bucket**.
1. Em **Nome do bucket**, insira um nome exclusivo para o bucket. Por exemplo, você poderá usar o **greengrass-component-artifacts-*region*-*123456789012***. *123456789012*Substitua pelo ID da sua AWS conta e *region* pelo Região da AWS que você usa neste tutorial.
1. Para **AWS região**, selecione a AWS região que você usa para este tutorial.
1. Selecione **Criar bucket**.
1. Em **Buckets**, escolha o bucket que você criou e carregue o script `hello_world.py` para a pasta `artifacts/com.example.HelloWorld/1.0.0` no bucket. Para mais informações sobre como carregar objetos para buckets do S3, consulte [Como carregar objetos](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html) no *Guia do usuário do Amazon Simple Storage Service*.
1. Copie o URI do S3 do objeto `hello_world.py` no bucket do S3. A aparência do URI deve ser semelhante ao exemplo a seguir. Substitua amzn-s3-demo-bucket pelo nome do bucket do S3.
```
s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py
```
1. Permita que o dispositivo principal acesse os artefatos do componente no bucket do S3.
Cada dispositivo principal tem uma [função de IAM do dispositivo principal](device-service-role.md) que permite interagir AWS IoT e enviar registros para a AWS nuvem. Essa função de dispositivo não permite acesso aos buckets do S3 por padrão, então você deve criar e anexar uma política que permita que o dispositivo principal recupere artefatos do componente do bucket do S3.
Se a função do seu dispositivo já permitir o acesso ao bucket do S3, você pode ignorar essa etapa. Caso contrário, crie uma política do IAM que permita acesso e anexe-a à função, da seguinte forma:
1. No menu de navegação do [console do IAM](https://console.aws.amazon.com/iam), escolha **Políticas** e **Criar política**.
1. Na guia **JSON**, substitua o conteúdo do espaço reservado pela política a seguir. Substitua amzn-s3-demo-bucket pelo nome do bucket do S3 que contém os artefatos do componente que serão baixados do dispositivo principal.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject"
],
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*"
}
]
}
```
1. Escolha **Próximo**.
1. Na **seção Detalhes da política**, insira **MyGreengrassV2ComponentArtifactPolicy** em **Nome**.
1. Selecione **Criar política**.
1. No menu de navegação do [console do IAM](https://console.aws.amazon.com/iam), escolha **Role** e, em seguida, escolha o nome da função para o dispositivo principal. Você especificou esse nome de função ao instalar o software AWS IoT Greengrass Core. Se você não especificou um nome, o padrão é `GreengrassV2TokenExchangeRole`.
1. Em **Permissões**, escolha **Adicionar permissões** e **Anexar políticas**.
1. Na página **Adicionar permissões**, marque a caixa de seleção ao lado da política `MyGreengrassV2ComponentArtifactPolicy` que você criou e escolha **Adicionar permissões**.
1. Use a fórmula do componente para criar um componente no [console do AWS IoT Greengrass](https://console.aws.amazon.com/greengrass).
1. No menu de navegação do [console do AWS IoT Greengrass](https://console.aws.amazon.com/greengrass), escolha **Componentes** e **Criar componente**.
1. Em **Informações do componente**, escolha **Inserir fórmula como JSON**. A fórmula no espaço reservado deve ser semelhante ao exemplo a seguir.
```
{
"RecipeFormatVersion": "2020-01-25",
"ComponentName": "com.example.HelloWorld",
"ComponentVersion": "1.0.0",
"ComponentDescription": "My first AWS IoT Greengrass component.",
"ComponentPublisher": "Amazon",
"ComponentConfiguration": {
"DefaultConfiguration": {
"Message": "world"
}
},
"Manifests": [
{
"Platform": {
"os": "linux"
},
"Lifecycle": {
"Run": "python3 -u {artifacts:path}/hello_world.py \"{configuration:/Message}\""
},
"Artifacts": [
{
"URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py"
}
]
},
{
"Platform": {
"os": "windows"
},
"Lifecycle": {
"Run": "py -3 -u {artifacts:path}/hello_world.py \"{configuration:/Message}\""
},
"Artifacts": [
{
"URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py"
}
]
}
]
}
```
1. Substitua o URI no espaço reservado em cada seção `Artifacts` pelo URI do S3 do objeto `hello_world.py`.
1. Escolha **Criar componente**.
1. No **com.example. HelloWorld**página do componente, verifique se o **status** do componente é **Implantável**.
## Crie seu componente em AWS IoT Greengrass (AWS CLI)
**Para carregar o componente Hello World**
1. Use um bucket do S3 em seu Conta da AWS para hospedar artefatos de AWS IoT Greengrass componentes. Quando você implanta o componente em um dispositivo principal, o dispositivo faz download dos artefatos do componente do bucket.
Você pode usar um bucket do S3 existente ou executar o comando a seguir para criar um bucket. Esse comando cria um bucket com seu Conta da AWS ID e Região da AWS forma um nome de bucket exclusivo. *123456789012*Substitua pelo seu Conta da AWS ID e *region* pelo Região da AWS que você usa neste tutorial.
```
aws s3 mb s3://greengrass-component-artifacts-123456789012-region
```
O comando retorna as informações a seguir quando a solicitação é bem-sucedida.
```
make_bucket: greengrass-component-artifacts-123456789012-region
```
1. Permita que o dispositivo principal acesse os artefatos do componente no bucket do S3.
Cada dispositivo principal tem uma [função IAM do dispositivo principal](device-service-role.md) que permite interagir AWS IoT e enviar registros para Nuvem AWS o. Por padrão, esse perfil do dispositivo não permite acesso aos buckets do S3, portanto você deve criar e anexar uma política que permita que o dispositivo principal recupere os artefatos do componente do bucket do S3.
Se o perfil do dispositivo principal já permitir o acesso ao bucket do S3, você poderá ignorar esta etapa. Caso contrário, crie uma política do IAM que permita acesso e anexe-a ao perfil da seguinte forma:
1. Crie um arquivo chamado `component-artifact-policy.json` e copie o JSON a seguir no arquivo. Essa política permite acesso a todos os arquivos em um bucket do S3. Substitua amzn-s3-demo-bucket pelo nome do bucket do S3.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject"
],
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*"
}
]
}
```
1. Execute o comando a seguir para criar a política com base no documento em `component-artifact-policy.json`.
------
#### [ Linux or Unix ]
```
aws iam create-policy \\
--policy-name MyGreengrassV2ComponentArtifactPolicy \\
--policy-document file://component-artifact-policy.json
```
------
#### [ Windows Command Prompt (CMD) ]
```
aws iam create-policy ^
--policy-name MyGreengrassV2ComponentArtifactPolicy ^
--policy-document file://component-artifact-policy.json
```
------
#### [ PowerShell ]
```
aws iam create-policy `
--policy-name MyGreengrassV2ComponentArtifactPolicy `
--policy-document file://component-artifact-policy.json
```
------
Copie o nome do recurso da Amazon (ARN) da política dos metadados na saída. Na próxima etapa, você vai usar esse ARN para anexar a política ao perfil do dispositivo principal.
1. Execute o comando a seguir para anexar a política ao perfil do dispositivo principal. *GreengrassV2TokenExchangeRole*Substitua pelo nome da função do dispositivo principal. Você especificou esse nome de função ao instalar o software AWS IoT Greengrass Core. Substitua o ARN da política pelo ARN da etapa anterior.
------
#### [ Linux or Unix ]
```
aws iam attach-role-policy \\
--role-name GreengrassV2TokenExchangeRole \\
--policy-arn arn:aws:iam::123456789012:policy/MyGreengrassV2ComponentArtifactPolicy
```
------
#### [ Windows Command Prompt (CMD) ]
```
aws iam attach-role-policy ^
--role-name GreengrassV2TokenExchangeRole ^
--policy-arn arn:aws:iam::123456789012:policy/MyGreengrassV2ComponentArtifactPolicy
```
------
#### [ PowerShell ]
```
aws iam attach-role-policy `
--role-name GreengrassV2TokenExchangeRole `
--policy-arn arn:aws:iam::123456789012:policy/MyGreengrassV2ComponentArtifactPolicy
```
------
Se for bem-sucedido, o comando não retornará nada. Agora o dispositivo principal pode acessar os artefatos que você carregou nesse bucket do S3.
1. Carregue o artefato do script Hello World em Python para o bucket do S3.
Execute o comando a seguir para carregar o script no mesmo caminho no bucket em que o script existe no seu AWS IoT Greengrass núcleo. Substitua amzn-s3-demo-bucket pelo nome do bucket do S3.
------
#### [ Linux or Unix ]
```
aws s3 cp \
artifacts/com.example.HelloWorld/1.0.0/hello_world.py \
s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py
```
------
#### [ Windows Command Prompt (CMD) ]
```
aws s3 cp ^
artifacts/com.example.HelloWorld/1.0.0/hello_world.py ^
s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py
```
------
#### [ PowerShell ]
```
aws s3 cp `
artifacts/com.example.HelloWorld/1.0.0/hello_world.py `
s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py
```
------
O comando retornará uma linha que começa com `upload:` se a solicitação for bem-sucedida.
1. Adicione o URI do Amazon S3 do artefato à fórmula do componente.
O URI do Amazon S3 é composto do nome do bucket e do caminho para o objeto de artefato no bucket. O URI do Amazon S3 do artefato no script é onde você carregou o artefato na etapa anterior. A aparência do URI deve ser semelhante ao exemplo a seguir. Substitua amzn-s3-demo-bucket pelo nome do bucket do S3.
```
s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py
```
Para adicionar o artefato à fórmula, adicione uma lista de `Artifacts` que contenha uma estrutura com o URI do Amazon S3.
------
#### [ JSON ]
```
"Artifacts": [
{
"URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py"
}
]
```
Abra o arquivo da fórmula em um editor de texto.
Por exemplo, em um sistema baseado em Linux, você pode executar o comando a seguir para usar o GNU nano para criar o arquivo.
```
nano recipes/com.example.HelloWorld-1.0.0.json
```
Adicione o artefato à fórmula. O arquivo da fórmula deve ser semelhante ao exemplo a seguir.
```
{
"RecipeFormatVersion": "2020-01-25",
"ComponentName": "com.example.HelloWorld",
"ComponentVersion": "1.0.0",
"ComponentDescription": "My first AWS IoT Greengrass component.",
"ComponentPublisher": "Amazon",
"ComponentConfiguration": {
"DefaultConfiguration": {
"Message": "world"
}
},
"Manifests": [
{
"Platform": {
"os": "linux"
},
"Lifecycle": {
"Run": "python3 -u {artifacts:path}/hello_world.py \"{configuration:/Message}\""
},
"Artifacts": [
{
"URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py"
}
]
},
{
"Platform": {
"os": "windows"
},
"Lifecycle": {
"Run": "py -3 -u {artifacts:path}/hello_world.py \"{configuration:/Message}\""
},
"Artifacts": [
{
"URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py"
}
]
}
]
}
```
------
#### [ YAML ]
```
Artifacts:
- URI: s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py
```
Abra o arquivo da fórmula em um editor de texto.
Por exemplo, em um sistema baseado em Linux, você pode executar o comando a seguir para usar o GNU nano para criar o arquivo.
```
nano recipes/com.example.HelloWorld-1.0.0.yaml
```
Adicione o artefato à fórmula. O arquivo da fórmula deve ser semelhante ao exemplo a seguir.
```
---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.HelloWorld
ComponentVersion: '1.0.0'
ComponentDescription: My first AWS IoT Greengrass component.
ComponentPublisher: Amazon
ComponentConfiguration:
DefaultConfiguration:
Message: world
Manifests:
- Platform:
os: linux
Lifecycle:
Run: |
python3 -u {artifacts:path}/hello_world.py "{configuration:/Message}"
Artifacts:
- URI: s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py
- Platform:
os: windows
Lifecycle:
Run: |
py -3 -u {artifacts:path}/hello_world.py "{configuration:/Message}"
Artifacts:
- URI: s3://amzn-s3-demo-bucket/artifacts/com.example.HelloWorld/1.0.0/hello_world.py
```
------
1. Crie um recurso de componente a AWS IoT Greengrass partir da receita. Execute o comando a seguir para criar o componente com base na fórmula, que você fornece como um arquivo binário.
------
#### [ JSON ]
```
aws greengrassv2 create-component-version --inline-recipe fileb://recipes/com.example.HelloWorld-1.0.0.json
```
------
#### [ YAML ]
```
aws greengrassv2 create-component-version --inline-recipe fileb://recipes/com.example.HelloWorld-1.0.0.yaml
```
------
Se a solicitação for bem-sucedida, a resposta será semelhante ao exemplo a seguir.
```
{
"arn": "arn:aws:greengrass:region:123456789012:components:com.example.HelloWorld:versions:1.0.0",
"componentName": "com.example.HelloWorld",
"componentVersion": "1.0.0",
"creationTimestamp": "Mon Nov 30 09:04:05 UTC 2020",
"status": {
"componentState": "REQUESTED",
"message": "NONE",
"errors": {}
}
}
```
Copie o `arn` da saída para verificar o estado do componente na próxima etapa.
**nota**
Você também pode ver o componente Hello World no [console do AWS IoT Greengrass](https://console.aws.amazon.com/greengrass) na página **Componentes**.
1. Verifique se o componente foi criado e está pronto para ser implantado. Quando você cria um componente, o estado dele é `REQUESTED`. Em seguida, AWS IoT Greengrass valida se o componente é implantável. Você pode executar o comando a seguir para consultar o status do componente e verificar se ele é implantável. Substitua `arn` pelo ARN da etapa anterior.
```
aws greengrassv2 describe-component --arn "arn:aws:greengrass:region:123456789012:components:com.example.HelloWorld:versions:1.0.0"
```
Se o componente for validado, a resposta indicará que o estado dele é `DEPLOYABLE`.
```
{
"arn": "arn:aws:greengrass:region:123456789012:components:com.example.HelloWorld:versions:1.0.0",
"componentName": "com.example.HelloWorld",
"componentVersion": "1.0.0",
"creationTimestamp": "2020-11-30T18:04:05.823Z",
"publisher": "Amazon",
"description": "My first Greengrass component.",
"status": {
"componentState": "DEPLOYABLE",
"message": "NONE",
"errors": {}
},
"platforms": [
{
"os": "linux",
"architecture": "all"
}
]
}
```
Seu componente Hello World agora está disponível em AWS IoT Greengrass. Você pode implantá-lo de volta nesse dispositivo principal do Greengrass ou em outros.
# Etapa 6: implantar seu componente
Com o AWS IoT Greengrass, é possível implantar componentes em dispositivos individuais ou grupos de dispositivos. Quando você implanta um componente, o AWS IoT Greengrass instala e executa o software desse componente em cada dispositivo de destino. Você especifica quais componentes implantar e a atualização de configuração a ser implantada para cada um. Você também pode controlar como a implantação é implementada nos dispositivos visados pela implantação. Para obter mais informações, consulte [Implemente AWS IoT Greengrass componentes em dispositivos](manage-deployments.md).
Nesta seção, você implanta seu componente Hello World de volta ao seu dispositivo principal do Greengrass.
## Implantar seus componentes (console)
1. No menu de navegação do [console do AWS IoT Greengrass](https://console.aws.amazon.com/greengrass), selecione **Componentes**.
1. Na página **Componentes**, na guia **Meus componentes**, escolha **com.example.HelloWorld**.
1. Na página **com.example.HelloWorld**, escolha **Implantar**.
1. Em **Adicionar à implantação**, escolha **Criar nova implantação** e, em seguida, **Avançar**.
1. Na página **Especificar detalhes**, faça o seguinte:
1. Na caixa **Name** (Nome), insira **Deployment for MyGreengrassCore**.
1. Em **Destino de implantação**, escolha **Dispositivo principal** e o nome do objeto da AWS IoT para seu dispositivo principal. O valor padrão neste tutorial é *MyGreengrasscore*.
1. Escolha **Próximo**.
1. Na página **Selecionar componentes**, em **Meus componentes**, verifique se o componente **com.example.HelloWorld** está selecionado e escolha **Avançar**.
1. Na página **Configurar componentes**, selecione **com.example.HelloWorld** 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.
```
{
"Message": "universe"
}
```
Essa atualização de configuração define o parâmetro `Message` Hello World para `universe` para o dispositivo nesta implantação.
1. Escolha **Confirmar**.
1. Escolha **Próximo**.
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**.
1. Verifique se a implantação foi concluída com êxito. A implantação pode levar vários minutos para ser concluída. Verifique o log do Hello World para ver a alteração. Execute o comando a seguir em seu dispositivo principal do Greengrass.
------
#### [ 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
```
------
#### [ PowerShell ]
```
gc C:\greengrass\v2\\logs\\com.example.HelloWorld.log -Tail 10 -Wait
```
------
Você verá mensagens semelhantes ao exemplo a seguir.
```
Hello, universe! Greetings from your first Greengrass component.
```
**nota**
Se as mensagens de log não mudarem, a implantação falhou ou não atingiu o dispositivo principal. Isso pode ocorrer se o seu dispositivo principal não estiver conectado à Internet ou não tiver permissões para recuperar artefatos do bucket do S3. Execute o seguinte comando no seu dispositivo principal para visualizar o arquivo de log do software AWS IoT Greengrass Core. Esse arquivo inclui logs do serviço de implantação do dispositivo principal do Greengrass.
```
sudo tail -f /greengrass/v2/logs/greengrass.log
```
```
type C:\greengrass\v2\\logs\\greengrass.log
```
O comando `type` grava o conteúdo do arquivo no terminal. Execute esse comando várias vezes para observar as alterações no arquivo.
```
gc C:\greengrass\v2\\logs\\greengrass.log -Tail 10 -Wait
```
Para obter mais informações, consulte [Solução de problemas AWS IoT Greengrass V2](troubleshooting.md).
## Implantar seu componente (AWS CLI)
**Para desenvolver um componente Hello World**
1. No seu computador de desenvolvimento, crie um arquivo chamado `hello-world-deployment.json` e copie o seguinte JSON para o arquivo. Esse arquivo define os componentes e as configurações a serem implantados.
```
{
"components": {
"com.example.HelloWorld": {
"componentVersion": "1.0.0",
"configurationUpdate": {
"merge": "{\"Message\":\"universe\"}"
}
}
}
}
```
Esse arquivo de configuração especifica a implantação da versão `1.0.0` do componente Hello World que você desenvolveu e publicou no procedimento anterior. O `configurationUpdate` especifica a mesclagem da configuração do componente em uma string codificada em JSON. Essa atualização de configuração define o parâmetro `Message` Hello World para `universe` para o dispositivo nesta implantação.
1. Execute o seguinte comando para implantar o componente no seu dispositivo principal do Greengrass. É possível implantar em objetos, que são dispositivos individuais, ou grupos de objetos, que são grupos de dispositivos. Substitua *MyGreengrassCore* pelo nome do objeto da AWS IoT para seu dispositivo principal.
------
#### [ Linux or Unix ]
```
aws greengrassv2 create-deployment \
--target-arn "arn:aws:iot:region:account-id:thing/MyGreengrassCore" \
--cli-input-json file://hello-world-deployment.json
```
------
#### [ Windows Command Prompt (CMD) ]
```
aws greengrassv2 create-deployment ^
--target-arn "arn:aws:iot:region:account-id:thing/MyGreengrassCore" ^
--cli-input-json file://hello-world-deployment.json
```
------
#### [ PowerShell ]
```
aws greengrassv2 create-deployment `
--target-arn "arn:aws:iot:region:account-id:thing/MyGreengrassCore" `
--cli-input-json file://hello-world-deployment.json
```
------
O comando gera uma resposta semelhante ao exemplo a seguir.
```
{
"deploymentId": "deb69c37-314a-4369-a6a1-3dff9fce73a9",
"iotJobId": "b5d92151-6348-4941-8603-bdbfb3e02b75",
"iotJobArn": "arn:aws:iot:region:account-id:job/b5d92151-6348-4941-8603-bdbfb3e02b75"
}
```
1. Verifique se a implantação foi concluída com êxito. A implantação pode levar vários minutos para ser concluída. Verifique o log do Hello World para ver a alteração. Execute o comando a seguir em seu dispositivo principal do Greengrass.
------
#### [ 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
```
------
#### [ PowerShell ]
```
gc C:\greengrass\v2\\logs\\com.example.HelloWorld.log -Tail 10 -Wait
```
------
Você verá mensagens semelhantes ao exemplo a seguir.
```
Hello, universe! Greetings from your first Greengrass component.
```
**nota**
Se as mensagens de log não mudarem, a implantação falhou ou não atingiu o dispositivo principal. Isso pode ocorrer se o seu dispositivo principal não estiver conectado à Internet ou não tiver permissões para recuperar artefatos do bucket do S3. Execute o seguinte comando no seu dispositivo principal para visualizar o arquivo de log do software AWS IoT Greengrass Core. Esse arquivo inclui logs do serviço de implantação do dispositivo principal do Greengrass.
```
sudo tail -f /greengrass/v2/logs/greengrass.log
```
```
type C:\greengrass\v2\\logs\\greengrass.log
```
O comando `type` grava o conteúdo do arquivo no terminal. Execute esse comando várias vezes para observar as alterações no arquivo.
```
gc C:\greengrass\v2\\logs\\greengrass.log -Tail 10 -Wait
```
Para obter mais informações, consulte [Solução de problemas AWS IoT Greengrass V2](troubleshooting.md).
# Próximas etapas
Você concluiu este tutorial. O software AWS IoT Greengrass Core e seu componente Hello World são executados no dispositivo. Além disso, seu componente Hello World está disponível no serviço de nuvem do AWS IoT Greengrass para ser implantado em outros dispositivos. Para obter mais informações sobre os tópicos deste tutorial, consulte o seguinte:
+ [Criar componentes do AWS IoT Greengrass](create-components.md)
+ [Publish components to deploy to your core devices](publish-components.md)
+ [Implemente AWS IoT Greengrass componentes em dispositivos](manage-deployments.md)