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á.
# Configurando dispositivos AWS IoT Greengrass principais
Conclua as tarefas nesta seção para instalar, configurar e executar o software AWS IoT Greengrass principal.
**nota**
Esta seção descreve a instalação e a configuração avançadas do software AWS IoT Greengrass Core. Essas etapas não se aplicam ao nucleus Lite.Se você é um usuário iniciante do AWS IoT Greengrass V2, recomendamos que você primeiro conclua o [tutorial de introdução](getting-started.md) para configurar um dispositivo principal e explorar os recursos do. AWS IoT Greengrass
**Topics**
+ [Plataformas compatíveis](#supported-platforms)
+ [Requisitos do dispositivo](#device-requirements)
+ [Requisitos da função do Lambda](#greengrass-v2-lambda-requirements)
+ [Configurar um Conta da AWS](#set-up-aws-account)
+ [Instalar o software do AWS IoT Greengrass Core](install-greengrass-core-v2.md)
+ [Execute o software AWS IoT Greengrass Core](run-greengrass-core-v2.md)
+ [Execute AWS IoT Greengrass o software Core em um contêiner Docker](run-greengrass-docker.md)
+ [Configurar o software AWS IoT Greengrass principal](configure-greengrass-core-v2.md)
+ [Atualizar o software de núcleo do AWS IoT Greengrass (OTA)](update-greengrass-core-v2.md)
+ [Desinstalar o software de núcleo do AWS IoT Greengrass](uninstall-greengrass-core-v2.md)
## Plataformas compatíveis
+ [Plataformas com suporte ao Greengrass nucleus](https://docs.aws.amazon.com/greengrass/v2/developerguide/greengrass-nucleus-component.html)
+ [Plataformas com suporte ao Greengrass nucleus lite](https://docs.aws.amazon.com/greengrass/v2/developerguide/greengrass-nucleus-lite-component.html)
## Requisitos do dispositivo
+ [Requisitos de dispositivo do Greengrass nucleus](https://docs.aws.amazon.com/greengrass/v2/developerguide/greengrass-nucleus-component.html)
+ [Requisitos de dispositivo do Greengrass nucleus lite](https://docs.aws.amazon.com/greengrass/v2/developerguide/greengrass-nucleus-lite-component.html)
## Requisitos da função do Lambda
**Importante**
Atualmente, não há suporte para funções do Lambda no Greengrass nucleus lite.
O dispositivo deve atender aos seguintes requisitos para executar funções do Lambda:
+ Um sistema operacional baseado em Linux.
+ O dispositivo deve ter o comando de shell `mkfifo`.
+ O dispositivo deve executar as bibliotecas de linguagem de programação obrigatórias para uma função do Lambda. É necessário instalar as bibliotecas obrigatórias no dispositivo e adicioná-las à variável de ambiente `PATH`. O Greengrass oferece suporte a todas as versões compatíveis com o Lambda dos runtimes Python, Node.js e Java. O Greengrass não impõe nenhuma outra restrição às versões de runtime obsoletas do Lambda. Para obter mais informações sobre o AWS IoT Greengrass suporte para tempos de execução do Lambda, consulte. [Executar funções AWS Lambda.](run-lambda-functions.md)
+ Para executar funções do Lambda em contêiner, o dispositivo deve atender aos seguintes requisitos:
+ Kernel Linux versão 4.4 ou posterior.
+ O kernel deve ser compatível com [cgroups](https://en.wikipedia.org/wiki/Cgroups) v1, e é necessário habilitar e montar os seguintes cgroups:
+ O cgroup de *memória* AWS IoT Greengrass para definir o limite de memória para funções Lambda em contêineres.
+ O cgroup de *dispositivos* para funções do Lambda em contêiner para acessar dispositivos ou volumes do sistema.
O software AWS IoT Greengrass Core não suporta cgroups v2.
Para atender a esse requisito, inicialize o dispositivo com os parâmetros do kernel do Linux a seguir.
```
cgroup_enable=memory cgroup_memory=1 systemd.unified_cgroup_hierarchy=0
```
**dica**
Em um Raspberry Pi, edite o arquivo `/boot/cmdline.txt` para definir os parâmetros do kernel do dispositivo.
+ É necessário habilitar as seguintes configurações do kernel do Linux no dispositivo:
+ Namespace:
+ `CONFIG_IPC_NS`
+ `CONFIG_UTS_NS`
+ `CONFIG_USER_NS`
+ `CONFIG_PID_NS`
+ Cgroups:
+ `CONFIG_CGROUP_DEVICE`
+ `CONFIG_CGROUPS`
+ `CONFIG_MEMCG`
+ Outros:
+ `CONFIG_POSIX_MQUEUE`
+ `CONFIG_OVERLAY_FS`
+ `CONFIG_HAVE_ARCH_SECCOMP_FILTER`
+ `CONFIG_SECCOMP_FILTER`
+ `CONFIG_KEYS`
+ `CONFIG_SECCOMP`
+ `CONFIG_SHMEM`
**dica**
Consulte a documentação referente à sua distribuição Linux para saber como verificar e definir parâmetros do kernel do Linux. Você também pode usar AWS IoT Device Tester for AWS IoT Greengrass para verificar se seu dispositivo atende a esses requisitos. Para obter mais informações, consulte [Como usar o AWS IoT Device Tester para o AWS IoT Greengrass V2](device-tester-for-greengrass-ug.md).
## Configurar 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).
Para criar um usuário administrador, selecione uma das opções a seguir.
****
| Selecionar uma forma de gerenciar o administrador | Para | Por | Você também pode |
| --- | --- | --- | --- |
| Centro de Identidade do IAM (Recomendado) | Usar credenciais de curto prazo para acessar a AWS.Isso está de acordo com as práticas recomendadas de segurança. Para obter informações sobre as práticas recomendadas, consulte [Práticas recomendadas de segurança no IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#bp-users-federation-idp) no *Guia do usuário do IAM*. | Seguindo as instruções em [Conceitos básicos](https://docs.aws.amazon.com//singlesignon/latest/userguide/getting-started.html) no Guia do usuário do Centro de Identidade do AWS IAM . | Configure o acesso programático [configurando o AWS CLI para uso Centro de Identidade do AWS IAM](https://docs.aws.amazon.com//cli/latest/userguide/cli-configure-sso.html) no Guia do AWS Command Line Interface usuário. |
| No IAM (Não recomendado) | Usar credenciais de longo prazo para acessar a AWS. | Seguindo as instruções em [Criar um acesso de emergência para um usuário do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/getting-started-emergency-iam-user.html) no Guia do usuário do IAM. | Configurar o acesso programático, com base em [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. |
# Instalar o software do AWS IoT Greengrass Core
O AWS IoT Greengrass estende a AWS a dispositivos de borda para que eles possam agir com base nos dados que geram, ao mesmo tempo em que usam a Nuvem AWS para gerenciamento, analytics e armazenamento resiliente. Instale o software AWS IoT Greengrass Core em dispositivos de ponta para integração com AWS IoT Greengrass Nuvem AWS o.
**Importante**
Antes de baixar e instalar o software AWS IoT Greengrass Core, verifique se seu dispositivo principal atende aos [requisitos](greengrass-nucleus-component.md#greengrass-v2-requirements) para instalar e executar o software AWS IoT Greengrass Core v2.0.
O software AWS IoT Greengrass Core inclui um instalador que configura seu dispositivo como um dispositivo principal do Greengrass. Ao executar o instalador, você pode configurar opções, como a pasta raiz e Região da AWS a ser usada. Você pode optar por fazer com que o instalador crie os recursos necessários AWS IoT e do IAM para você. Você também pode optar por implantar ferramentas de desenvolvimento local para configurar um dispositivo que você usa para desenvolvimento de componentes personalizados.
O software AWS IoT Greengrass principal requer os seguintes recursos AWS IoT e os recursos do IAM para se conectar Nuvem AWS e operar:
+ Umo objeto do AWS IoT. Quando você registra um dispositivo como um objeto da AWS IoT, ele pode usar um certificado digital para autenticação com a AWS. Esse certificado permite que o dispositivo se comunique com a AWS IoT e o AWS IoT Greengrass. Para obter mais informações, consulte [Autenticação e autorização de dispositivos para AWS IoT Greengrass](device-auth.md).
+ (Opcional) Qualquer grupo de AWS IoT coisas. Use grupos de objetos para gerenciar 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. Você pode adicionar um dispositivo a um grupo de coisas para implantar os componentes de software desse grupo de coisas no dispositivo. Para obter mais informações, consulte [Implemente AWS IoT Greengrass componentes em dispositivos](manage-deployments.md).
+ Um perfil do IAM. Os principais dispositivos do Greengrass usam o provedor de AWS IoT Core credenciais para autorizar chamadas para AWS serviços com uma função do IAM. Essa função permite que seu dispositivo interaja com o Amazon CloudWatch LogsAWS IoT, envie logs para o Amazon CloudWatch Logs e baixe artefatos de componentes personalizados do Amazon Simple Storage Service (Amazon S3). Para obter mais informações, consulte [Autorize os dispositivos principais a interagir com os serviços AWS](device-service-role.md).
+ Um alias de AWS IoT função. Os dispositivos principais do Greengrass usam o alias de função para identificar a função do IAM a ser usada. O alias da função permite que você altere a função do IAM, mas mantenha a mesma configuração do dispositivo. Para mais informações, consulte [Autorizar de chamadas diretas para serviços da AWS](https://docs.aws.amazon.com/iot/latest/developerguide/authorizing-direct-aws.html) no *Guia do desenvolvedor do AWS IoT Core*.
Selecione uma das opções a seguir para instalar o software AWS IoT Greengrass Core em seu dispositivo principal do.
+ **Instalação rápida**
Selecione essa opção para configurar um dispositivo principal do Greengrass da forma mais simples possível. O instalador cria os recursos necessários AWS IoT e do IAM para você. Essa opção exige que você forneça AWS credenciais ao instalador para criar recursos no seuConta da AWS.
Você não pode usar essa opção para instalar atrás de um firewall ou proxy de rede. Se seus dispositivos estiverem protegidos por um firewall ou proxy de rede, considere a [instalação manual](manual-installation.md).
Para obter mais informações, consulte [Instale o software AWS IoT Greengrass principal com provisionamento automático de recursos](quick-installation.md).
+ **Instalação manual**
Escolha essa opção para criar os AWS recursos necessários manualmente ou para instalar atrás de um firewall ou proxy de rede. Ao usar uma instalação manual, você não precisa dar permissão ao instalador para criar recursos no seuConta da AWS, pois você cria os recursos necessários AWS IoT e do IAM. Você também pode configurar seu dispositivo para se conectar na porta 443 ou por meio de um proxy de rede. Você também pode configurar o software AWS IoT Greengrass Core para usar uma chave privada e um certificado que você armazena em um módulo de segurança de hardware (HSM), Trusted Platform Module (TPM) ou outro elemento criptográfico.
Para obter mais informações, consulte [Instale o software AWS IoT Greengrass principal com provisionamento manual de recursos](manual-installation.md).
+ **Instalação com provisionamento de AWS IoT frota**
Escolha essa opção para criar os AWS recursos necessários a partir de um modelo de provisionamento de AWS IoT frota. Você pode escolher essa opção para criar dispositivos semelhantes em uma frota ou se fabricar dispositivos que seus clientes ativarão posteriormente, como veículos ou dispositivos domésticos inteligentes. Os dispositivos usam certificados de declaração para autenticar e provisionar AWS recursos, incluindo um certificado de cliente X.509 que o dispositivo usa para se conectar ao Nuvem AWS para operação normal. Você pode incorporar ou atualizar os certificados de solicitação no hardware do dispositivo durante a fabricação e usar o mesmo certificado de solicitação e chave para provisionar vários dispositivos. Você também pode configurar dispositivos para se conectar na porta 443 ou por meio de um proxy de rede.
Para obter mais informações, consulte [Instale o software AWS IoT Greengrass principal com provisionamento de AWS IoT frota](fleet-provisioning.md).
+ **Instalação com provisionamento personalizado**
Escolha essa opção para desenvolver uma aplicação Java personalizada que provisione os recursos necessários da AWS. Você pode escolher essa opção se [criar seus próprios certificados de cliente X.509](https://docs.aws.amazon.com/iot/latest/developerguide/device-certs-your-own.html) ou se quiser ter mais controle sobre o processo de provisionamento. O AWS IoT Greengrass fornece uma interface que você pode implementar para trocar informações entre sua aplicação de provisionamento personalizada e o instalador do software AWS IoT Greengrass Core.
Para obter mais informações, consulte [Instale o software AWS IoT Greengrass principal com provisionamento personalizado de recursos](custom-provisioning.md).
O AWS IoT Greengrass também fornece ambientes em contêineres que executam o software do AWS IoT Greengrass Core. Você pode usar um Dockerfile para [executar AWS IoT Greengrass em um contêiner do Docker](run-greengrass-docker.md).
**Topics**
+ [Instalar com provisionamento automático](quick-installation.md)
+ [Instalar com provisionamento manual](manual-installation.md)
+ [Instalar com provisionamento de frota](fleet-provisioning.md)
+ [Instalar com provisionamento personalizado](custom-provisioning.md)
+ [Argumentos de instalação](configure-installer.md)
# Instale o software AWS IoT Greengrass principal com provisionamento automático de recursos
O software AWS IoT Greengrass Core inclui um instalador que configura seu dispositivo como um dispositivo principal do Greengrass. Para configurar um dispositivo rapidamente, o instalador pode provisionar a AWS IoT AWS IoT coisa, o grupo de coisas, a função do IAM e o alias da AWS IoT função que o dispositivo principal precisa para operar. O instalador também pode implantar as ferramentas de desenvolvimento local no dispositivo principal, para que você possa usar o dispositivo para desenvolver e testar componentes de software personalizados. O instalador exige AWS credenciais para provisionar esses recursos e criar a implantação.
Se você não puder fornecer AWS credenciais para o dispositivo, poderá provisionar os AWS recursos que o dispositivo principal precisa para operar. Também é possível implantar as ferramentas de desenvolvimento em um dispositivo principal para usar como dispositivo de desenvolvimento. Isso faz com que você forneça menos permissões ao dispositivo ao executar o instalador. Para obter mais informações, consulte [Instale o software AWS IoT Greengrass principal com provisionamento manual de recursos](manual-installation.md).
**Importante**
Antes de baixar o software AWS IoT Greengrass Core, verifique se seu dispositivo principal atende aos [requisitos](greengrass-nucleus-component.md#greengrass-v2-requirements) para instalar e executar o software AWS IoT Greengrass Core v2.0.
**Topics**
+ [Configurar o ambiente do dispositivo](#set-up-device-environment)
+ [Forneça AWS credenciais para o dispositivo](#provide-installer-aws-credentials)
+ [Baixe o software AWS IoT Greengrass Core](#download-greengrass-core-v2)
+ [Instale o software AWS IoT Greengrass Core](#run-greengrass-core-v2-installer)
## Configurar o ambiente do dispositivo
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
**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
**nota**
Esse recurso está disponível para a versão 2.5.0 e posterior do [componente de Greengrass nucleus](greengrass-nucleus-component.md).
**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.
## Forneça AWS credenciais para o dispositivo
Forneça suas AWS credenciais ao seu dispositivo para que o instalador possa provisionar os AWS recursos necessários. Para mais informações sobre as permissões necessárias, consulte [Política mínima de IAM para o instalador provisionar recursos](provision-minimal-iam-policy.md).
**Para fornecer AWS credenciais ao dispositivo**
+ Forneça suas AWS credenciais ao dispositivo para que o instalador possa provisionar os recursos do IAM AWS IoT e do IAM para seu dispositivo principal. 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 AWS IoT Greengrass instalador do software Core:
+ (Recomendado) Use credenciais temporárias de 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. Execute os comandos a seguir para fornecer as credenciais para o software AWS IoT Greengrass principal.
------
#### [ 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. Execute os comandos a seguir para fornecer as credenciais para o software AWS IoT Greengrass principal.
------
#### [ 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. Execute os comandos a seguir para fornecer as credenciais para o software AWS IoT Greengrass principal.
------
#### [ 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 *.
## Baixe o software AWS IoT Greengrass Core
Você pode baixar a versão mais recente do software AWS IoT Greengrass Core no seguinte local:
+ [https://d2s8p88vqu9w66.cloudfront. net/releases/greengrass](https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip)-nucleus-latest.zip
**nota**
Você pode baixar uma versão específica do software AWS IoT Greengrass Core no seguinte local. *version*Substitua pela versão a ser baixada.
```
https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-version.zip
```
**Para baixar o software AWS IoT Greengrass Core**
1. Em seu 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. (Opcional) Para verificar a assinatura do software do Greengrass nucleus
**nota**
Esse atributo está disponível com o Greengrass nucleus versão 2.9.5 e posterior.
1. Use o comando a seguir para verificar a assinatura do artefato do Greengrass nucleus:
------
#### [ Linux or Unix ]
```
jarsigner -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
O nome do arquivo pode parecer diferente dependendo da versão do JDK que você instala. Substitua *`jdk17.0.6_10`* pela versão do JDK que você instalou.
```
"C:\\Program Files\\Amazon Corretto\\jdk17.0.6_10\\bin\\jarsigner.exe" -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
O nome do arquivo pode parecer diferente dependendo da versão do JDK que você instala. Substitua *`jdk17.0.6_10`* pela versão do JDK que você instalou.
```
'C:\\Program Files\\Amazon Corretto\\jdk17.0.6_10\\bin\\jarsigner.exe' -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
1. A invocação `jarsigner` produz uma saída que indica os resultados da verificação.
1. Se o arquivo zip do Greengrass nucleus estiver assinado, a saída conterá a seguinte declaração:
```
jar verified.
```
1. Se o arquivo zip do Greengrass nucleus não estiver assinado, a saída conterá a seguinte declaração:
```
jar is unsigned.
```
1. Se você forneceu a opção `-certs` do Jarsigner junto com as opções `-verify` e `-verbose`, a saída também incluirá informações detalhadas do certificado do assinante.
1. Descompacte o software AWS IoT Greengrass Core em uma pasta no seu dispositivo. *GreengrassInstaller*Substitua 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. (Opcional) Execute o comando a seguir para ver a versão do software AWS IoT Greengrass Core.
```
java -jar ./GreengrassInstaller/lib/Greengrass.jar --version
```
**Importante**
Se você instalar uma versão do núcleo do Greengrass anterior à v2.4.0, não remova essa pasta depois de instalar o software Core. AWS IoT Greengrass O software AWS IoT Greengrass Core usa os arquivos dessa pasta para ser executado.
Se você baixou a versão mais recente do software, instale a versão 2.4.0 ou posterior e poderá remover essa pasta depois de instalar o software AWS IoT Greengrass Core.
## Instale o software AWS IoT Greengrass Core
Execute o instalador com argumentos que especificam o seguinte:
+ Crie os AWS recursos que o dispositivo principal precisa para operar.
+ 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ê.
+ 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, você deve configurar o software AWS IoT Greengrass Core como um serviço do sistema.
Para configurar um dispositivo de desenvolvimento com ferramentas de desenvolvimento local, especifique o argumento `--deploy-dev-tools true`. As ferramentas de desenvolvimento local podem levar até um minuto para serem implantadas após a conclusão da instalação.
Para mais informações sobre os argumentos que podem ser especificados, consulte [Argumentos de instalação](configure-installer.md).
**nota**
Se você estiver executando 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).
**Para instalar o software AWS IoT Greengrass Core**
1. Execute o instalador AWS IoT Greengrass Core. Substitua os valores dos argumentos no comando da seguinte maneira.
**nota**
O Windows tem uma limitação de comprimento de caminho de 260 caracteres. Se você estiver usando o Windows, use uma pasta raiz como `C:\greengrass\v2` ou `D:\greengrass\v2` para manter os caminhos dos componentes do Greengrass abaixo do limite de 260 caracteres.
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*. O Região da AWS no qual encontrar ou criar recursos.
1. *MyGreengrassCore*. O nome da AWS IoT coisa para o seu dispositivo principal do Greengrass. Se o objeto não existir, o instalador o cria. O instalador baixa os certificados para autenticar a AWS IoT coisa. 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 grupo de AWS IoT coisas do 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 AWS IoT política que permite que os dispositivos principais do Greengrass se comuniquem com e. AWS IoT AWS IoT Greengrass Se a AWS IoT política não existir, o instalador cria uma AWS IoT política permissiva 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 da função do IAM que permite que o dispositivo principal do Greengrass obtenha credenciais temporárias 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 a função 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
```
------
#### [ 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
```
------
#### [ 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
```
------
**Importante**
Nos dispositivos principais do Windows, você deve especificar `--setup-system-service true` a configuração do software AWS IoT Greengrass Core como um serviço do sistema.
O instalador imprime as seguintes mensagens se for bem-sucedido:
+ Se você especificar `--provision`, o instalador imprimirá `Successfully configured Nucleus with provisioned resource details` se ele configurou os recursos com êxito.
+ Se você especificar `--deploy-dev-tools`, o instalador imprimirá `Configured Nucleus to deploy aws.greengrass.Cli component` se ele criou a implantação com êxito.
+ Se você especificar `--setup-system-service true`, o instalador imprimirá `Successfully set up Nucleus as a system service` se ele configurou e executou o software como um serviço.
+ Se você não especificar `--setup-system-service true`, o instalador imprimirá `Launched Nucleus successfully` se foi bem-sucedido e executou o software.
1. Ignore esta etapa se você instalou a versão 2.0.4 do [Greengrass nucleus](greengrass-nucleus-component.md) ou posterior. Se você baixou a versão mais recente do software, instalou a versão 2.0.4 ou posterior.
Execute o comando a seguir para definir as permissões de arquivo necessárias para a pasta raiz do software AWS IoT Greengrass Core. `/greengrass/v2`Substitua pela pasta raiz especificada no comando de instalação e */greengrass* substitua pela pasta principal da pasta raiz.
```
sudo chmod 755 /greengrass/v2 && sudo chmod 755 /greengrass
```
Se você instalou o software AWS IoT Greengrass Core como um serviço do sistema, o instalador executa o software para você. Caso contrário, será preciso executar o software manualmente. Para obter mais informações, consulte [Execute o software AWS IoT Greengrass Core](run-greengrass-core-v2.md).
**nota**
Por padrão, o perfil do IAM criado pelo instalador não permite acesso aos artefatos dos componentes nos buckets do S3. Para implantar componentes personalizados que definem artefatos no Amazon S3, é preciso adicionar permissões ao perfil para permitir que seu dispositivo principal recupere artefatos de componentes. Para obter mais informações, consulte [Permitir acesso aos buckets do S3 para artefatos de componentes](device-service-role.md#device-service-role-access-s3-bucket).
Se você ainda não tem um bucket do S3 para artefatos de componentes, é possível adicionar essas permissões depois de criar um bucket.
**nota**
Quando o software AWS IoT Greengrass Core se conectar à nuvem, seu dispositivo será reconhecido como um dispositivo Core.
Para obter mais informações sobre como configurar e usar o software AWS IoT Greengrass, consulte o seguinte:
+ [Configurar o software AWS IoT Greengrass principal](configure-greengrass-core-v2.md)
+ [Desenvolver componentes do AWS IoT Greengrass](develop-greengrass-components.md)
+ [Implemente AWS IoT Greengrass componentes em dispositivos](manage-deployments.md)
+ [Interface de linha de comando do Greengrass](gg-cli.md)
# Instale o software AWS IoT Greengrass principal com provisionamento manual de recursos
O software AWS IoT Greengrass Core inclui um instalador que configura seu dispositivo como um dispositivo principal do Greengrass. Para configurar um dispositivo manualmente, você pode criar os recursos necessários AWS IoT e do IAM para o dispositivo usar. Se você criar esses recursos manualmente, não precisará fornecer AWS credenciais ao instalador.
Ao instalar manualmente o software AWS IoT Greengrass Core, você também pode configurar o dispositivo para usar um proxy de rede ou conectar-se AWS à porta 443. Talvez seja necessário especificar essas opções de configuração se o dispositivo estiver protegido por um firewall ou proxy de rede, por exemplo. Para obter mais informações, consulte [Conectar-se à porta 443 ou por meio de um proxy de rede](configure-greengrass-core-v2.md#configure-alpn-network-proxy).
Você também pode configurar o software AWS IoT Greengrass Core para usar um módulo de segurança de hardware (HSM) por meio da interface [PKCS \$111](https://en.wikipedia.org/wiki/PKCS_11). Esse recurso permite que você armazene com segurança arquivos de chave privada e certificado para que eles não sejam expostos ou duplicados no software. É possível armazenar chaves privadas e certificados em um módulo de hardware, como um HSM, um Trusted Platform Module (TPM – Módulo de plataforma confiável) ou outro elemento criptográfico. Esse recurso está disponível apenas em dispositivos Linux. Para mais informações sobre a segurança do hardware e os requisitos para usá-lo, consulte [Integração de segurança de hardware](hardware-security.md).
**Importante**
Antes de baixar o software AWS IoT Greengrass Core, verifique se seu dispositivo principal atende aos [requisitos](greengrass-nucleus-component.md#greengrass-v2-requirements) para instalar e executar o software AWS IoT Greengrass Core v2.0.
**Topics**
+ [Recupere endpoints AWS IoT](#retrieve-iot-endpoints)
+ [Crie qualquer AWS IoT coisa](#create-iot-thing)
+ [Criar o certificado do objeto](#create-thing-certificate)
+ [Configurar o certificado do objeto](#configure-thing-certificate)
+ [Criar um perfil de troca de token](#create-token-exchange-role)
+ [Baixar certificados para o dispositivo](#download-thing-certificates)
+ [Configurar o ambiente do dispositivo](#set-up-device-environment)
+ [Baixe o software AWS IoT Greengrass Core](#download-greengrass-core-v2)
+ [Instale o software AWS IoT Greengrass Core](#run-greengrass-core-v2-installer-manual)
## Recupere endpoints AWS IoT
Obtenha os AWS IoT endpoints para você Conta da AWS e salve-os para usar mais tarde. Seu dispositivo usa esses endpoints para se conectar à AWS IoT. Faça o seguinte:
1. Obtenha o endpoint de AWS IoT dados para você Conta da AWS.
```
aws iot describe-endpoint --endpoint-type iot:Data-ATS
```
Se a solicitação for bem-sucedida, a resposta será semelhante ao exemplo a seguir.
```
{
"endpointAddress": "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
}
```
1. Obtenha o endpoint AWS IoT de credenciais para seu. Conta da AWS
```
aws iot describe-endpoint --endpoint-type iot:CredentialProvider
```
Se a solicitação for bem-sucedida, a resposta será semelhante ao exemplo a seguir.
```
{
"endpointAddress": "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
}
```
## Crie qualquer AWS IoT coisa
AWS IoT *as coisas* representam dispositivos e entidades lógicas que se conectam AWS IoT a. Os principais dispositivos do Greengrass são AWS IoT coisas. Quando você registra um dispositivo como uma AWS IoT coisa, esse dispositivo pode usar um certificado digital para se autenticar AWS.
Nesta seção, você cria AWS IoT algo que representa seu dispositivo.
**Para criar qualquer AWS IoT coisa**
1. Crie qualquer AWS IoT coisa para o seu dispositivo. Execute o comando a seguir no computador de desenvolvimento.
+ *MyGreengrassCore*Substitua pelo nome da coisa a ser usada. Esse nome também é o nome do dispositivo principal do Greengrass.
**nota**
O nome do objeto não pode conter caracteres de dois pontos (`:`).
```
aws iot create-thing --thing-name MyGreengrassCore
```
Se a solicitação for bem-sucedida, a resposta será semelhante ao exemplo a seguir.
```
{
"thingName": "MyGreengrassCore",
"thingArn": "arn:aws:iot:us-west-2:123456789012:thing/MyGreengrassCore",
"thingId": "8cb4b6cd-268e-495d-b5b9-1713d71dbf42"
}
```
1. (Opcional) Adicione a AWS IoT coisa a um grupo de coisas novo ou existente. Use grupos de objetos para gerenciar frotas de dispositivos principais do Greengrass. Ao implantar componentes de software nos dispositivos, é possível segmentar dispositivos individuais ou grupos de dispositivos. É possível adicionar um dispositivo a um grupo de objetos com uma implantação ativa do Greengrass para implantar os componentes de software desse grupo de objetos no dispositivo. Faça o seguinte:
1. (Opcional) Crie um grupo de AWS IoT coisas.
+ *MyGreengrassCoreGroup*Substitua pelo nome do grupo de coisas a ser criado.
**nota**
O nome do grupo de objetos não pode conter caracteres de dois pontos (`:`).
```
aws iot create-thing-group --thing-group-name MyGreengrassCoreGroup
```
Se a solicitação for bem-sucedida, a resposta será semelhante ao exemplo a seguir.
```
{
"thingGroupName": "MyGreengrassCoreGroup",
"thingGroupArn": "arn:aws:iot:us-west-2:123456789012:thinggroup/MyGreengrassCoreGroup",
"thingGroupId": "4df721e1-ff9f-4f97-92dd-02db4e3f03aa"
}
```
1. Adicione a AWS IoT coisa a um grupo de coisas.
+ *MyGreengrassCore*Substitua pelo nome da sua AWS IoT coisa.
+ *MyGreengrassCoreGroup*Substitua pelo nome do grupo de coisas.
```
aws iot add-thing-to-thing-group --thing-name MyGreengrassCore --thing-group-name MyGreengrassCoreGroup
```
O comando não terá nenhuma saída se a solicitação for bem-sucedida.
## Criar o certificado do objeto
Quando você registra um dispositivo como uma AWS IoT coisa, esse dispositivo pode usar um certificado digital para se autenticar AWS. Esse certificado permite que o dispositivo se comunique com AWS IoT AWS IoT Greengrass e.
Nesta seção, você cria e baixa certificados que o dispositivo pode usar para se conectar com a AWS.
Se você quiser configurar o software AWS IoT Greengrass Core para usar um módulo de segurança de hardware (HSM) para armazenar com segurança a chave privada e o certificado, siga as etapas para criar o certificado a partir de uma chave privada em um HSM. Caso contrário, siga as etapas para criar o certificado e a chave privada no AWS IoT serviço. O atributo de segurança de hardware está disponível somente em dispositivos Linux. Para mais informações sobre a segurança do hardware e os requisitos para usá-lo, consulte [Integração de segurança de hardware](hardware-security.md).
### Crie o certificado e a chave privada no AWS IoT serviço
**Para criar o certificado do objeto**
1. Crie uma pasta na qual você baixa os certificados da AWS IoT coisa.
```
mkdir greengrass-v2-certs
```
1. Crie e baixe os certificados da AWS IoT coisa.
```
aws iot create-keys-and-certificate --set-as-active --certificate-pem-outfile greengrass-v2-certs/device.pem.crt --public-key-outfile greengrass-v2-certs/public.pem.key --private-key-outfile greengrass-v2-certs/private.pem.key
```
Se a solicitação for bem-sucedida, a resposta será semelhante ao exemplo a seguir.
```
{
"certificateArn": "arn:aws:iot:us-west-2:123456789012:cert/aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4",
"certificateId": "aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4",
"certificatePem": "-----BEGIN CERTIFICATE-----
MIICiTCCAfICCQD6m7oRw0uXOjANBgkqhkiG9w
0BAQUFADCBiDELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAldBMRAwDgYDVQQHEwdTZ
WF0dGxlMQ8wDQYDVQQKEwZBbWF6b24xFDASBgNVBAsTC0lBTSBDb25zb2xlMRIw
EAYDVQQDEwlUZXN0Q2lsYWMxHzAdBgkqhkiG9w0BCQEWEG5vb25lQGFtYXpvbi5
jb20wHhcNMTEwNDI1MjA0NTIxWhcNMTIwNDI0MjA0NTIxWjCBiDELMAkGA1UEBh
MCVVMxCzAJBgNVBAgTAldBMRAwDgYDVQQHEwdTZWF0dGxlMQ8wDQYDVQQKEwZBb
WF6b24xFDASBgNVBAsTC0lBTSBDb25zb2xlMRIwEAYDVQQDEwlUZXN0Q2lsYWMx
HzAdBgkqhkiG9w0BCQEWEG5vb25lQGFtYXpvbi5jb20wgZ8wDQYJKoZIhvcNAQE
BBQADgY0AMIGJAoGBAMaK0dn+a4GmWIWJ21uUSfwfEvySWtC2XADZ4nB+BLYgVI
k60CpiwsZ3G93vUEIO3IyNoH/f0wYK8m9TrDHudUZg3qX4waLG5M43q7Wgc/MbQ
ITxOUSQv7c7ugFFDzQGBzZswY6786m86gpEIbb3OhjZnzcvQAaRHhdlQWIMm2nr
AgMBAAEwDQYJKoZIhvcNAQEFBQADgYEAtCu4nUhVVxYUntneD9+h8Mg9q6q+auN
KyExzyLwaxlAoo7TJHidbtS4J5iNmZgXL0FkbFFBjvSfpJIlJ00zbhNYS5f6Guo
EDmFJl0ZxBHjJnyp378OD8uTs7fLvjx79LjSTbNYiytVbZPQUQ5Yaxu2jXnimvw
3rrszlaEXAMPLE=
-----END CERTIFICATE-----",
"keyPair": {
"PublicKey": "-----BEGIN PUBLIC KEY-----\
MIIBIjANBgkqhkEXAMPLEQEFAAOCAQ8AMIIBCgKCAQEAEXAMPLE1nnyJwKSMHw4h\
MMEXAMPLEuuN/dMAS3fyce8DW/4+EXAMPLEyjmoF/YVF/gHr99VEEXAMPLE5VF13\
59VK7cEXAMPLE67GK+y+jikqXOgHh/xJTwo+sGpWEXAMPLEDz18xOd2ka4tCzuWEXAMPLEahJbYkCPUBSU8opVkR7qkEXAMPLE1DR6sx2HocliOOLtu6Fkw91swQWEXAMPLE\\GB3ZPrNh0PzQYvjUStZeccyNCx2EXAMPLEvp9mQOUXP6plfgxwKRX2fEXAMPLEDa\
hJLXkX3rHU2xbxJSq7D+XEXAMPLEcw+LyFhI5mgFRl88eGdsAEXAMPLElnI9EesG\
FQIDAQAB\
-----END PUBLIC KEY-----\
",
"PrivateKey": "-----BEGIN RSA PRIVATE KEY-----\
key omitted for security reasons\
-----END RSA PRIVATE KEY-----\
"
}
}
```
Salve o nome do recurso da Amazon (ARN) do certificado para usar na configuração do certificado posteriormente.
### Crie o certificado a partir de uma chave privada em um HSM
**nota**
[Esse recurso está disponível para a versão 2.5.3 e posterior do componente núcleo do Greengrass.](greengrass-nucleus-component.md) AWS IoT Greengrass atualmente não oferece suporte a esse recurso nos dispositivos principais do Windows.
**Para criar o certificado do objeto**
1. No dispositivo principal, inicialize um token PKCS\$111 no HSM e gere uma chave privada. A chave privada precisa ser uma chave RSA com um tamanho de chave RSA-2048 (ou maior) ou uma chave ECC.
**nota**
Para usar um módulo de segurança de hardware com chaves ECC, use o [Greengrass nucleus](greengrass-nucleus-component.md) v2.5.6 ou posterior.
Para usar um módulo de segurança de hardware e um [gerenciador de segredos](secret-manager-component.md), use um módulo de segurança de hardware com chaves RSA.
Consulte a documentação do HSM para saber como inicializar o token e gerar a chave privada. Se seu HSM suportar objetos IDs, especifique um ID de objeto ao gerar a chave privada. Salve o ID do slot, o PIN do usuário, o rótulo do objeto e o ID do objeto (se o HSM usar um) que você especifica ao inicializar o token e gerar a chave privada. Você usa esses valores posteriormente ao importar o certificado do item para o HSM e configurar o software AWS IoT Greengrass Core.
1. Crie uma solicitação de assinatura de certificado (CSR) a partir da chave privada. AWS IoT usa essa CSR para criar um certificado para a chave privada que você gerou no HSM. Para informações sobre como criar um CSR a partir da chave privada, consulte a documentação do HSM. O CSR é um arquivo, como `iotdevicekey.csr`.
1. Copie a CSR do dispositivo para o computador de desenvolvimento. Se o SSH e o SCP estiverem habilitados no computador de desenvolvimento e no dispositivo, será possível usar o comando `scp` no computador de desenvolvimento para transferir o CSR. *device-ip-address*Substitua pelo endereço IP do seu dispositivo e *\$1/iotdevicekey.csr* substitua pelo caminho para o arquivo CSR no dispositivo.
```
scp device-ip-address:~/iotdevicekey.csr iotdevicekey.csr
```
1. No seu computador de desenvolvimento, crie uma pasta na qual você baixa o certificado da AWS IoT coisa.
```
mkdir greengrass-v2-certs
```
1. Use o arquivo CSR para criar e baixar o certificado da AWS IoT coisa em seu computador de desenvolvimento.
```
aws iot create-certificate-from-csr --set-as-active --certificate-signing-request=file://iotdevicekey.csr --certificate-pem-outfile greengrass-v2-certs/device.pem.crt
```
Se a solicitação for bem-sucedida, a resposta será semelhante ao exemplo a seguir.
```
{
"certificateArn": "arn:aws:iot:us-west-2:123456789012:cert/aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4",
"certificateId": "aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4",
"certificatePem": "-----BEGIN CERTIFICATE-----
MIICiTCCAfICCQD6m7oRw0uXOjANBgkqhkiG9w
0BAQUFADCBiDELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAldBMRAwDgYDVQQHEwdTZ
WF0dGxlMQ8wDQYDVQQKEwZBbWF6b24xFDASBgNVBAsTC0lBTSBDb25zb2xlMRIw
EAYDVQQDEwlUZXN0Q2lsYWMxHzAdBgkqhkiG9w0BCQEWEG5vb25lQGFtYXpvbi5
jb20wHhcNMTEwNDI1MjA0NTIxWhcNMTIwNDI0MjA0NTIxWjCBiDELMAkGA1UEBh
MCVVMxCzAJBgNVBAgTAldBMRAwDgYDVQQHEwdTZWF0dGxlMQ8wDQYDVQQKEwZBb
WF6b24xFDASBgNVBAsTC0lBTSBDb25zb2xlMRIwEAYDVQQDEwlUZXN0Q2lsYWMx
HzAdBgkqhkiG9w0BCQEWEG5vb25lQGFtYXpvbi5jb20wgZ8wDQYJKoZIhvcNAQE
BBQADgY0AMIGJAoGBAMaK0dn+a4GmWIWJ21uUSfwfEvySWtC2XADZ4nB+BLYgVI
k60CpiwsZ3G93vUEIO3IyNoH/f0wYK8m9TrDHudUZg3qX4waLG5M43q7Wgc/MbQ
ITxOUSQv7c7ugFFDzQGBzZswY6786m86gpEIbb3OhjZnzcvQAaRHhdlQWIMm2nr
AgMBAAEwDQYJKoZIhvcNAQEFBQADgYEAtCu4nUhVVxYUntneD9+h8Mg9q6q+auN
KyExzyLwaxlAoo7TJHidbtS4J5iNmZgXL0FkbFFBjvSfpJIlJ00zbhNYS5f6Guo
EDmFJl0ZxBHjJnyp378OD8uTs7fLvjx79LjSTbNYiytVbZPQUQ5Yaxu2jXnimvw
3rrszlaEXAMPLE=
-----END CERTIFICATE-----"
}
```
Salve o ARN do certificado para usar na configuração do certificado posteriormente.
## Configurar o certificado do objeto
Anexe o certificado do AWS IoT item ao que você criou anteriormente e adicione uma AWS IoT política ao certificado para definir as AWS IoT permissões para o dispositivo principal.
**Para configurar o certificado do objeto**
1. Anexe o certificado à AWS IoT coisa.
+ *MyGreengrassCore*Substitua pelo nome da sua AWS IoT coisa.
+ Substitua o nome do recurso da Amazon (ARN) do certificado pelo ARN do certificado que você criou na etapa anterior.
```
aws iot attach-thing-principal --thing-name MyGreengrassCore --principal arn:aws:iot:us-west-2:123456789012:cert/aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4
```
O comando não terá nenhuma saída se a solicitação for bem-sucedida.
1. Crie e anexe uma AWS IoT política que defina as AWS IoT permissões para seu dispositivo principal do Greengrass. A política a seguir permite acesso a todos os tópicos MQTT e operações do Greengrass, para que seu dispositivo funcione com aplicações personalizadas e futuras alterações que exijam novas operações do Greengrass. É possível restringir essa política com base em 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).
Se você já configurou um dispositivo principal do Greengrass, pode anexar sua AWS IoT política em vez de criar uma nova.
Faça o seguinte:
1. Crie um arquivo que contenha o documento AWS IoT de política exigido pelos dispositivos principais do Greengrass.
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 greengrass-v2-iot-policy.json
```
Copie o seguinte JSON no arquivo.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Publish",
"iot:Subscribe",
"iot:Receive",
"iot:Connect",
"greengrass:*"
],
"Resource": [
"*"
]
}
]
}
```
1. Crie uma AWS IoT política a partir do documento de política.
+ *GreengrassV2IoTThingPolicy*Substitua pelo nome da política a ser criada.
```
aws iot create-policy --policy-name GreengrassV2IoTThingPolicy --policy-document file://greengrass-v2-iot-policy.json
```
Se a solicitação for bem-sucedida, a resposta será semelhante ao exemplo a seguir.
```
{
"policyName": "GreengrassV2IoTThingPolicy",
"policyArn": "arn:aws:iot:us-west-2:123456789012:policy/GreengrassV2IoTThingPolicy",
"policyDocument": "{
\\"Version\\": \\"2012-10-17 \\",
\\"Statement\\": [
{
\\"Effect\\": \\"Allow\\",
\\"Action\\": [
\\"iot:Publish\\",
\\"iot:Subscribe\\",
\\"iot:Receive\\",
\\"iot:Connect\\",
\\"greengrass:*\\"
],
\\"Resource\\": [
\\"*\\"
]
}
]
}",
"policyVersionId": "1"
}
```
1. Anexe a AWS IoT política ao certificado da AWS IoT coisa.
+ *GreengrassV2IoTThingPolicy*Substitua pelo nome da política a ser anexada.
+ Substitua o ARN de destino pelo ARN do certificado do objeto da AWS IoT .
```
aws iot attach-policy --policy-name GreengrassV2IoTThingPolicy --target arn:aws:iot:us-west-2:123456789012:cert/aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4
```
O comando não terá nenhuma saída se a solicitação for bem-sucedida.
## Criar um perfil de troca de token
Os dispositivos principais do Greengrass usam uma função de serviço do IAM, chamada função de *troca de tokens*, para autorizar chamadas para serviços. AWS O dispositivo usa o provedor de AWS IoT credenciais para obter AWS credenciais temporárias para essa função, o que permite que o dispositivo interaja AWS IoT, envie registros para o Amazon CloudWatch Logs e baixe artefatos de componentes personalizados do Amazon S3. Para obter mais informações, consulte [Autorize os dispositivos principais a interagir com os serviços AWS](device-service-role.md).
Você usa um *alias de AWS IoT função* para configurar a função de troca de tokens para os dispositivos principais do Greengrass. Os aliases de perfil permitem que você altere o perfil de troca de tokens de um dispositivo, mas mantenha a mesma configuração do dispositivo. Para mais informações, consulte [Autorizar de chamadas diretas para serviços da AWS](https://docs.aws.amazon.com/iot/latest/developerguide/authorizing-direct-aws.html) no *Guia do desenvolvedor do AWS IoT Core *.
Nesta seção, você cria uma função do IAM de troca de tokens e um alias de AWS IoT função que aponta para a função. Se você já configurou um dispositivo principal do Greengrass, pode usar o perfil de troca de tokens e o alias de perfil em vez de criar novos. Em seguida, você configura o objeto da AWS IoT do dispositivo para usar esse perfil e alias.
**Para criar um perfil do IAM de troca de token**
1. Crie um perfil do IAM que seu dispositivo possa usar como um perfil de troca de tokens. Faça o seguinte:
1. Crie um arquivo que contenha o documento de política de confiança exigido pelo perfil de troca de token.
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 device-role-trust-policy.json
```
Copie o seguinte JSON no arquivo.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "credentials.iot.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
1. Crie o perfil de troca de token com o documento de política de confiança.
+ *GreengrassV2TokenExchangeRole*Substitua pelo nome da função do IAM a ser criada.
```
aws iam create-role --role-name GreengrassV2TokenExchangeRole --assume-role-policy-document file://device-role-trust-policy.json
```
Se a solicitação for bem-sucedida, a resposta será semelhante ao exemplo a seguir.
```
{
"Role": {
"Path": "/",
"RoleName": "GreengrassV2TokenExchangeRole",
"RoleId": "AROAZ2YMUHYHK5OKM77FB",
"Arn": "arn:aws:iam::123456789012:role/GreengrassV2TokenExchangeRole",
"CreateDate": "2021-02-06T00:13:29+00:00",
"AssumeRolePolicyDocument": {
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "credentials.iot.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
}
```
1. Crie um arquivo que contenha o documento de política de acesso exigido pelo perfil de troca de token.
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 device-role-access-policy.json
```
Copie o seguinte JSON no arquivo.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents",
"logs:DescribeLogStreams",
"s3:GetBucketLocation"
],
"Resource": "*"
}
]
}
```
**nota**
Essa política de acesso não permite acesso a artefatos de componentes nos buckets do S3. Para implantar componentes personalizados que definem artefatos no Amazon S3, é preciso adicionar permissões ao perfil para permitir que seu dispositivo principal recupere artefatos de componentes. Para obter mais informações, consulte [Permitir acesso aos buckets do S3 para artefatos de componentes](device-service-role.md#device-service-role-access-s3-bucket).
Se você ainda não tem um bucket do S3 para artefatos de componentes, é possível adicionar essas permissões depois de criar um bucket.
1. Crie uma política do IAM a partir do documento de política.
+ *GreengrassV2TokenExchangeRoleAccess*Substitua pelo nome da política do IAM a ser criada.
```
aws iam create-policy --policy-name GreengrassV2TokenExchangeRoleAccess --policy-document file://device-role-access-policy.json
```
Se a solicitação for bem-sucedida, a resposta será semelhante ao exemplo a seguir.
```
{
"Policy": {
"PolicyName": "GreengrassV2TokenExchangeRoleAccess",
"PolicyId": "ANPAZ2YMUHYHACI7C5Z66",
"Arn": "arn:aws:iam::123456789012:policy/GreengrassV2TokenExchangeRoleAccess",
"Path": "/",
"DefaultVersionId": "v1",
"AttachmentCount": 0,
"PermissionsBoundaryUsageCount": 0,
"IsAttachable": true,
"CreateDate": "2021-02-06T00:37:17+00:00",
"UpdateDate": "2021-02-06T00:37:17+00:00"
}
}
```
1. Anexe a política do IAM ao perfil de troca de token.
+ Substitua *GreengrassV2TokenExchangeRole* pelo nome da perfil do IAM.
+ Substitua o ARN da política pelo ARN da política do IAM que você criou na etapa anterior.
```
aws iam attach-role-policy --role-name GreengrassV2TokenExchangeRole --policy-arn arn:aws:iam::123456789012:policy/GreengrassV2TokenExchangeRoleAccess
```
O comando não terá nenhuma saída se a solicitação for bem-sucedida.
1. Crie um alias de AWS IoT função que aponte para a função de troca de tokens.
+ *GreengrassCoreTokenExchangeRoleAlias*Substitua pelo nome do alias de função a ser criado.
+ Substitua o ARN do perfil pelo ARN do perfil do IAM que você criou na etapa anterior.
```
aws iot create-role-alias --role-alias GreengrassCoreTokenExchangeRoleAlias --role-arn arn:aws:iam::123456789012:role/GreengrassV2TokenExchangeRole
```
Se a solicitação for bem-sucedida, a resposta será semelhante ao exemplo a seguir.
```
{
"roleAlias": "GreengrassCoreTokenExchangeRoleAlias",
"roleAliasArn": "arn:aws:iot:us-west-2:123456789012:rolealias/GreengrassCoreTokenExchangeRoleAlias"
}
```
**nota**
Para criar um alias do perfil, é preciso ter permissão para passar o perfil do IAM de troca de token para a AWS IoT. Se você receber uma mensagem de erro ao tentar criar um alias de função, verifique se o AWS usuário tem essa permissão. Para obter mais informações, consulte [Conceder permissões a um usuário para passar uma função para um AWS serviço](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_passrole.html) no *Guia do AWS Identity and Access Management usuário*.
1. Crie e anexe uma AWS IoT política que permita que seu dispositivo principal do Greengrass use o alias de função para assumir a função de troca de tokens. Se você já configurou um dispositivo principal do Greengrass, pode anexar sua AWS IoT política de alias de função em vez de criar uma nova. Faça o seguinte:
1. (Opcional) Crie um arquivo que contenha o documento AWS IoT de política exigido pelo alias da funçã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 greengrass-v2-iot-role-alias-policy.json
```
Copie o JSON a seguir no arquivo.
+ Substitua o ARN do recurso pelo ARN do alias da do perfil.
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "iot:AssumeRoleWithCertificate",
"Resource": "arn:aws:iot:us-west-2:123456789012:rolealias/GreengrassCoreTokenExchangeRoleAlias"
}
]
}
```
1. Crie uma AWS IoT política a partir do documento de política.
+ *GreengrassCoreTokenExchangeRoleAliasPolicy*Substitua pelo nome da AWS IoT política a ser criada.
```
aws iot create-policy --policy-name GreengrassCoreTokenExchangeRoleAliasPolicy --policy-document file://greengrass-v2-iot-role-alias-policy.json
```
Se a solicitação for bem-sucedida, a resposta será semelhante ao exemplo a seguir.
```
{
"policyName": "GreengrassCoreTokenExchangeRoleAliasPolicy",
"policyArn": "arn:aws:iot:us-west-2:123456789012:policy/GreengrassCoreTokenExchangeRoleAliasPolicy",
"policyDocument": "{
\\"Version\\":\\"2012-10-17 \\",
\\"Statement\\": [
{
\\"Effect\\": \\"Allow\\",
\\"Action\\": \\"iot:AssumeRoleWithCertificate\\",
\\"Resource\\": \\"arn:aws:iot:us-west-2:123456789012:rolealias/GreengrassCoreTokenExchangeRoleAlias\\"
}
]
}",
"policyVersionId": "1"
}
```
1. Anexe a AWS IoT política ao certificado da AWS IoT coisa.
+ *GreengrassCoreTokenExchangeRoleAliasPolicy*Substitua pelo nome da AWS IoT política de alias de função.
+ Substitua o ARN de destino pelo ARN do certificado do objeto da AWS IoT .
```
aws iot attach-policy --policy-name GreengrassCoreTokenExchangeRoleAliasPolicy --target arn:aws:iot:us-west-2:123456789012:cert/aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4
```
O comando não terá nenhuma saída se a solicitação for bem-sucedida.
## Baixar certificados para o dispositivo
Anteriormente, você baixou o certificado do dispositivo para o computador de desenvolvimento. Nesta seção, você copia o certificado para o seu dispositivo principal para configurar o dispositivo com os certificados que ele usa para se conectar à AWS IoT. Você também pode baixar o certificado da autoridade de certificação raiz (CA) da Amazon. Se você usa um HSM, também importa o arquivo de certificado para o HSM nesta seção.
+ Se você criou o certificado e a chave privada do item no AWS IoT serviço anteriormente, siga as etapas para baixar os certificados com a chave privada e os arquivos de certificado.
+ Se você criou o certificado do objeto a partir de uma chave privada em um módulo de segurança de hardware (HSM) anteriormente, siga as etapas para baixar os certificados com a chave privada e o certificado em um HSM.
### Baixar certificados com a chave privada e arquivos de certificado
**Para baixar certificados para o dispositivo**
1. Copie o AWS IoT certificado do item do seu computador de desenvolvimento para o dispositivo. Se o SSH e o SCP estiverem habilitados no computador de desenvolvimento e no dispositivo, será possível usar o comando `scp` no computador de desenvolvimento para transferir o certificado. *device-ip-address*Substitua pelo endereço IP do seu dispositivo.
```
scp -r greengrass-v2-certs/ device-ip-address:~
```
1. Crie a pasta raiz do Greengrass no dispositivo. Posteriormente, você instalará o software AWS IoT Greengrass Core nessa pasta.
**nota**
O Windows tem uma limitação de comprimento de caminho de 260 caracteres. Se você estiver usando o Windows, use uma pasta raiz como `C:\greengrass\v2` ou `D:\greengrass\v2` para manter os caminhos dos componentes do Greengrass abaixo do limite de 260 caracteres.
------
#### [ Linux or Unix ]
+ Substitua `/greengrass/v2` pela pasta a ser usada.
```
sudo mkdir -p /greengrass/v2
```
------
#### [ Windows Command Prompt ]
+ Substitua *C:\$1greengrass\$1v2* pela pasta a ser usada.
```
mkdir C:\greengrass\v2
```
------
#### [ PowerShell ]
+ Substitua *C:\$1greengrass\$1v2* pela pasta a ser usada.
```
mkdir C:\greengrass\v2
```
------
1. (Somente Linux) Defina as permissões do pai da pasta raiz do Greengrass.
+ */greengrass*Substitua pelo pai da pasta raiz.
```
sudo chmod 755 /greengrass
```
1. Copie os certificados do AWS IoT item para a pasta raiz do Greengrass.
------
#### [ Linux or Unix ]
+ Substitua `/greengrass/v2` pela pasta raiz do Greengrass.
```
sudo cp -R ~/greengrass-v2-certs/* /greengrass/v2
```
------
#### [ Windows Command Prompt ]
+ Substitua *C:\$1greengrass\$1v2* pela pasta a ser usada.
```
robocopy %USERPROFILE%\greengrass-v2-certs C:\greengrass\v2 /E
```
------
#### [ PowerShell ]
+ Substitua *C:\$1greengrass\$1v2* pela pasta a ser usada.
```
cp -Path ~\greengrass-v2-certs\* -Destination C:\greengrass\v2
```
------
1. Baixe o certificado da autoridade de certificação raiz (CA) da Amazon. AWS IoT os certificados são associados ao certificado CA raiz da Amazon por padrão.
------
#### [ Linux or Unix ]
```
sudo curl -o /greengrass/v2/AmazonRootCA1.pem https://www.amazontrust.com/repository/AmazonRootCA1.pem
```
------
#### [ Windows Command Prompt (CMD) ]
```
curl -o C:\greengrass\v2\\AmazonRootCA1.pem https://www.amazontrust.com/repository/AmazonRootCA1.pem
```
------
#### [ PowerShell ]
```
iwr -Uri https://www.amazontrust.com/repository/AmazonRootCA1.pem -OutFile C:\greengrass\v2\\AmazonRootCA1.pem
```
------
### Baixar certificados com a chave privada e o certificado em um HSM
**nota**
[Esse recurso está disponível para a versão 2.5.3 e posterior do componente núcleo do Greengrass.](greengrass-nucleus-component.md) AWS IoT Greengrass atualmente não oferece suporte a esse recurso nos dispositivos principais do Windows.
**Para baixar certificados para o dispositivo**
1. Copie o AWS IoT certificado do item do seu computador de desenvolvimento para o dispositivo. Se o SSH e o SCP estiverem habilitados no computador de desenvolvimento e no dispositivo, será possível usar o comando `scp` no computador de desenvolvimento para transferir o certificado. *device-ip-address*Substitua pelo endereço IP do seu dispositivo.
```
scp -r greengrass-v2-certs/ device-ip-address:~
```
1. Crie a pasta raiz do Greengrass no dispositivo. Posteriormente, você instalará o software AWS IoT Greengrass Core nessa pasta.
**nota**
O Windows tem uma limitação de comprimento de caminho de 260 caracteres. Se você estiver usando o Windows, use uma pasta raiz como `C:\greengrass\v2` ou `D:\greengrass\v2` para manter os caminhos dos componentes do Greengrass abaixo do limite de 260 caracteres.
------
#### [ Linux or Unix ]
+ Substitua `/greengrass/v2` pela pasta a ser usada.
```
sudo mkdir -p /greengrass/v2
```
------
#### [ Windows Command Prompt ]
+ Substitua *C:\$1greengrass\$1v2* pela pasta a ser usada.
```
mkdir C:\greengrass\v2
```
------
#### [ PowerShell ]
+ Substitua *C:\$1greengrass\$1v2* pela pasta a ser usada.
```
mkdir C:\greengrass\v2
```
------
1. (Somente Linux) Defina as permissões do pai da pasta raiz do Greengrass.
+ */greengrass*Substitua pelo pai da pasta raiz.
```
sudo chmod 755 /greengrass
```
1. Importe o arquivo de certificado do objeto, `~/greengrass-v2-certs/device.pem.crt`, para o HSM. Consulte a documentação do HSM para saber como importar certificados para ele. Importe o certificado usando o mesmo token, ID do slot, PIN do usuário, rótulo do objeto e ID do objeto (se o HSM usar um) em que você gerou a chave privada no HSM anteriormente.
**nota**
Se você gerou a chave privada anteriormente sem uma ID de objeto e o certificado tiver uma ID de objeto, defina a ID do objeto da chave privada com o mesmo valor do certificado. Consulte a documentação do HSM para saber como definir o ID do objeto de chave privada.
1. (Opcional) Exclua o arquivo de certificado do item, para que ele exista somente no HSM.
```
rm ~/greengrass-v2-certs/device.pem.crt
```
1. Baixe o certificado da autoridade de certificação raiz (CA) da Amazon. AWS IoT os certificados são associados ao certificado CA raiz da Amazon por padrão.
------
#### [ Linux or Unix ]
```
sudo curl -o /greengrass/v2/AmazonRootCA1.pem https://www.amazontrust.com/repository/AmazonRootCA1.pem
```
------
#### [ Windows Command Prompt (CMD) ]
```
curl -o C:\greengrass\v2\\AmazonRootCA1.pem https://www.amazontrust.com/repository/AmazonRootCA1.pem
```
------
#### [ PowerShell ]
```
iwr -Uri https://www.amazontrust.com/repository/AmazonRootCA1.pem -OutFile C:\greengrass\v2\\AmazonRootCA1.pem
```
------
## Configurar o ambiente do dispositivo
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
**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
**nota**
Esse recurso está disponível para a versão 2.5.0 e posterior do [componente de Greengrass nucleus](greengrass-nucleus-component.md).
**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.
## Baixe o software AWS IoT Greengrass Core
Você pode baixar a versão mais recente do software AWS IoT Greengrass Core no seguinte local:
+ [https://d2s8p88vqu9w66.cloudfront. net/releases/greengrass](https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip)-nucleus-latest.zip
**nota**
Você pode baixar uma versão específica do software AWS IoT Greengrass Core no seguinte local. *version*Substitua pela versão a ser baixada.
```
https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-version.zip
```
**Para baixar o software AWS IoT Greengrass Core**
1. Em seu 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. (Opcional) Para verificar a assinatura do software do Greengrass nucleus
**nota**
Esse atributo está disponível com o Greengrass nucleus versão 2.9.5 e posterior.
1. Use o comando a seguir para verificar a assinatura do artefato do Greengrass nucleus:
------
#### [ Linux or Unix ]
```
jarsigner -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
O nome do arquivo pode parecer diferente dependendo da versão do JDK que você instala. Substitua *`jdk17.0.6_10`* pela versão do JDK que você instalou.
```
"C:\\Program Files\\Amazon Corretto\\jdk17.0.6_10\\bin\\jarsigner.exe" -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
O nome do arquivo pode parecer diferente dependendo da versão do JDK que você instala. Substitua *`jdk17.0.6_10`* pela versão do JDK que você instalou.
```
'C:\\Program Files\\Amazon Corretto\\jdk17.0.6_10\\bin\\jarsigner.exe' -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
1. A invocação `jarsigner` produz uma saída que indica os resultados da verificação.
1. Se o arquivo zip do Greengrass nucleus estiver assinado, a saída conterá a seguinte declaração:
```
jar verified.
```
1. Se o arquivo zip do Greengrass nucleus não estiver assinado, a saída conterá a seguinte declaração:
```
jar is unsigned.
```
1. Se você forneceu a opção `-certs` do Jarsigner junto com as opções `-verify` e `-verbose`, a saída também incluirá informações detalhadas do certificado do assinante.
1. Descompacte o software AWS IoT Greengrass Core em uma pasta no seu dispositivo. *GreengrassInstaller*Substitua 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. (Opcional) Execute o comando a seguir para ver a versão do software AWS IoT Greengrass Core.
```
java -jar ./GreengrassInstaller/lib/Greengrass.jar --version
```
**Importante**
Se você instalar uma versão do núcleo do Greengrass anterior à v2.4.0, não remova essa pasta depois de instalar o software Core. AWS IoT Greengrass O software AWS IoT Greengrass Core usa os arquivos dessa pasta para ser executado.
Se você baixou a versão mais recente do software, instale a versão 2.4.0 ou posterior e poderá remover essa pasta depois de instalar o software AWS IoT Greengrass Core.
## Instale o software AWS IoT Greengrass Core
Execute o instalador com argumentos que especificam as seguintes ações:
+ Instale a partir de um arquivo de configuração parcial que especifica o uso AWS dos recursos e certificados que você criou anteriormente. O software AWS IoT Greengrass Core usa um arquivo de configuração que especifica a configuração de cada componente do Greengrass no dispositivo. O instalador cria um arquivo de configuração completo a partir do arquivo de configuração parcial fornecido por você.
+ 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ê.
+ 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, você deve configurar o software AWS IoT Greengrass Core como um serviço do sistema.
Para mais informações sobre os argumentos que podem ser especificados, consulte [Argumentos de instalação](configure-installer.md).
**nota**
Se você estiver executando 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).
+ Se você criou o certificado e a chave privada do item no AWS IoT serviço anteriormente, siga as etapas para instalar o software AWS IoT Greengrass Core com a chave privada e os arquivos de certificado.
+ Se você criou o certificado do item a partir de uma chave privada em um módulo de segurança de hardware (HSM) anteriormente, siga as etapas para instalar o software AWS IoT Greengrass Core com a chave privada e o certificado em um HSM.
### Instale o software AWS IoT Greengrass Core com arquivos de chave privada e certificado
**Para instalar o software AWS IoT Greengrass Core**
1. Verifique a versão do software AWS IoT Greengrass Core.
+ *GreengrassInstaller*Substitua pelo caminho para a pasta que contém o software.
```
java -jar ./GreengrassInstaller/lib/Greengrass.jar --version
```
1. Use um editor de texto para criar um arquivo de configuração chamado `config.yaml` para fornecer ao instalador.
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 GreengrassInstaller/config.yaml
```
Copie o seguinte conteúdo YAML para o arquivo. Esse arquivo de configuração parcial especifica os parâmetros do sistema e os parâmetros do Greengrass nucleus.
```
---
system:
certificateFilePath: "/greengrass/v2/device.pem.crt"
privateKeyPath: "/greengrass/v2/private.pem.key"
rootCaPath: "/greengrass/v2/AmazonRootCA1.pem"
rootpath: "/greengrass/v2"
thingName: "MyGreengrassCore"
services:
aws.greengrass.Nucleus:
componentType: "NUCLEUS"
version: "2.16.1"
configuration:
awsRegion: "us-west-2"
iotRoleAlias: "GreengrassCoreTokenExchangeRoleAlias"
iotDataEndpoint: "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
iotCredEndpoint: "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
```
Faça o seguinte:
+ Substitua cada instância de `/greengrass/v2` pela pasta raiz do Greengrass.
+ *MyGreengrassCore*Substitua pelo nome da AWS IoT coisa.
+ *2.16.1*Substitua pela versão do software AWS IoT Greengrass Core.
+ *us-west-2*Substitua pelo Região da AWS local onde você criou os recursos.
+ *GreengrassCoreTokenExchangeRoleAlias*Substitua pelo nome do alias da função de troca de tokens.
+ Substitua o `iotDataEndpoint` por seu endpoint de AWS IoT dados.
+ Substitua o `iotCredEndpoint` pelo endpoint de suas AWS IoT credenciais.
**nota**
Nesse arquivo de configuração, é possível personalizar outras opções de configuração do núcleo, como as portas e o proxy de rede a serem usados, conforme mostrado no exemplo a seguir. Para mais informações, consulte [Configuração do núcleo do Greengrass](greengrass-nucleus-component.md#greengrass-nucleus-component-configuration).
```
---
system:
certificateFilePath: "/greengrass/v2/device.pem.crt"
privateKeyPath: "/greengrass/v2/private.pem.key"
rootCaPath: "/greengrass/v2/AmazonRootCA1.pem"
rootpath: "/greengrass/v2"
thingName: "MyGreengrassCore"
services:
aws.greengrass.Nucleus:
componentType: "NUCLEUS"
version: "2.16.1"
configuration:
awsRegion: "us-west-2"
iotRoleAlias: "GreengrassCoreTokenExchangeRoleAlias"
iotCredEndpoint: "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
iotDataEndpoint: "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
mqtt:
port: 443
greengrassDataPlanePort: 443
networkProxy:
noProxyAddresses: "http://192.168.0.1,www.example.com"
proxy:
url: "https://my-proxy-server:1100"
username: "Mary_Major"
password: "pass@word1357"
```
1. Execute o instalador e especifique `--init-config` para fornecer o arquivo de configuração.
+ Substitua `/greengrass/v2` ou *C:\$1greengrass\$1v2* pela pasta raiz do Greengrass.
+ Substitua cada instância do *GreengrassInstaller* pela pasta em que você descompactou o instalador.
------
#### [ Linux or Unix ]
```
sudo -E java -Droot="/greengrass/v2" -Dlog.store=FILE \
-jar ./GreengrassInstaller/lib/Greengrass.jar \
--init-config ./GreengrassInstaller/config.yaml \
--component-default-user ggc_user:ggc_group \
--setup-system-service true
```
------
#### [ Windows Command Prompt (CMD) ]
```
java -Droot="C:\greengrass\v2" "-Dlog.store=FILE" ^
-jar ./GreengrassInstaller/lib/Greengrass.jar ^
--init-config ./GreengrassInstaller/config.yaml ^
--component-default-user ggc_user ^
--setup-system-service true
```
------
#### [ PowerShell ]
```
java -Droot="C:\greengrass\v2" "-Dlog.store=FILE" `
-jar ./GreengrassInstaller/lib/Greengrass.jar `
--init-config ./GreengrassInstaller/config.yaml `
--component-default-user ggc_user `
--setup-system-service true
```
------
**Importante**
Nos dispositivos principais do Windows, você deve especificar `--setup-system-service true` a configuração do software AWS IoT Greengrass Core como um serviço do sistema.
Se você especificar `--setup-system-service true`, o instalador imprimirá `Successfully set up Nucleus as a system service` se ele configurou e executou o software como um serviço do sistema. Caso contrário, o instalador não emitirá nenhuma mensagem se instalar o software com êxito.
**nota**
Não é possível usar o argumento `deploy-dev-tools` para implantar ferramentas de desenvolvimento local ao executar o instalador sem o argumento `--provision true`. Para informações sobre a implantação da CLI do Greengrass diretamente no dispositivo, consulte [Interface de linha de comando do Greengrass](gg-cli.md).
1. Verifique a instalação visualizando os arquivos na pasta raiz.
------
#### [ Linux or Unix ]
```
ls /greengrass/v2
```
------
#### [ Windows Command Prompt (CMD) ]
```
dir C:\greengrass\v2
```
------
#### [ PowerShell ]
```
ls C:\greengrass\v2
```
------
Se a instalação for bem-sucedida, a pasta raiz conterá várias pastas, como `config`, `packages` e `logs`.
### Instale o software AWS IoT Greengrass Core com a chave privada e o certificado em um HSM
**nota**
[Esse recurso está disponível para a versão 2.5.3 e posterior do componente núcleo do Greengrass.](greengrass-nucleus-component.md) AWS IoT Greengrass atualmente não oferece suporte a esse recurso nos dispositivos principais do Windows.
**Para instalar o software AWS IoT Greengrass Core**
1. Verifique a versão do software AWS IoT Greengrass Core.
+ *GreengrassInstaller*Substitua pelo caminho para a pasta que contém o software.
```
java -jar ./GreengrassInstaller/lib/Greengrass.jar --version
```
1. Para permitir que o software AWS IoT Greengrass Core use a chave privada e o certificado no HSM, instale o [componente do provedor PKCS \$111](pkcs11-provider-component.md) ao instalar o software AWS IoT Greengrass Core. O componente do provedor PKCS\$111 é um plug-in que você pode configurar durante a instalação. É possível baixar a versão mais recente do componente do provedor PKCS\$111 no seguinte local:
+ [https://d2s8p88vqu9w66.cloudfront. net/releases/Pkcs11Provider/aws.greengrass.crypto.pkcs11Provider-Latest.jar](https://d2s8p88vqu9w66.cloudfront.net/releases/Pkcs11Provider/aws.greengrass.crypto.Pkcs11Provider-latest.jar)
Baixe o plug-in do provedor PKCS\$111 para um arquivo chamado `aws.greengrass.crypto.Pkcs11Provider.jar`. *GreengrassInstaller*Substitua pela pasta que você deseja usar.
```
curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/Pkcs11Provider/aws.greengrass.crypto.Pkcs11Provider-latest.jar > GreengrassInstaller/aws.greengrass.crypto.Pkcs11Provider.jar
```
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. Use um editor de texto para criar um arquivo de configuração chamado `config.yaml` para fornecer ao instalador.
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 GreengrassInstaller/config.yaml
```
Copie o seguinte conteúdo YAML para o arquivo. Esse arquivo de configuração parcial especifica os parâmetros do sistema, os parâmetros do Greengrass nucleus e os parâmetros do provedor PKCS\$111.
```
---
system:
certificateFilePath: "pkcs11:object=iotdevicekey;type=cert"
privateKeyPath: "pkcs11:object=iotdevicekey;type=private"
rootCaPath: "/greengrass/v2/AmazonRootCA1.pem"
rootpath: "/greengrass/v2"
thingName: "MyGreengrassCore"
services:
aws.greengrass.Nucleus:
componentType: "NUCLEUS"
version: "2.16.1"
configuration:
awsRegion: "us-west-2"
iotRoleAlias: "GreengrassCoreTokenExchangeRoleAlias"
iotDataEndpoint: "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
iotCredEndpoint: "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
aws.greengrass.crypto.Pkcs11Provider:
configuration:
name: "softhsm_pkcs11"
library: "/usr/local/Cellar/softhsm/2.6.1/lib/softhsm/libsofthsm2.so"
slot: 1
userPin: "1234"
```
Faça o seguinte:
+ Substitua cada instância do PKCS \$111 URIs pelo rótulo do objeto *iotdevicekey* em que você criou a chave privada e importou o certificado.
+ Substitua cada instância de `/greengrass/v2` pela pasta raiz do Greengrass.
+ *MyGreengrassCore*Substitua pelo nome da AWS IoT coisa.
+ *2.16.1*Substitua pela versão do software AWS IoT Greengrass Core.
+ *us-west-2*Substitua pelo Região da AWS local onde você criou os recursos.
+ *GreengrassCoreTokenExchangeRoleAlias*Substitua pelo nome do alias da função de troca de tokens.
+ Substitua o `iotDataEndpoint` por seu endpoint de AWS IoT dados.
+ Substitua o `iotCredEndpoint` pelo endpoint de suas AWS IoT credenciais.
+ Substitua os parâmetros de configuração do componente `aws.greengrass.crypto.Pkcs11Provider` pelos valores da configuração do HSM no dispositivo principal.
**nota**
Nesse arquivo de configuração, é possível personalizar outras opções de configuração do núcleo, como as portas e o proxy de rede a serem usados, conforme mostrado no exemplo a seguir. Para mais informações, consulte [Configuração do núcleo do Greengrass](greengrass-nucleus-component.md#greengrass-nucleus-component-configuration).
```
---
system:
certificateFilePath: "pkcs11:object=iotdevicekey;type=cert"
privateKeyPath: "pkcs11:object=iotdevicekey;type=private"
rootCaPath: "/greengrass/v2/AmazonRootCA1.pem"
rootpath: "/greengrass/v2"
thingName: "MyGreengrassCore"
services:
aws.greengrass.Nucleus:
componentType: "NUCLEUS"
version: "2.16.1"
configuration:
awsRegion: "us-west-2"
iotRoleAlias: "GreengrassCoreTokenExchangeRoleAlias"
iotDataEndpoint: "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
iotCredEndpoint: "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
mqtt:
port: 443
greengrassDataPlanePort: 443
networkProxy:
noProxyAddresses: "http://192.168.0.1,www.example.com"
proxy:
url: "https://my-proxy-server:1100"
username: "Mary_Major"
password: "pass@word1357"
aws.greengrass.crypto.Pkcs11Provider:
configuration:
name: "softhsm_pkcs11"
library: "/usr/local/Cellar/softhsm/2.6.1/lib/softhsm/libsofthsm2.so"
slot: 1
userPin: "1234"
```
1. Execute o instalador e especifique `--init-config` para fornecer o arquivo de configuração.
+ Substitua `/greengrass/v2` pela pasta raiz do Greengrass.
+ Substitua cada instância do *GreengrassInstaller* pela pasta em que você descompactou o instalador.
```
sudo -E java -Droot="/greengrass/v2" -Dlog.store=FILE \
-jar ./GreengrassInstaller/lib/Greengrass.jar \
--trusted-plugin ./GreengrassInstaller/aws.greengrass.crypto.Pkcs11Provider.jar \
--init-config ./GreengrassInstaller/config.yaml \
--component-default-user ggc_user:ggc_group \
--setup-system-service true
```
**Importante**
Nos dispositivos principais do Windows, você deve especificar `--setup-system-service true` a configuração do software AWS IoT Greengrass Core como um serviço do sistema.
Se você especificar `--setup-system-service true`, o instalador imprimirá `Successfully set up Nucleus as a system service` se ele configurou e executou o software como um serviço do sistema. Caso contrário, o instalador não emitirá nenhuma mensagem se instalar o software com êxito.
**nota**
Não é possível usar o argumento `deploy-dev-tools` para implantar ferramentas de desenvolvimento local ao executar o instalador sem o argumento `--provision true`. Para informações sobre a implantação da CLI do Greengrass diretamente no dispositivo, consulte [Interface de linha de comando do Greengrass](gg-cli.md).
1. Verifique a instalação visualizando os arquivos na pasta raiz.
------
#### [ Linux or Unix ]
```
ls /greengrass/v2
```
------
#### [ Windows Command Prompt (CMD) ]
```
dir C:\greengrass\v2
```
------
#### [ PowerShell ]
```
ls C:\greengrass\v2
```
------
Se a instalação for bem-sucedida, a pasta raiz conterá várias pastas, como `config`, `packages` e `logs`.
Se você instalou o software AWS IoT Greengrass Core como um serviço do sistema, o instalador executa o software para você. Caso contrário, será preciso executar o software manualmente. Para obter mais informações, consulte [Execute o software AWS IoT Greengrass Core](run-greengrass-core-v2.md).
**nota**
Quando o software AWS IoT Greengrass Core se conectar à nuvem, seu dispositivo será reconhecido como um dispositivo Core.
Para obter mais informações sobre como configurar e usar o software AWS IoT Greengrass, consulte o seguinte:
+ [Configurar o software AWS IoT Greengrass principal](configure-greengrass-core-v2.md)
+ [Desenvolver componentes do AWS IoT Greengrass](develop-greengrass-components.md)
+ [Implemente AWS IoT Greengrass componentes em dispositivos](manage-deployments.md)
+ [Interface de linha de comando do Greengrass](gg-cli.md)
# Instale o software AWS IoT Greengrass principal com provisionamento de AWS IoT frota
Esse recurso está disponível para a versão 2.4.0 e posterior do [componente de Greengrass nucleus](greengrass-nucleus-component.md).
Com o provisionamento de AWS IoT frotas, você pode configurar AWS IoT para gerar e entregar com segurança certificados de dispositivos X.509 e chaves privadas aos seus dispositivos quando eles se conectarem pela primeira vez. AWS IoT AWS IoT fornece certificados de cliente assinados pela autoridade de certificação (CA) raiz da Amazon. Você também pode configurar AWS IoT para especificar grupos de coisas, tipos de coisas e permissões para os dispositivos principais do Greengrass que você provisiona com o provisionamento de frotas. Você define um *modelo de aprovisionamento* para definir como AWS IoT provisiona cada dispositivo. O modelo de provisionamento especifica o objeto, a política e os recursos de certificado a serem criados para um dispositivo durante o provisionamento. Para mais informações, consulte [Provisionamento de modelos](https://docs.aws.amazon.com/iot/latest/developerguide/provision-template.html) no *Guia do desenvolvedor do AWS IoT Core *.
AWS IoT Greengrass fornece um plug-in de provisionamento de AWS IoT frota que você pode usar para instalar o software AWS IoT Greengrass Core usando AWS recursos criados pelo provisionamento de AWS IoT frota. O plug-in de provisionamento de frota usa o *provisionamento por reivindicação*. Os dispositivos usam um certificado de reivindicação de provisionamento e uma chave privada para ter um certificado de dispositivo X.509 e uma chave privada exclusivos que podem ser usados para operações regulares. É possível incorporar o certificado de reivindicação e a chave privada em cada dispositivo durante a fabricação, para que seus clientes possam ativar os dispositivos posteriormente, quando cada dispositivo estiver on-line. É possível usar o mesmo certificado de reivindicação e chave privada para vários dispositivos. Para mais informações, consulte [Provisionamento por reivindicação](https://docs.aws.amazon.com/iot/latest/developerguide/provision-wo-cert.html#claim-based) no *Guia do desenvolvedor do AWS IoT Core *.
**nota**
Atualmente, o plug-in de provisionamento de frota não oferece suporte ao armazenamento de arquivos de chave privada e certificado em um módulo de segurança de hardware (HSM). Para usar um HSM, [instale o software AWS IoT Greengrass Core com provisionamento manual](manual-installation.md).
Para instalar o software AWS IoT Greengrass Core com provisionamento de AWS IoT frota, você deve configurar os recursos Conta da AWS que são AWS IoT usados para provisionar os dispositivos principais do Greengrass. Esses recursos incluem um modelo de provisionamento, certificados de reivindicação e um [perfil do IAM de troca de tokens](device-service-role.md). Depois de criar esses recursos, é possível reutilizá-los para provisionar vários dispositivos principais em uma frota. Para obter mais informações, consulte [Configure o provisionamento AWS IoT da frota para os principais dispositivos do Greengrass](fleet-provisioning-setup.md).
**Importante**
Antes de baixar o software AWS IoT Greengrass Core, verifique se seu dispositivo principal atende aos [requisitos](greengrass-nucleus-component.md#greengrass-v2-requirements) para instalar e executar o software AWS IoT Greengrass Core v2.0.
**Topics**
+ [Pré-requisitos](#fleet-provisioning-prerequisites)
+ [Recupere endpoints AWS IoT](#retrieve-iot-endpoints)
+ [Baixar certificados para o dispositivo](#download-claim-certificates)
+ [Configurar o ambiente do dispositivo](#set-up-device-environment)
+ [Baixe o software AWS IoT Greengrass Core](#download-greengrass-core-v2)
+ [Baixe o plug-in de aprovisionamento de AWS IoT frotas](#download-fleet-provisioning-plugin)
+ [Instale o software AWS IoT Greengrass Core](#run-greengrass-core-v2-installer-fleet)
+ [Configure o provisionamento AWS IoT da frota para os principais dispositivos do Greengrass](fleet-provisioning-setup.md)
+ [Configurar o plug-in de aprovisionamento de AWS IoT frotas](fleet-provisioning-configuration.md)
+ [Changelog do plugin de aprovisionamento de frota da AWS IoT](fleet-provisioning-changelog.md)
## Pré-requisitos
Para instalar o software AWS IoT Greengrass Core com provisionamento de AWS IoT frota, você deve primeiro [configurar o provisionamento de AWS IoT frota para os dispositivos principais do Greengrass](fleet-provisioning-setup.md). Depois de concluir essas etapas uma vez, você pode usar o provisionamento de frota para instalar o software AWS IoT Greengrass Core em qualquer número de dispositivos.
## Recupere endpoints AWS IoT
Obtenha os AWS IoT endpoints para você Conta da AWS e salve-os para usar mais tarde. Seu dispositivo usa esses endpoints para se conectar à AWS IoT. Faça o seguinte:
1. Obtenha o endpoint de AWS IoT dados para você Conta da AWS.
```
aws iot describe-endpoint --endpoint-type iot:Data-ATS
```
Se a solicitação for bem-sucedida, a resposta será semelhante ao exemplo a seguir.
```
{
"endpointAddress": "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
}
```
1. Obtenha o endpoint AWS IoT de credenciais para seu. Conta da AWS
```
aws iot describe-endpoint --endpoint-type iot:CredentialProvider
```
Se a solicitação for bem-sucedida, a resposta será semelhante ao exemplo a seguir.
```
{
"endpointAddress": "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
}
```
## Baixar certificados para o dispositivo
O dispositivo usa um certificado de solicitação e uma chave privada para autenticar sua solicitação para provisionar AWS recursos e adquirir um certificado de dispositivo X.509. É possível incorporar o certificado de reivindicação e a chave privada no dispositivo durante a fabricação ou copiar o certificado e a chave para o dispositivo durante a instalação. Nesta seção, você copia o certificado de reivindicação e a chave privada para o dispositivo. Você também pode baixar o certificado da autoridade de certificação (CA) raiz da Amazon ao dispositivo.
**Importante**
O provisionamento de chaves privadas de reivindicação deve ser protegido o tempo todo, inclusive em dispositivos principais do Greengrass. Recomendamos que você use CloudWatch métricas e registros da Amazon para monitorar indícios de uso indevido, como o uso não autorizado do certificado de solicitação para provisionar dispositivos. Se você detectar uso indevido, desative o certificado de reivindicação de provisionamento para que ele não possa ser usado para o provisionamento de dispositivos. Para obter mais informações, consulte [Monitorar AWS IoT](https://docs.aws.amazon.com/iot/latest/developerguide/monitoring_overview.html) no *Guia do Desenvolvedor do AWS IoT Core *.
Para ajudá-lo a gerenciar melhor o número de dispositivos e quais dispositivos se registram no seu Conta da AWS, você pode especificar um gancho de pré-provisionamento ao criar um modelo de aprovisionamento de frota. Um gancho de pré-provisionamento é uma AWS Lambda função que valida os parâmetros do modelo que os dispositivos fornecem durante o registro. Por exemplo, você pode criar um hook de pré-provisionamento que compara a ID do dispositivo a um banco de dados para verificar se ele tem permissão para provisionar. Para mais informações, consulte [Hooks de pré-provisionamento](https://docs.aws.amazon.com/iot/latest/developerguide/pre-provisioning-hook.html) no *Guia do desenvolvedor da AWS IoT Core *.
**Para baixar certificados de reivindicação para o dispositivo**
1. Copie o certificado de reivindicação e a chave privada para o dispositivo. Se o SSH e o SCP estiverem habilitados no computador de desenvolvimento e no dispositivo, será possível usar o comando `scp` no computador de desenvolvimento para transferir o certificado de reivindicação e a chave privada. O comando de exemplo a seguir transfere esses arquivos de uma pasta chamada `claim-certs` no computador de desenvolvimento para o dispositivo. *device-ip-address*Substitua pelo endereço IP do seu dispositivo.
```
scp -r claim-certs/ device-ip-address:~
```
1. Crie a pasta raiz do Greengrass no dispositivo. Posteriormente, você instalará o software AWS IoT Greengrass Core nessa pasta.
**nota**
O Windows tem uma limitação de comprimento de caminho de 260 caracteres. Se você estiver usando o Windows, use uma pasta raiz como `C:\greengrass\v2` ou `D:\greengrass\v2` para manter os caminhos dos componentes do Greengrass abaixo do limite de 260 caracteres.
------
#### [ Linux or Unix ]
+ Substitua `/greengrass/v2` pela pasta a ser usada.
```
sudo mkdir -p /greengrass/v2
```
------
#### [ Windows Command Prompt ]
+ Substitua *C:\$1greengrass\$1v2* pela pasta a ser usada.
```
mkdir C:\greengrass\v2
```
------
#### [ PowerShell ]
+ Substitua *C:\$1greengrass\$1v2* pela pasta a ser usada.
```
mkdir C:\greengrass\v2
```
------
1. (Somente Linux) Defina as permissões do pai da pasta raiz do Greengrass.
+ */greengrass*Substitua pelo pai da pasta raiz.
```
sudo chmod 755 /greengrass
```
1. Mova os certificados de reivindicação para a pasta raiz do Greengrass.
+ Substitua `/greengrass/v2` ou *C:\$1greengrass\$1v2* pela pasta raiz do Greengrass.
------
#### [ Linux or Unix ]
```
sudo mv ~/claim-certs /greengrass/v2
```
------
#### [ Windows Command Prompt (CMD) ]
```
move %USERPROFILE%\claim-certs C:\greengrass\v2
```
------
#### [ PowerShell ]
```
mv -Path ~\claim-certs -Destination C:\greengrass\v2
```
------
1. Baixe o certificado da autoridade de certificação raiz (CA) da Amazon. AWS IoT os certificados são associados ao certificado CA raiz da Amazon por padrão.
------
#### [ Linux or Unix ]
```
sudo curl -o /greengrass/v2/AmazonRootCA1.pem https://www.amazontrust.com/repository/AmazonRootCA1.pem
```
------
#### [ Windows Command Prompt (CMD) ]
```
curl -o C:\greengrass\v2\\AmazonRootCA1.pem https://www.amazontrust.com/repository/AmazonRootCA1.pem
```
------
#### [ PowerShell ]
```
iwr -Uri https://www.amazontrust.com/repository/AmazonRootCA1.pem -OutFile C:\greengrass\v2\\AmazonRootCA1.pem
```
------
## Configurar o ambiente do dispositivo
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
**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
**nota**
Esse recurso está disponível para a versão 2.5.0 e posterior do [componente de Greengrass nucleus](greengrass-nucleus-component.md).
**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.
## Baixe o software AWS IoT Greengrass Core
Você pode baixar a versão mais recente do software AWS IoT Greengrass Core no seguinte local:
+ [https://d2s8p88vqu9w66.cloudfront. net/releases/greengrass](https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip)-nucleus-latest.zip
**nota**
Você pode baixar uma versão específica do software AWS IoT Greengrass Core no seguinte local. *version*Substitua pela versão a ser baixada.
```
https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-version.zip
```
**Para baixar o software AWS IoT Greengrass Core**
1. Em seu 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. (Opcional) Para verificar a assinatura do software do Greengrass nucleus
**nota**
Esse atributo está disponível com o Greengrass nucleus versão 2.9.5 e posterior.
1. Use o comando a seguir para verificar a assinatura do artefato do Greengrass nucleus:
------
#### [ Linux or Unix ]
```
jarsigner -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
O nome do arquivo pode parecer diferente dependendo da versão do JDK que você instala. Substitua *`jdk17.0.6_10`* pela versão do JDK que você instalou.
```
"C:\\Program Files\\Amazon Corretto\\jdk17.0.6_10\\bin\\jarsigner.exe" -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
O nome do arquivo pode parecer diferente dependendo da versão do JDK que você instala. Substitua *`jdk17.0.6_10`* pela versão do JDK que você instalou.
```
'C:\\Program Files\\Amazon Corretto\\jdk17.0.6_10\\bin\\jarsigner.exe' -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
1. A invocação `jarsigner` produz uma saída que indica os resultados da verificação.
1. Se o arquivo zip do Greengrass nucleus estiver assinado, a saída conterá a seguinte declaração:
```
jar verified.
```
1. Se o arquivo zip do Greengrass nucleus não estiver assinado, a saída conterá a seguinte declaração:
```
jar is unsigned.
```
1. Se você forneceu a opção `-certs` do Jarsigner junto com as opções `-verify` e `-verbose`, a saída também incluirá informações detalhadas do certificado do assinante.
1. Descompacte o software AWS IoT Greengrass Core em uma pasta no seu dispositivo. *GreengrassInstaller*Substitua 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. (Opcional) Execute o comando a seguir para ver a versão do software AWS IoT Greengrass Core.
```
java -jar ./GreengrassInstaller/lib/Greengrass.jar --version
```
**Importante**
Se você instalar uma versão do núcleo do Greengrass anterior à v2.4.0, não remova essa pasta depois de instalar o software Core. AWS IoT Greengrass O software AWS IoT Greengrass Core usa os arquivos dessa pasta para ser executado.
Se você baixou a versão mais recente do software, instale a versão 2.4.0 ou posterior e poderá remover essa pasta depois de instalar o software AWS IoT Greengrass Core.
## Baixe o plug-in de aprovisionamento de AWS IoT frotas
Você pode baixar a versão mais recente do plug-in de aprovisionamento de AWS IoT frotas no seguinte local:
+ [https://d2s8p88vqu9w66.cloudfront. net/releases/aws-greengrass-FleetProvisioningByClaim/fleetprovisioningbyclaim](https://d2s8p88vqu9w66.cloudfront.net/releases/aws-greengrass-FleetProvisioningByClaim/fleetprovisioningbyclaim-latest.jar)-latest.jar
**nota**
Você pode baixar uma versão específica do plug-in de aprovisionamento de AWS IoT frotas no seguinte local. *version*Substitua pela versão a ser baixada. Para mais informações sobre cada versão do plug-in de provisionamento de frota, consulte [Changelog do plugin de aprovisionamento de frota da AWS IoT](fleet-provisioning-changelog.md).
```
https://d2s8p88vqu9w66.cloudfront.net/releases/aws-greengrass-FleetProvisioningByClaim/fleetprovisioningbyclaim-version.jar
```
O plug-in de provisionamento de frota é de código aberto. Para ver seu código-fonte, consulte o [plug-in de provisionamento de AWS IoT frota](https://github.com/aws-greengrass/aws-greengrass-fleet-provisioning-by-claim) ativado. GitHub
**Para baixar o plug-in de aprovisionamento de AWS IoT frotas**
+ Em seu dispositivo, baixe o plug-in de aprovisionamento de AWS IoT frota em um arquivo chamado. `aws.greengrass.FleetProvisioningByClaim.jar` *GreengrassInstaller*Substitua pela pasta que você deseja usar.
------
#### [ Linux or Unix ]
```
curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/aws-greengrass-FleetProvisioningByClaim/fleetprovisioningbyclaim-latest.jar > GreengrassInstaller/aws.greengrass.FleetProvisioningByClaim.jar
```
------
#### [ Windows Command Prompt (CMD) ]
```
curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/aws-greengrass-FleetProvisioningByClaim/fleetprovisioningbyclaim-latest.jar > GreengrassInstaller/aws.greengrass.FleetProvisioningByClaim.jar
```
------
#### [ PowerShell ]
```
iwr -Uri https://d2s8p88vqu9w66.cloudfront.net/releases/aws-greengrass-FleetProvisioningByClaim/fleetprovisioningbyclaim-latest.jar -OutFile GreengrassInstaller/aws.greengrass.FleetProvisioningByClaim.jar
```
------
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).
## Instale o software AWS IoT Greengrass Core
Execute o instalador com argumentos que especificam as seguintes ações:
+ Instale a partir de um arquivo de configuração parcial que especifica o uso do plug-in de provisionamento de frota para provisionar recursos. AWS O software AWS IoT Greengrass Core usa um arquivo de configuração que especifica a configuração de cada componente do Greengrass no dispositivo. O instalador cria um arquivo de configuração completo a partir do arquivo de configuração parcial que você fornece e dos recursos da AWS que o plug-in de aprovisionamento de frota cria.
+ 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ê.
+ 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, você deve configurar o software AWS IoT Greengrass Core como um serviço do sistema.
Para mais informações sobre os argumentos que podem ser especificados, consulte [Argumentos de instalação](configure-installer.md).
**nota**
Se você estiver executando 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).
**Para instalar o software AWS IoT Greengrass Core**
1. Verifique a versão do software AWS IoT Greengrass Core.
+ *GreengrassInstaller*Substitua pelo caminho para a pasta que contém o software.
```
java -jar ./GreengrassInstaller/lib/Greengrass.jar --version
```
1. Use um editor de texto para criar um arquivo de configuração chamado `config.yaml` para fornecer ao instalador.
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 GreengrassInstaller/config.yaml
```
Copie o seguinte conteúdo YAML para o arquivo. Esse arquivo de configuração parcial especifica os parâmetros para o plug-in de provisionamento de frota. Para informações sobre as opções que você pode especificar, consulte [Configurar o plug-in de aprovisionamento de AWS IoT frotas](fleet-provisioning-configuration.md).
------
#### [ Linux or Unix ]
```
---
services:
aws.greengrass.Nucleus:
version: "2.16.1"
aws.greengrass.FleetProvisioningByClaim:
configuration:
rootPath: "/greengrass/v2"
awsRegion: "us-west-2"
iotDataEndpoint: "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
iotCredentialEndpoint: "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
iotRoleAlias: "GreengrassCoreTokenExchangeRoleAlias"
provisioningTemplate: "GreengrassFleetProvisioningTemplate"
claimCertificatePath: "/greengrass/v2/claim-certs/claim.pem.crt"
claimCertificatePrivateKeyPath: "/greengrass/v2/claim-certs/claim.private.pem.key"
rootCaPath: "/greengrass/v2/AmazonRootCA1.pem"
templateParameters:
ThingName: "MyGreengrassCore"
ThingGroupName: "MyGreengrassCoreGroup"
```
------
#### [ Windows ]
```
---
services:
aws.greengrass.Nucleus:
version: "2.16.1"
aws.greengrass.FleetProvisioningByClaim:
configuration:
rootPath: "C:\\greengrass\\v2"
awsRegion: "us-west-2"
iotDataEndpoint: "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
iotCredentialEndpoint: "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
iotRoleAlias: "GreengrassCoreTokenExchangeRoleAlias"
provisioningTemplate: "GreengrassFleetProvisioningTemplate"
claimCertificatePath: "C:\\greengrass\\v2\\claim-certs\\claim.pem.crt"
claimCertificatePrivateKeyPath: "C:\\greengrass\\v2\\claim-certs\\claim.private.pem.key"
rootCaPath: "C:\\greengrass\\v2\\AmazonRootCA1.pem"
templateParameters:
ThingName: "MyGreengrassCore"
ThingGroupName: "MyGreengrassCoreGroup"
```
------
Faça o seguinte:
+ *2.16.1*Substitua pela versão do software AWS IoT Greengrass Core.
+ Substitua cada instância de `/greengrass/v2` ou *C:\$1greengrass\$1v2* pela pasta raiz do Greengrass.
**nota**
Em dispositivos Windows, é preciso especificar os separadores de caminho com barras invertidas duplas (`\\`), como `C:\\greengrass\\v2`.
+ *us-west-2*Substitua pela AWS região em que você criou o modelo de provisionamento e outros recursos.
+ Substitua o `iotDataEndpoint` por seu endpoint de AWS IoT dados.
+ Substitua o `iotCredentialEndpoint` pelo endpoint de suas AWS IoT credenciais.
+ *GreengrassCoreTokenExchangeRoleAlias*Substitua pelo nome do alias da função de troca de tokens.
+ *GreengrassFleetProvisioningTemplate*Substitua pelo nome do modelo de aprovisionamento da frota.
+ Substitua o `claimCertificatePath` pelo caminho para o certificado de reivindicação no dispositivo.
+ Substitua o `claimCertificatePrivateKeyPath` pelo caminho para a chave privada do certificado de reivindicação no dispositivo.
+ Substitua os parâmetros do modelo (`templateParameters`) pelos valores a serem usados para provisionar o dispositivo. Este exemplo se refere ao [modelo de exemplo](fleet-provisioning-setup.md#example-fleet-provisioning-template) que define os parâmetros `ThingName` e `ThingGroupName`.
**nota**
Neste arquivo de configuração, você pode personalizar outras opções de configuração, como as portas e o proxy de rede a serem usados, conforme mostrado no exemplo a seguir. Para obter mais informações, consulte [Configuração do Greengrass nucleus](greengrass-nucleus-component.md#greengrass-nucleus-component-configuration).
```
---
services:
aws.greengrass.Nucleus:
version: "2.16.1"
configuration:
mqtt:
port: 443
greengrassDataPlanePort: 443
networkProxy:
noProxyAddresses: "http://192.168.0.1,www.example.com"
proxy:
url: "http://my-proxy-server:1100"
username: "Mary_Major"
password: "pass@word1357"
aws.greengrass.FleetProvisioningByClaim:
configuration:
rootPath: "/greengrass/v2"
awsRegion: "us-west-2"
iotDataEndpoint: "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
iotCredentialEndpoint: "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
iotRoleAlias: "GreengrassCoreTokenExchangeRoleAlias"
provisioningTemplate: "GreengrassFleetProvisioningTemplate"
claimCertificatePath: "/greengrass/v2/claim-certs/claim.pem.crt"
claimCertificatePrivateKeyPath: "/greengrass/v2/claim-certs/claim.private.pem.key"
rootCaPath: "/greengrass/v2/AmazonRootCA1.pem"
templateParameters:
ThingName: "MyGreengrassCore"
ThingGroupName: "MyGreengrassCoreGroup"
mqttPort: 443
proxyUrl: "http://my-proxy-server:1100"
proxyUserName: "Mary_Major"
proxyPassword: "pass@word1357"
```
```
---
services:
aws.greengrass.Nucleus:
version: "2.16.1"
configuration:
mqtt:
port: 443
greengrassDataPlanePort: 443
networkProxy:
noProxyAddresses: "http://192.168.0.1,www.example.com"
proxy:
url: "http://my-proxy-server:1100"
username: "Mary_Major"
password: "pass@word1357"
aws.greengrass.FleetProvisioningByClaim:
configuration:
rootPath: "C:\\greengrass\\v2"
awsRegion: "us-west-2"
iotDataEndpoint: "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
iotCredentialEndpoint: "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
iotRoleAlias: "GreengrassCoreTokenExchangeRoleAlias"
provisioningTemplate: "GreengrassFleetProvisioningTemplate"
claimCertificatePath: "C:\\greengrass\\v2\\claim-certs\\claim.pem.crt"
claimCertificatePrivateKeyPath: "C:\\greengrass\\v2\\claim-certs\\claim.private.pem.key"
rootCaPath: "C:\\greengrass\\v2\\AmazonRootCA1.pem"
templateParameters:
ThingName: "MyGreengrassCore"
ThingGroupName: "MyGreengrassCoreGroup"
mqttPort: 443
proxyUrl: "http://my-proxy-server:1100"
proxyUserName: "Mary_Major"
proxyPassword: "pass@word1357"
```
Para usar um proxy HTTPS, é necessário usar a versão 1.1.0 ou posterior do plug-in de provisionamento de frota. Além disso, é necessário especificar o `rootCaPath` em `system`, conforme mostrado no exemplo a seguir.
```
---
system:
rootCaPath: "/greengrass/v2/AmazonRootCA1.pem"
services:
...
```
```
---
system:
rootCaPath: "C:\\greengrass\\v2\\AmazonRootCA1.pem"
services:
...
```
1. Execute o instalador. Especifique `--trusted-plugin` para fornecer o plug-in de provisionamento de frota e especifique `--init-config` para fornecer o arquivo de configuração.
+ Substitua `/greengrass/v2` pela pasta raiz do Greengrass.
+ Substitua cada instância do *GreengrassInstaller* pela pasta em que você descompactou o instalador.
------
#### [ Linux or Unix ]
```
sudo -E java -Droot="/greengrass/v2" -Dlog.store=FILE \
-jar ./GreengrassInstaller/lib/Greengrass.jar \
--trusted-plugin ./GreengrassInstaller/aws.greengrass.FleetProvisioningByClaim.jar \
--init-config ./GreengrassInstaller/config.yaml \
--component-default-user ggc_user:ggc_group \
--setup-system-service true
```
------
#### [ Windows Command Prompt (CMD) ]
```
java -Droot="C:\greengrass\v2" "-Dlog.store=FILE" ^
-jar ./GreengrassInstaller/lib/Greengrass.jar ^
--trusted-plugin ./GreengrassInstaller/aws.greengrass.FleetProvisioningByClaim.jar ^
--init-config ./GreengrassInstaller/config.yaml ^
--component-default-user ggc_user ^
--setup-system-service true
```
------
#### [ PowerShell ]
```
java -Droot="C:\greengrass\v2" "-Dlog.store=FILE" `
-jar ./GreengrassInstaller/lib/Greengrass.jar `
--trusted-plugin ./GreengrassInstaller/aws.greengrass.FleetProvisioningByClaim.jar `
--init-config ./GreengrassInstaller/config.yaml `
--component-default-user ggc_user `
--setup-system-service true
```
------
**Importante**
Nos dispositivos principais do Windows, você deve especificar `--setup-system-service true` a configuração do software AWS IoT Greengrass Core como um serviço do sistema.
Se você especificar `--setup-system-service true`, o instalador imprimirá `Successfully set up Nucleus as a system service` se ele configurou e executou o software como um serviço do sistema. Caso contrário, o instalador não emitirá nenhuma mensagem se instalar o software com êxito.
**nota**
Não é possível usar o argumento `deploy-dev-tools` para implantar ferramentas de desenvolvimento local ao executar o instalador sem o argumento `--provision true`. Para informações sobre a implantação da CLI do Greengrass diretamente no dispositivo, consulte [Interface de linha de comando do Greengrass](gg-cli.md).
1. Verifique a instalação visualizando os arquivos na pasta raiz.
------
#### [ Linux or Unix ]
```
ls /greengrass/v2
```
------
#### [ Windows Command Prompt (CMD) ]
```
dir C:\greengrass\v2
```
------
#### [ PowerShell ]
```
ls C:\greengrass\v2
```
------
Se a instalação for bem-sucedida, a pasta raiz conterá várias pastas, como `config`, `packages` e `logs`.
Se você instalou o software AWS IoT Greengrass Core como um serviço do sistema, o instalador executa o software para você. Caso contrário, será preciso executar o software manualmente. Para obter mais informações, consulte [Execute o software AWS IoT Greengrass Core](run-greengrass-core-v2.md).
Para obter mais informações sobre como configurar e usar o software AWS IoT Greengrass, consulte o seguinte:
+ [Configurar o software AWS IoT Greengrass principal](configure-greengrass-core-v2.md)
+ [Desenvolver componentes do AWS IoT Greengrass](develop-greengrass-components.md)
+ [Implemente AWS IoT Greengrass componentes em dispositivos](manage-deployments.md)
+ [Interface de linha de comando do Greengrass](gg-cli.md)
# Configure o provisionamento AWS IoT da frota para os principais dispositivos do Greengrass
Para [instalar o software AWS IoT Greengrass Core com provisionamento de frota](fleet-provisioning.md), você deve primeiro configurar os seguintes recursos em seu. Conta da AWS Esses recursos permitem que os dispositivos se registrem AWS IoT e operem como dispositivos principais do Greengrass. Siga as etapas desta seção para criar e configurar esses recursos na Conta da AWS.
+ Um perfil do IAM de troca de tokens, que os dispositivos principais usam para autorizar chamadas para serviços da AWS .
+ Um alias de AWS IoT função que aponta para a função de troca de tokens.
+ (Opcional) Uma AWS IoT política que os dispositivos principais usam para autorizar chamadas para os AWS IoT Greengrass serviços AWS IoT e. Essa AWS IoT política deve permitir a `iot:AssumeRoleWithCertificate` permissão para o alias de AWS IoT função que aponta para a função de troca de tokens.
Você pode usar uma única AWS IoT política para todos os dispositivos principais da sua frota ou pode configurar seu modelo de aprovisionamento da frota para criar uma AWS IoT política para cada dispositivo principal.
+ Um modelo de aprovisionamento de AWS IoT frota. Esse modelo precisa especificar o seguinte:
+ Qualquer AWS IoT coisa, recurso. É possível especificar uma lista de grupos de objetos existentes para implantar componentes em cada dispositivo quando on-line.
+ Um recurso AWS IoT político. Esse recurso pode definir uma das propriedades a seguir:
+ O nome de uma AWS IoT política existente. Se você escolher essa opção, os dispositivos principais criados a partir desse modelo usarão a mesma AWS IoT política e você poderá gerenciar suas permissões como uma frota.
+ Um documento AWS IoT de política. Se você escolher essa opção, cada dispositivo principal criado a partir desse modelo usará uma AWS IoT política exclusiva e você poderá gerenciar permissões para cada dispositivo principal individual.
+ Um recurso de AWS IoT certificado. Esse recurso de certificado precisa usar o parâmetro `AWS::IoT::Certificate::Id` para anexar o certificado ao dispositivo principal. Para obter mais informações, consulte [Just-in-time provisionamento no Guia](https://docs.aws.amazon.com/iot/latest/developerguide/jit-provisioning.html) do *AWS IoT desenvolvedor*.
+ Um certificado de solicitação AWS IoT de aprovisionamento e uma chave privada para o modelo de aprovisionamento da frota. É possível incorporar esse certificado e a chave privada nos dispositivos durante a fabricação, para que eles possam se registrar e se provisionar quando estiverem on-line.
**Importante**
As chaves privadas de reivindicação de provisionamento devem ser protegidas o tempo todo, inclusive nos dispositivos principais do Greengrass. Recomendamos que você use CloudWatch métricas e registros da Amazon para monitorar indícios de uso indevido, como o uso não autorizado do certificado de solicitação para provisionar dispositivos. Se você detectar uso indevido, desative o certificado de reivindicação de provisionamento para que ele não possa ser usado para o provisionamento de dispositivos. Para obter mais informações, consulte [Monitorar AWS IoT](https://docs.aws.amazon.com/iot/latest/developerguide/monitoring_overview.html) no *Guia do Desenvolvedor do AWS IoT Core *.
Para ajudá-lo a gerenciar melhor o número de dispositivos e quais dispositivos se registram no seu Conta da AWS, você pode especificar um gancho de pré-provisionamento ao criar um modelo de aprovisionamento de frota. Um gancho de pré-provisionamento é uma AWS Lambda função que valida os parâmetros do modelo que os dispositivos fornecem durante o registro. Por exemplo, você pode criar um hook de pré-provisionamento que compara a ID do dispositivo a um banco de dados para verificar se ele tem permissão para provisionar. Para mais informações, consulte [Hooks de pré-provisionamento](https://docs.aws.amazon.com/iot/latest/developerguide/pre-provisioning-hook.html) no *Guia do desenvolvedor da AWS IoT Core *.
+ Uma AWS IoT política que você anexa ao certificado de solicitação de aprovisionamento para permitir que os dispositivos se registrem e usem o modelo de aprovisionamento da frota.
**Topics**
+ [Criar um perfil de troca de token](#create-token-exchange-role)
+ [Crie uma AWS IoT política](#create-iot-policy)
+ [Criar um modelo de provisionamento de frota](#create-provisioning-template)
+ [Crie um certificado de reivindicação de provisionamento e uma chave privada](#create-claim-certificates)
## Criar um perfil de troca de token
Os dispositivos principais do Greengrass usam uma função de serviço do IAM, chamada função de *troca de tokens*, para autorizar chamadas para serviços. AWS O dispositivo usa o provedor de AWS IoT credenciais para obter AWS credenciais temporárias para essa função, o que permite que o dispositivo interaja AWS IoT, envie registros para o Amazon CloudWatch Logs e baixe artefatos de componentes personalizados do Amazon S3. Para obter mais informações, consulte [Autorize os dispositivos principais a interagir com os serviços AWS](device-service-role.md).
Você usa um *alias de AWS IoT função* para configurar a função de troca de tokens para os dispositivos principais do Greengrass. Os aliases de perfil permitem que você altere o perfil de troca de tokens de um dispositivo, mas mantenha a mesma configuração do dispositivo. Para mais informações, consulte [Autorizar de chamadas diretas para serviços da AWS](https://docs.aws.amazon.com/iot/latest/developerguide/authorizing-direct-aws.html) no *Guia do desenvolvedor do AWS IoT Core *.
Nesta seção, você cria uma função do IAM de troca de tokens e um alias de AWS IoT função que aponta para a função. Se você já configurou um dispositivo principal do Greengrass, pode usar o perfil de troca de tokens e o alias de perfil em vez de criar novos.
**Criar um perfil do IAM de troca de token**
1. Crie um perfil do IAM que seu dispositivo possa usar como um perfil de troca de tokens. Faça o seguinte:
1. Crie um arquivo que contenha o documento de política de confiança exigido pelo perfil de troca de token.
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 device-role-trust-policy.json
```
Copie o seguinte JSON no arquivo.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "credentials.iot.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
1. Crie o perfil de troca de token com o documento de política de confiança.
+ *GreengrassV2TokenExchangeRole*Substitua pelo nome da função do IAM a ser criada.
```
aws iam create-role --role-name GreengrassV2TokenExchangeRole --assume-role-policy-document file://device-role-trust-policy.json
```
Se a solicitação for bem-sucedida, a resposta será semelhante ao exemplo a seguir.
```
{
"Role": {
"Path": "/",
"RoleName": "GreengrassV2TokenExchangeRole",
"RoleId": "AROAZ2YMUHYHK5OKM77FB",
"Arn": "arn:aws:iam::123456789012:role/GreengrassV2TokenExchangeRole",
"CreateDate": "2021-02-06T00:13:29+00:00",
"AssumeRolePolicyDocument": {
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "credentials.iot.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
}
```
1. Crie um arquivo que contenha o documento de política de acesso exigido pelo perfil de troca de token.
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 device-role-access-policy.json
```
Copie o seguinte JSON no arquivo.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents",
"logs:DescribeLogStreams",
"s3:GetBucketLocation"
],
"Resource": "*"
}
]
}
```
**nota**
Essa política de acesso não permite acesso a artefatos de componentes nos buckets do S3. Para implantar componentes personalizados que definem artefatos no Amazon S3, é preciso adicionar permissões ao perfil para permitir que seu dispositivo principal recupere artefatos de componentes. Para obter mais informações, consulte [Permitir acesso aos buckets do S3 para artefatos de componentes](device-service-role.md#device-service-role-access-s3-bucket).
Se você ainda não tem um bucket do S3 para artefatos de componentes, é possível adicionar essas permissões depois de criar um bucket.
1. Crie uma política do IAM a partir do documento de política.
+ *GreengrassV2TokenExchangeRoleAccess*Substitua pelo nome da política do IAM a ser criada.
```
aws iam create-policy --policy-name GreengrassV2TokenExchangeRoleAccess --policy-document file://device-role-access-policy.json
```
Se a solicitação for bem-sucedida, a resposta será semelhante ao exemplo a seguir.
```
{
"Policy": {
"PolicyName": "GreengrassV2TokenExchangeRoleAccess",
"PolicyId": "ANPAZ2YMUHYHACI7C5Z66",
"Arn": "arn:aws:iam::123456789012:policy/GreengrassV2TokenExchangeRoleAccess",
"Path": "/",
"DefaultVersionId": "v1",
"AttachmentCount": 0,
"PermissionsBoundaryUsageCount": 0,
"IsAttachable": true,
"CreateDate": "2021-02-06T00:37:17+00:00",
"UpdateDate": "2021-02-06T00:37:17+00:00"
}
}
```
1. Anexe a política do IAM ao perfil de troca de token.
+ Substitua *GreengrassV2TokenExchangeRole* pelo nome da perfil do IAM.
+ Substitua o ARN da política pelo ARN da política do IAM que você criou na etapa anterior.
```
aws iam attach-role-policy --role-name GreengrassV2TokenExchangeRole --policy-arn arn:aws:iam::123456789012:policy/GreengrassV2TokenExchangeRoleAccess
```
O comando não terá nenhuma saída se a solicitação for bem-sucedida.
1. Crie um alias de AWS IoT função que aponte para a função de troca de tokens.
+ *GreengrassCoreTokenExchangeRoleAlias*Substitua pelo nome do alias de função a ser criado.
+ Substitua o ARN do perfil pelo ARN do perfil do IAM que você criou na etapa anterior.
```
aws iot create-role-alias --role-alias GreengrassCoreTokenExchangeRoleAlias --role-arn arn:aws:iam::123456789012:role/GreengrassV2TokenExchangeRole
```
Se a solicitação for bem-sucedida, a resposta será semelhante ao exemplo a seguir.
```
{
"roleAlias": "GreengrassCoreTokenExchangeRoleAlias",
"roleAliasArn": "arn:aws:iot:us-west-2:123456789012:rolealias/GreengrassCoreTokenExchangeRoleAlias"
}
```
**nota**
Para criar um alias do perfil, é preciso ter permissão para passar o perfil do IAM de troca de token para a AWS IoT. Se você receber uma mensagem de erro ao tentar criar um alias de função, verifique se o AWS usuário tem essa permissão. Para obter mais informações, consulte [Conceder permissões a um usuário para passar uma função para um AWS serviço](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_passrole.html) no *Guia do AWS Identity and Access Management usuário*.
## Crie uma AWS IoT política
Depois de registrar um dispositivo como uma AWS IoT coisa, esse dispositivo pode usar um certificado digital para se autenticar AWS. Esse certificado inclui uma ou mais AWS IoT políticas que definem as permissões que um dispositivo pode usar com o certificado. Essas políticas permitem que o dispositivo se comunique com AWS IoT AWS IoT Greengrass e.
Com o provisionamento AWS IoT da frota, os dispositivos se conectam AWS IoT para criar e baixar um certificado de dispositivo. No modelo de aprovisionamento de frota que você cria na próxima seção, você pode especificar se AWS IoT anexa a mesma AWS IoT política aos certificados de todos os dispositivos ou cria uma nova política para cada dispositivo.
Nesta seção, você cria uma AWS IoT política que se AWS IoT anexa aos certificados de todos os dispositivos. Com essa abordagem, é possível gerenciar as permissões para todos os dispositivos como uma frota. Se preferir criar uma nova AWS IoT política para cada dispositivo, você pode pular esta seção e consultar a política nela ao definir seu modelo de frota.
**Para criar uma AWS IoT política**
+ Crie uma AWS IoT política que defina as AWS IoT permissões para sua frota de dispositivos principais do Greengrass. A política a seguir permite acesso a todos os tópicos MQTT e operações do Greengrass, para que seu dispositivo funcione com aplicativos personalizados e futuras alterações que exijam novas operações do Greengrass. Essa política também permite `iot:AssumeRoleWithCertificate`, que possibilita que seus dispositivos usem o perfil de troca de tokens que você criou na seção anterior. É possível restringir essa política com base em 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).
Faça o seguinte:
1. Crie um arquivo que contenha o documento AWS IoT de política exigido pelos dispositivos principais do Greengrass.
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 greengrass-v2-iot-policy.json
```
Copie o seguinte JSON no arquivo.
+ Substitua o `iot:AssumeRoleWithCertificate` recurso pelo ARN do alias de AWS IoT função que você criou na seção anterior.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Publish",
"iot:Subscribe",
"iot:Receive",
"iot:Connect",
"greengrass:*"
],
"Resource": [
"*"
]
},
{
"Effect": "Allow",
"Action": "iot:AssumeRoleWithCertificate",
"Resource": "arn:aws:iot:us-east-1:123456789012:rolealias/GreengrassCoreTokenExchangeRoleAlias"
}
]
}
```
------
1. Crie uma AWS IoT política a partir do documento de política.
+ *GreengrassV2IoTThingPolicy*Substitua pelo nome da política a ser criada.
```
aws iot create-policy --policy-name GreengrassV2IoTThingPolicy --policy-document file://greengrass-v2-iot-policy.json
```
Se a solicitação for bem-sucedida, a resposta será semelhante ao exemplo a seguir.
------
#### [ JSON ]
****
```
{
"policyName": "GreengrassV2IoTThingPolicy",
"policyArn": "arn:aws:iot:us-west-2:123456789012:policy/GreengrassV2IoTThingPolicy",
"policyDocument": "{
\"Version\": \"2012-10-17\",
\"Statement\": [
{
\"Effect\": \"Allow\",
\"Action\": [
\"iot:Publish\",
\"iot:Subscribe\",
\"iot:Receive\",
\"iot:Connect\",
\"greengrass:*\"
],
\"Resource\": [
\"*\"
]
},
{
\"Effect\": \"Allow\",
\"Action\": \"iot:AssumeRoleWithCertificate\",
\"Resource\": \"arn:aws:iot:us-west-2:123456789012:rolealias/GreengrassCoreTokenExchangeRoleAlias\"
}
]
}",
"policyVersionId": "1"
}
```
------
## Criar um modelo de provisionamento de frota
AWS IoT os modelos de aprovisionamento de frotas definem como provisionar AWS IoT itens, políticas e certificados. Para provisionar os dispositivos principais do Greengrass com o plug-in de provisionamento de frota, é preciso criar um modelo que especifique o seguinte:
+ Qualquer AWS IoT coisa, recurso. É possível especificar uma lista de grupos de objetos existentes para implantar componentes em cada dispositivo quando on-line.
+ Um recurso AWS IoT político. Esse recurso pode definir uma das propriedades a seguir:
+ O nome de uma AWS IoT política existente. Se você escolher essa opção, os dispositivos principais criados a partir desse modelo usarão a mesma AWS IoT política e você poderá gerenciar suas permissões como uma frota.
+ Um documento AWS IoT de política. Se você escolher essa opção, cada dispositivo principal criado a partir desse modelo usará uma AWS IoT política exclusiva e você poderá gerenciar permissões para cada dispositivo principal individual.
+ Um recurso de AWS IoT certificado. Esse recurso de certificado precisa usar o parâmetro `AWS::IoT::Certificate::Id` para anexar o certificado ao dispositivo principal. Para obter mais informações, consulte [Just-in-time provisionamento no Guia](https://docs.aws.amazon.com/iot/latest/developerguide/jit-provisioning.html) do *AWS IoT desenvolvedor*.
No modelo, você pode especificar a adição da AWS IoT coisa a uma lista de grupos de coisas existentes. Quando o dispositivo principal se conecta AWS IoT Greengrass pela primeira vez, ele recebe implantações do Greengrass para cada grupo do qual é membro. É possível usar grupos de objetos para implantar o software mais recente em cada dispositivo assim que ele estiver online. Para obter mais informações, consulte [Implemente AWS IoT Greengrass componentes em dispositivos](manage-deployments.md).
O AWS IoT serviço exige permissões para criar e atualizar AWS IoT recursos em seu dispositivo Conta da AWS ao provisionar dispositivos. Para dar acesso ao AWS IoT serviço, você cria uma função do IAM e a fornece ao criar o modelo. AWS IoT fornece uma política gerenciada, [AWSIoTThingsRegistro](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/service-role/AWSIoTThingsRegistration), que permite acesso a todas as permissões que AWS IoT podem ser usadas ao provisionar dispositivos. É possível usar essa política gerenciada ou criar uma política personalizada que defina as permissões na política gerenciada para seu caso de uso.
Nesta seção, você cria uma função do IAM que permite AWS IoT provisionar recursos para dispositivos e cria um modelo de aprovisionamento de frota que usa essa função do IAM.
**Para criar um modelo de provisionamento de frota**
1. Crie uma função do IAM que AWS IoT possa assumir o provisionamento de recursos em seu Conta da AWS. Faça o seguinte:
1. Crie um arquivo que contenha o documento de política de confiança que AWS IoT permite assumir a funçã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 aws-iot-trust-policy.json
```
Copie o seguinte JSON no arquivo.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "iot.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
1. Crie um perfil do IAM com um documento de política de confiança.
+ *GreengrassFleetProvisioningRole*Substitua pelo nome da função do IAM a ser criada.
```
aws iam create-role --role-name GreengrassFleetProvisioningRole --assume-role-policy-document file://aws-iot-trust-policy.json
```
Se a solicitação for bem-sucedida, a resposta será semelhante ao exemplo a seguir.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Connect",
"iot:Publish",
"iot:Subscribe",
"iot:Receive"
],
"Resource": "*"
}
]
}
```
------
1. Revise a política de [AWSIoTThingsregistro](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/service-role/AWSIoTThingsRegistration), que permite acesso a todas as permissões que AWS IoT podem ser usadas ao provisionar dispositivos. Você pode usar essa política gerenciada ou criar uma política personalizada que defina permissões restritas para o seu caso de uso. Se você optar por criar uma política personalizada, faça isso agora.
1. Anexe a política do IAM ao perfil de provisionamento de frota.
+ Substitua *GreengrassFleetProvisioningRole* pelo nome da perfil do IAM.
+ Se você criou uma política personalizada na etapa anterior, substitua o ARN da política pelo ARN da política do IAM a ser usada.
```
aws iam attach-role-policy --role-name GreengrassFleetProvisioningRole --policy-arn arn:aws:iam::aws:policy/service-role/AWSIoTThingsRegistration
```
O comando não terá nenhuma saída se a solicitação for bem-sucedida.
1. (Opcional) Crie um *hook de pré-provisionamento*, que é uma função AWS Lambda que valida os parâmetros do modelo que os dispositivos fornecem durante o registro. É possível usar um hook de pré-provisionamento para ter mais controle sobre quais e quantos dispositivos estão integrados na sua Conta da AWS. Para mais informações, consulte [Hooks de pré-provisionamento](https://docs.aws.amazon.com/iot/latest/developerguide/pre-provisioning-hook.html) no *Guia do desenvolvedor da AWS IoT Core *.
1. Crie um modelo de provisionamento de frota. Faça o seguinte:
1. Crie um arquivo para conter o documento modelo de provisionamento.
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 greengrass-fleet-provisioning-template.json
```
Escreva o documento modelo de provisionamento. Você pode começar com o seguinte exemplo de modelo de aprovisionamento, que especifica a criação de AWS IoT algo com as seguintes propriedades:
+ O nome do objeto é o valor que você especifica no parâmetro do modelo `ThingName`.
+ O objeto é um membro do grupo de objetos que você especifica no parâmetro do modelo `ThingGroupName`. O grupo de coisas deve existir em seu Conta da AWS.
+ O certificado da coisa tem a AWS IoT política nomeada `GreengrassV2IoTThingPolicy` anexada a ele.
Para mais informações, consulte [Provisionamento de modelos](https://docs.aws.amazon.com/iot/latest/developerguide/provision-template.html) no *Guia do desenvolvedor do AWS IoT Core *.
```
{
"Parameters": {
"ThingName": {
"Type": "String"
},
"ThingGroupName": {
"Type": "String"
},
"AWS::IoT::Certificate::Id": {
"Type": "String"
}
},
"Resources": {
"MyThing": {
"OverrideSettings": {
"AttributePayload": "REPLACE",
"ThingGroups": "REPLACE",
"ThingTypeName": "REPLACE"
},
"Properties": {
"AttributePayload": {},
"ThingGroups": [
{
"Ref": "ThingGroupName"
}
],
"ThingName": {
"Ref": "ThingName"
}
},
"Type": "AWS::IoT::Thing"
},
"MyPolicy": {
"Properties": {
"PolicyName": "GreengrassV2IoTThingPolicy"
},
"Type": "AWS::IoT::Policy"
},
"MyCertificate": {
"Properties": {
"CertificateId": {
"Ref": "AWS::IoT::Certificate::Id"
},
"Status": "Active"
},
"Type": "AWS::IoT::Certificate"
}
}
}
```
**nota**
*MyThing*,*MyPolicy*, e *MyCertificate* são nomes arbitrários que identificam cada especificação de recurso no modelo de aprovisionamento da frota. AWS IoT não usa esses nomes nos recursos que ele cria a partir do modelo. Você pode usar esses nomes ou substituí-los por valores que ajudam a identificar cada recurso no modelo.
1. Crie o modelo de provisionamento de frota a partir do documento do modelo de provisionamento.
+ Substitua *GreengrassFleetProvisioningTemplate* pelo nome do modelo a ser criado.
+ Substitua descrição do modelo por uma descrição para o modelo.
+ Substitua o ARN do perfil de provisionamento pelo ARN do perfil que você criou anteriormente.
------
#### [ Linux or Unix ]
```
aws iot create-provisioning-template \
--template-name GreengrassFleetProvisioningTemplate \
--description "A provisioning template for Greengrass core devices." \
--provisioning-role-arn "arn:aws:iam::123456789012:role/GreengrassFleetProvisioningRole" \
--template-body file://greengrass-fleet-provisioning-template.json \
--enabled
```
------
#### [ Windows Command Prompt (CMD) ]
```
aws iot create-provisioning-template ^
--template-name GreengrassFleetProvisioningTemplate ^
--description "A provisioning template for Greengrass core devices." ^
--provisioning-role-arn "arn:aws:iam::123456789012:role/GreengrassFleetProvisioningRole" ^
--template-body file://greengrass-fleet-provisioning-template.json ^
--enabled
```
------
#### [ PowerShell ]
```
aws iot create-provisioning-template `
--template-name GreengrassFleetProvisioningTemplate `
--description "A provisioning template for Greengrass core devices." `
--provisioning-role-arn "arn:aws:iam::123456789012:role/GreengrassFleetProvisioningRole" `
--template-body file://greengrass-fleet-provisioning-template.json `
--enabled
```
------
**nota**
Se você criou um hook de pré-provisionamento, especifique o ARN da função do Lambda do hook de pré-provisionamento com o argumento `--pre-provisioning-hook`.
```
--pre-provisioning-hook targetArn=arn:aws:lambda:us-west-2:123456789012:function:GreengrassPreProvisioningHook
```
Se a solicitação for bem-sucedida, a resposta será semelhante ao exemplo a seguir.
```
{
"templateArn": "arn:aws:iot:us-west-2:123456789012:provisioningtemplate/GreengrassFleetProvisioningTemplate",
"templateName": "GreengrassFleetProvisioningTemplate",
"defaultVersionId": 1
}
```
## Crie um certificado de reivindicação de provisionamento e uma chave privada
Os certificados de declaração são certificados X.509 que permitem que os dispositivos se registrem como AWS IoT itens e recuperem um certificado de dispositivo X.509 exclusivo para uso em operações regulares. Depois de criar um certificado de solicitação, você anexa uma AWS IoT política que permite que os dispositivos o usem para criar certificados de dispositivo exclusivos e provisionar com um modelo de aprovisionamento de frota. Os dispositivos com o certificado de reivindicação podem provisionar usando somente o modelo de provisionamento permitido na política de AWS IoT .
Nesta seção, você cria o certificado de reivindicação e o configura para os dispositivos usarem com o modelo de provisionamento de frota criado na seção anterior.
**Importante**
As chaves privadas de solicitação de provisionamento devem ser protegidas o tempo todo, inclusive nos dispositivos principais do Greengrass. Recomendamos que você use CloudWatch métricas e registros da Amazon para monitorar indícios de uso indevido, como o uso não autorizado do certificado de solicitação para provisionar dispositivos. Se você detectar uso indevido, desative o certificado de reivindicação de provisionamento para que ele não possa ser usado para o provisionamento de dispositivos. Para obter mais informações, consulte [Monitorar AWS IoT](https://docs.aws.amazon.com/iot/latest/developerguide/monitoring_overview.html) no *Guia do Desenvolvedor do AWS IoT Core *.
Para ajudá-lo a gerenciar melhor o número de dispositivos e quais dispositivos se registram no seu Conta da AWS, você pode especificar um gancho de pré-provisionamento ao criar um modelo de aprovisionamento de frota. Um gancho de pré-provisionamento é uma AWS Lambda função que valida os parâmetros do modelo que os dispositivos fornecem durante o registro. Por exemplo, você pode criar um hook de pré-provisionamento que compara a ID do dispositivo a um banco de dados para verificar se ele tem permissão para provisionar. Para mais informações, consulte [Hooks de pré-provisionamento](https://docs.aws.amazon.com/iot/latest/developerguide/pre-provisioning-hook.html) no *Guia do desenvolvedor da AWS IoT Core *.
**Crie um certificado de reivindicação de provisionamento e uma chave privada**
1. Crie uma pasta na qual você faz download do certificado de reivindicação e da chave privada.
```
mkdir claim-certs
```
1. Crie e salve um certificado e uma chave privada para usar no provisionamento. AWS IoT fornece certificados de cliente assinados pela autoridade de certificação (CA) raiz da Amazon.
------
#### [ Linux or Unix ]
```
aws iot create-keys-and-certificate \
--certificate-pem-outfile "claim-certs/claim.pem.crt" \
--public-key-outfile "claim-certs/claim.public.pem.key" \
--private-key-outfile "claim-certs/claim.private.pem.key" \
--set-as-active
```
------
#### [ Windows Command Prompt (CMD) ]
```
aws iot create-keys-and-certificate ^
--certificate-pem-outfile "claim-certs/claim.pem.crt" ^
--public-key-outfile "claim-certs/claim.public.pem.key" ^
--private-key-outfile "claim-certs/claim.private.pem.key" ^
--set-as-active
```
------
#### [ PowerShell ]
```
aws iot create-keys-and-certificate `
--certificate-pem-outfile "claim-certs/claim.pem.crt" `
--public-key-outfile "claim-certs/claim.public.pem.key" `
--private-key-outfile "claim-certs/claim.private.pem.key" `
--set-as-active
```
------
A resposta contém informações sobre o certificado, se a solicitação for bem-sucedida. Salve o ARN do certificado para usar posteriormente.
1. Crie e anexe uma AWS IoT política que permita que os dispositivos usem o certificado para criar certificados de dispositivos exclusivos e provisionar com o modelo de aprovisionamento da frota. A política a seguir permite acesso à API do MQTT de provisionamento de dispositivo. Para mais informações, consulte [API MQTT de provisionamento de dispositivos](https://docs.aws.amazon.com/iot/latest/developerguide/fleet-provision-api.html) no *Guia do desenvolvedor do AWS IoT Core *.
Faça o seguinte:
1. Crie um arquivo que contenha o documento AWS IoT de política exigido pelos dispositivos principais do Greengrass.
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 greengrass-provisioning-claim-iot-policy.json
```
Copie o seguinte JSON no arquivo.
+ Substitua cada instância *region* de pela Região da AWS onde você configura o provisionamento da frota.
+ Substitua cada instância do *account-id* pelo seu Conta da AWS ID.
+ Substitua cada instância do *GreengrassFleetProvisioningTemplate* pelo nome do modelo de aprovisionamento de frota que você criou na seção anterior.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "iot:Connect",
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"iot:Publish",
"iot:Receive"
],
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topic/$aws/certificates/create/*",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/provisioning-templates/GreengrassFleetProvisioningTemplate/provision/*"
]
},
{
"Effect": "Allow",
"Action": "iot:Subscribe",
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/certificates/create/*",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/provisioning-templates/GreengrassFleetProvisioningTemplate/provision/*"
]
}
]
}
```
------
1. Crie uma AWS IoT política a partir do documento de política.
+ *GreengrassProvisioningClaimPolicy*Substitua pelo nome da política a ser criada.
```
aws iot create-policy --policy-name GreengrassProvisioningClaimPolicy --policy-document file://greengrass-provisioning-claim-iot-policy.json
```
Se a solicitação for bem-sucedida, a resposta será semelhante ao exemplo a seguir.
------
#### [ JSON ]
****
```
{
"policyName": "GreengrassProvisioningClaimPolicy",
"policyArn": "arn:aws:iot:us-west-2:123456789012:policy/GreengrassProvisioningClaimPolicy",
"policyDocument": "{
\"Version\": \"2012-10-17\",
\"Statement\": [
{
\"Effect\": \"Allow\",
\"Action\": \"iot:Connect\",
\"Resource\": \"*\"
},
{
\"Effect\": \"Allow\",
\"Action\": [
\"iot:Publish\",
\"iot:Receive\"
],
\"Resource\": [
\"arn:aws:iot:us-east-1:123456789012:topic/$aws/certificates/create/*\",
\"arn:aws:iot:us-east-1:123456789012:topic/$aws/provisioning-templates/GreengrassFleetProvisioningTemplate/provision/*\"
]
},
{
\"Effect\": \"Allow\",
\"Action\": \"iot:Subscribe\",
\"Resource\": [
\"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/certificates/create/*\",
\"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/provisioning-templates/GreengrassFleetProvisioningTemplate/provision/*\"
]
}
]
}",
"policyVersionId": "1"
}
```
------
1. Anexe a AWS IoT política ao certificado de solicitação de aprovisionamento.
+ *GreengrassProvisioningClaimPolicy*Substitua pelo nome da política a ser anexada.
+ Substitua o ARN de destino pelo ARN do certificado de reivindicação de provisionamento.
```
aws iot attach-policy --policy-name GreengrassProvisioningClaimPolicy --target arn:aws:iot:us-west-2:123456789012:cert/aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4
```
O comando não terá nenhuma saída se a solicitação for bem-sucedida.
Agora você tem um certificado de solicitação de provisionamento e uma chave privada que os dispositivos podem usar para se registrar AWS IoT e se provisionar como dispositivos principais do Greengrass. Você pode incorporar o certificado de solicitação e a chave privada nos dispositivos durante a fabricação ou copiar o certificado e a chave nos dispositivos antes de instalar o software AWS IoT Greengrass Core. Para obter mais informações, consulte [Instale o software AWS IoT Greengrass principal com provisionamento de AWS IoT frota](fleet-provisioning.md).
# Configurar o plug-in de aprovisionamento de AWS IoT frotas
O plug-in de provisionamento de AWS IoT frota fornece os seguintes parâmetros de configuração que você pode personalizar ao [instalar o software AWS IoT Greengrass Core com provisionamento de frota](fleet-provisioning.md).
`rootPath`
O caminho para a pasta a ser usada como raiz do software AWS IoT Greengrass Core.
`awsRegion`
O Região da AWS que o plug-in de provisionamento de frota usa para AWS provisionar recursos.
`iotDataEndpoint`
O endpoint de AWS IoT dados para seu. Conta da AWS
`iotCredentialEndpoint`
O endpoint AWS IoT de credenciais para seu. Conta da AWS
`iotRoleAlias`
O alias de AWS IoT função que aponta para uma função do IAM de troca de tokens. O provedor de AWS IoT credenciais assume essa função para permitir que o dispositivo principal do Greengrass interaja com os serviços. AWS Para obter mais informações, consulte [Autorize os dispositivos principais a interagir com os serviços AWS](device-service-role.md).
`provisioningTemplate`
O modelo de provisionamento de AWS IoT frota a ser usado para AWS provisionar recursos. Esse modelo precisa especificar o seguinte:
+ Qualquer AWS IoT coisa, recurso. É possível especificar uma lista de grupos de objetos existentes para implantar componentes em cada dispositivo quando on-line.
+ Um recurso AWS IoT político. Esse recurso pode definir uma das propriedades a seguir:
+ O nome de uma AWS IoT política existente. Se você escolher essa opção, os dispositivos principais criados a partir desse modelo usarão a mesma AWS IoT política e você poderá gerenciar suas permissões como uma frota.
+ Um documento AWS IoT de política. Se você escolher essa opção, cada dispositivo principal criado a partir desse modelo usará uma AWS IoT política exclusiva e você poderá gerenciar permissões para cada dispositivo principal individual.
+ Um recurso de AWS IoT certificado. Esse recurso de certificado precisa usar o parâmetro `AWS::IoT::Certificate::Id` para anexar o certificado ao dispositivo principal. Para obter mais informações, consulte [Just-in-time provisionamento no Guia](https://docs.aws.amazon.com/iot/latest/developerguide/jit-provisioning.html) do *AWS IoT desenvolvedor*.
Para obter mais informações, consulte [Modelos de provisionamento](https://docs.aws.amazon.com/iot/latest/developerguide/provision-template.html) no *Guia do desenvolvedor do AWS IoT Core *.
`claimCertificatePath`
O caminho para o certificado de reivindicação de provisionamento para o modelo que você especifica no `provisioningTemplate`. Para obter mais informações, consulte [CreateProvisioningClaim](https://docs.aws.amazon.com/iot/latest/apireference/API_CreateProvisioningClaim.html) na *Referência de APIs do AWS IoT Core *.
`claimCertificatePrivateKeyPath`
O caminho para a chave privada do certificado de reivindicação de provisionamento. para o modelo que você especifica no `provisioningTemplate`. Para obter mais informações, consulte [CreateProvisioningClaim](https://docs.aws.amazon.com/iot/latest/apireference/API_CreateProvisioningClaim.html) na *Referência de APIs do AWS IoT Core *.
O provisionamento de chaves privadas de reivindicação deve ser protegido o tempo todo, inclusive em dispositivos principais do Greengrass. Recomendamos que você use CloudWatch métricas e registros da Amazon para monitorar indícios de uso indevido, como o uso não autorizado do certificado de solicitação para provisionar dispositivos. Se você detectar uso indevido, desative o certificado de reivindicação de provisionamento para que ele não possa ser usado para o provisionamento de dispositivos. Para obter mais informações, consulte [Monitorar AWS IoT](https://docs.aws.amazon.com/iot/latest/developerguide/monitoring_overview.html) no *Guia do Desenvolvedor do AWS IoT Core *.
Para ajudá-lo a gerenciar melhor o número de dispositivos e quais dispositivos se registram no seu Conta da AWS, você pode especificar um gancho de pré-provisionamento ao criar um modelo de aprovisionamento de frota. Um gancho de pré-provisionamento é uma AWS Lambda função que valida os parâmetros do modelo que os dispositivos fornecem durante o registro. Por exemplo, você pode criar um hook de pré-provisionamento que compara a ID do dispositivo a um banco de dados para verificar se ele tem permissão para provisionar. Para mais informações, consulte [Hooks de pré-provisionamento](https://docs.aws.amazon.com/iot/latest/developerguide/pre-provisioning-hook.html) no *Guia do desenvolvedor do AWS IoT Core *.
`rootCaPath`
O caminho para o certificado da autoridade de certificação (CA) raiz da Amazon.
`templateParameters`
(Opcional) O mapa dos parâmetros a serem fornecidos ao modelo de provisionamento de frotas. Para mais informações, consulte [Seção de parâmetros de modelos de provisionamento](https://docs.aws.amazon.com/iot/latest/developerguide/provision-template.html#parameters-section), no *Guia do desenvolvedor do AWS IoT Core *.
`deviceId`
(Opcional) O identificador do dispositivo a ser usado como ID do cliente quando o plug-in de provisionamento de frotas cria uma conexão MQTT com a AWS IoT.
Padrão: um UUID aleatório.
`mqttPort`
(Opcional) A porta usada para conexões MQTT.
Padrão: `8883`
`proxyUrl`
(opcional) O URL do servidor de proxy, no formato `scheme://userinfo@host:port`. Para usar um proxy de HTTPS, é preciso usar a versão 1.1.0 ou posterior do plug-in de provisionamento de frotas.
+ `scheme`: o esquema, que precisa ser `http` ou `https`.
**Importante**
Os dispositivos do Greengrass nucleus devem executar o [Greengrass nucleus](greengrass-nucleus-component.md) v2.5.0 ou posterior para usar proxies HTTPS.
Se você configurar um proxy HTTPS, deverá adicionar o certificado de CA do servidor proxy ao certificado de CA raiz da Amazon do dispositivo principal. Para obter mais informações, consulte [Ative o dispositivo principal para confiar em um proxy HTTPS](configure-greengrass-core-v2.md#https-proxy-certificate-trust).
+ `userinfo`: (opcional) as informações de nome de usuário e senha. Se você especificar essas informações no `url`, o dispositivo principal do Greengrass ignorará os campos `username` e `password`.
+ `host`: o nome do host ou endereço IP do servidor de proxy.
+ `port`: (opcional) o número da porta. Se você não especifica a porta, o dispositivo principal do Greengrass usa os seguintes valores padrão:
+ `http`: 80
+ `https`: 443
`proxyUserName`
(Opcional) O nome de usuário que autentica o servidor de proxy.
`proxyPassword`
(Opcional) O nome de usuário que autentica o servidor de proxy.
csrPath
(Opcional) O caminho para o arquivo de solicitação de assinatura de certificado (CSR) que será usado para criar o certificado do dispositivo a partir de uma CSR. Para mais informações, consulte [Provisionamento por reivindicação](https://docs.aws.amazon.com/iot/latest/developerguide/provision-wo-cert.html#claim-based) no *guia do desenvolvedor do AWS IoT Core *.
csrPrivateKeyCaminho
(Opcional, obrigatório se o `csrPath` for declarado) O caminho para a chave privada usada para gerar a CSR. A chave privada deve ter sido usada para gerar a CSR. Para mais informações, consulte [Provisionamento por reivindicação](https://docs.aws.amazon.com/iot/latest/developerguide/provision-wo-cert.html#claim-based) no *guia do desenvolvedor do AWS IoT Core *.
certificatePath
(Opcional) O caminho a ser usado para salvar o certificado do dispositivo baixado.
privateKeyPath
(Opcional) O caminho a ser usado para salvar a chave privada do dispositivo baixado.
# Changelog do plugin de aprovisionamento de frota da AWS IoT
A tabela a seguir descreve as alterações em cada versão do provisionamento de frota da AWS IoT pelo plug-in de reivindicação (`aws.greengrass.FleetProvisioningByClaim`).
| Versão | Alterações |
| --- | --- |
| 1.2.2 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/greengrass/v2/developerguide/fleet-provisioning-changelog.html) |
| 1.2.1 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/greengrass/v2/developerguide/fleet-provisioning-changelog.html) |
| 1.2.0 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/greengrass/v2/developerguide/fleet-provisioning-changelog.html) |
| 1.1.0 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/greengrass/v2/developerguide/fleet-provisioning-changelog.html) |
| 1.0.0 | Versão inicial. |
# Instale o software AWS IoT Greengrass principal com provisionamento personalizado de recursos
Esse recurso está disponível para a versão 2.4.0 e posterior do [componente de Greengrass nucleus](greengrass-nucleus-component.md).
O instalador do software AWS IoT Greengrass Core fornece uma interface Java que você pode implementar em um plug-in personalizado que provisiona AWS os recursos necessários. Você pode desenvolver um plug-in de provisionamento para usar certificados de cliente X.509 personalizados ou para executar etapas complexas de provisionamento não compatíveis com outros processos de instalação. Para obter mais informações, consulte [Usar seus próprios certificados cliente](https://docs.aws.amazon.com/iot/latest/developerguide/device-certs-your-own.html) no *Guia do desenvolvedor do AWS IoT Core *.
Para executar um plug-in de provisionamento personalizado ao instalar o software AWS IoT Greengrass Core, você cria um arquivo JAR que fornece ao instalador. O instalador executa o plug-in, e o plug-in retorna uma configuração de provisionamento que define os AWS recursos para o dispositivo principal do Greengrass. O instalador usa essas informações para configurar o software AWS IoT Greengrass Core no dispositivo. Para obter mais informações, consulte [Desenvolver plug-ins de provisionamento personalizados](develop-custom-provisioning-plugins.md).
**Importante**
Antes de baixar o software AWS IoT Greengrass Core, verifique se seu dispositivo principal atende aos [requisitos](greengrass-nucleus-component.md#greengrass-v2-requirements) para instalar e executar o software AWS IoT Greengrass Core v2.0.
**Topics**
+ [Pré-requisitos](#custom-provisioning-prerequisites)
+ [Configurar o ambiente do dispositivo](#set-up-device-environment)
+ [Baixe o software AWS IoT Greengrass Core](#download-greengrass-core-v2)
+ [Instale o software AWS IoT Greengrass Core](#run-greengrass-core-v2-installer-custom)
+ [Desenvolver plug-ins de provisionamento personalizados](develop-custom-provisioning-plugins.md)
## Pré-requisitos
Para instalar o software AWS IoT Greengrass Core com provisionamento personalizado, você deve ter o seguinte:
+ Um arquivo JAR para um plug-in de provisionamento personalizado que implementa o `DeviceIdentityInterface`. O plug-in de provisionamento personalizado deve retornar valores para cada parâmetro de configuração do sistema e do núcleo. Caso contrário, forneça esses valores no arquivo de configuração durante a instalação. Para obter mais informações, consulte [Desenvolver plug-ins de provisionamento personalizados](develop-custom-provisioning-plugins.md).
## Configurar o ambiente do dispositivo
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
**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
**nota**
Esse recurso está disponível para a versão 2.5.0 e posterior do [componente de Greengrass nucleus](greengrass-nucleus-component.md).
**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.
## Baixe o software AWS IoT Greengrass Core
Você pode baixar a versão mais recente do software AWS IoT Greengrass Core no seguinte local:
+ [https://d2s8p88vqu9w66.cloudfront. net/releases/greengrass](https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip)-nucleus-latest.zip
**nota**
Você pode baixar uma versão específica do software AWS IoT Greengrass Core no seguinte local. *version*Substitua pela versão a ser baixada.
```
https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-version.zip
```
**Para baixar o software AWS IoT Greengrass Core**
1. Em seu 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. (Opcional) Para verificar a assinatura do software do Greengrass nucleus
**nota**
Esse atributo está disponível com o Greengrass nucleus versão 2.9.5 e posterior.
1. Use o comando a seguir para verificar a assinatura do artefato do Greengrass nucleus:
------
#### [ Linux or Unix ]
```
jarsigner -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
O nome do arquivo pode parecer diferente dependendo da versão do JDK que você instala. Substitua *`jdk17.0.6_10`* pela versão do JDK que você instalou.
```
"C:\\Program Files\\Amazon Corretto\\jdk17.0.6_10\\bin\\jarsigner.exe" -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
O nome do arquivo pode parecer diferente dependendo da versão do JDK que você instala. Substitua *`jdk17.0.6_10`* pela versão do JDK que você instalou.
```
'C:\\Program Files\\Amazon Corretto\\jdk17.0.6_10\\bin\\jarsigner.exe' -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
1. A invocação `jarsigner` produz uma saída que indica os resultados da verificação.
1. Se o arquivo zip do Greengrass nucleus estiver assinado, a saída conterá a seguinte declaração:
```
jar verified.
```
1. Se o arquivo zip do Greengrass nucleus não estiver assinado, a saída conterá a seguinte declaração:
```
jar is unsigned.
```
1. Se você forneceu a opção `-certs` do Jarsigner junto com as opções `-verify` e `-verbose`, a saída também incluirá informações detalhadas do certificado do assinante.
1. Descompacte o software AWS IoT Greengrass Core em uma pasta no seu dispositivo. *GreengrassInstaller*Substitua 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. (Opcional) Execute o comando a seguir para ver a versão do software AWS IoT Greengrass Core.
```
java -jar ./GreengrassInstaller/lib/Greengrass.jar --version
```
**Importante**
Se você instalar uma versão do núcleo do Greengrass anterior à v2.4.0, não remova essa pasta depois de instalar o software Core. AWS IoT Greengrass O software AWS IoT Greengrass Core usa os arquivos dessa pasta para ser executado.
Se você baixou a versão mais recente do software, instale a versão 2.4.0 ou posterior e poderá remover essa pasta depois de instalar o software AWS IoT Greengrass Core.
## Instale o software AWS IoT Greengrass Core
Execute o instalador com argumentos que especificam as seguintes ações:
+ Instale a partir de um arquivo de configuração parcial que especifica o uso do plug-in de provisionamento personalizado para provisionar recursos. AWS O software AWS IoT Greengrass Core usa um arquivo de configuração que especifica a configuração de cada componente do Greengrass no dispositivo. O instalador cria um arquivo de configuração completo a partir do arquivo de configuração parcial que você fornece e dos AWS recursos que o plug-in de aprovisionamento personalizado cria.
+ 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ê.
+ 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, você deve configurar o software AWS IoT Greengrass Core como um serviço do sistema.
Para mais informações sobre os argumentos que podem ser especificados, consulte [Argumentos de instalação](configure-installer.md).
**nota**
Se você estiver executando 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).
**Para instalar o software AWS IoT Greengrass Core (Linux)**
1. Verifique a versão do software AWS IoT Greengrass Core.
+ *GreengrassInstaller*Substitua pelo caminho para a pasta que contém o software.
```
java -jar ./GreengrassInstaller/lib/Greengrass.jar --version
```
1. Use um editor de texto para criar um arquivo de configuração chamado `config.yaml` para fornecer ao instalador.
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 GreengrassInstaller/config.yaml
```
Copie o conteúdo YAML a seguir para o arquivo.
```
---
system:
rootpath: "/greengrass/v2"
# The following values are optional. Return them from the provisioning plugin or set them here.
# certificateFilePath: ""
# privateKeyPath: ""
# rootCaPath: ""
# thingName: ""
services:
aws.greengrass.Nucleus:
version: "2.16.1"
configuration:
# The following values are optional. Return them from the provisioning plugin or set them here.
# awsRegion: ""
# iotRoleAlias: ""
# iotDataEndpoint: ""
# iotCredEndpoint: ""
com.example.CustomProvisioning:
configuration:
# You can specify configuration parameters to provide to your plugin.
# pluginParameter: ""
```
Faça o seguinte:
+ *2.16.1*Substitua pela versão do software AWS IoT Greengrass Core.
+ Substitua cada instância de `/greengrass/v2` pela pasta raiz do Greengrass.
+ (Opcional) Especifique os valores de configuração do sistema e do núcleo. Defina esses valores se seu plug-in de provisionamento não os fornecer.
+ (Opcional) Especifique os parâmetros de configuração a serem fornecidos ao seu plug-in de provisionamento.
**nota**
Neste arquivo de configuração, você pode personalizar outras opções de configuração, como as portas e o proxy de rede a serem usados, conforme mostrado no exemplo a seguir. Para mais informações, consulte [Configuração do núcleo do Greengrass](greengrass-nucleus-component.md#greengrass-nucleus-component-configuration).
```
---
system:
rootpath: "/greengrass/v2"
# The following values are optional. Return them from the provisioning plugin or set them here.
# certificateFilePath: ""
# privateKeyPath: ""
# rootCaPath: ""
# thingName: ""
services:
aws.greengrass.Nucleus:
version: "2.16.1"
configuration:
mqtt:
port: 443
greengrassDataPlanePort: 443
networkProxy:
noProxyAddresses: "http://192.168.0.1,www.example.com"
proxy:
url: "http://my-proxy-server:1100"
username: "Mary_Major"
password: "pass@word1357"
# The following values are optional. Return them from the provisioning plugin or set them here.
# awsRegion: ""
# iotRoleAlias: ""
# iotDataEndpoint: ""
# iotCredEndpoint: ""
com.example.CustomProvisioning:
configuration:
# You can specify configuration parameters to provide to your plugin.
# pluginParameter: ""
```
1. Execute o instalador. Especifique `--trusted-plugin` para fornecer seu plug-in de provisionamento personalizado e especifique `--init-config` para fornecer o arquivo de configuração.
**nota**
O Windows tem uma limitação de comprimento de caminho de 260 caracteres. Se você estiver usando o Windows, use uma pasta raiz como `C:\greengrass\v2` ou `D:\greengrass\v2` para manter os caminhos dos componentes do Greengrass abaixo do limite de 260 caracteres.
+ Substitua `/greengrass/v2` ou *C:\$1greengrass\$1v2* pela pasta raiz do Greengrass.
+ Substitua cada instância do *GreengrassInstaller* pela pasta em que você descompactou o instalador.
+ Substitua o caminho para o arquivo JAR do plug-in de provisionamento personalizado pelo caminho para o arquivo JAR do seu plug-in.
------
#### [ Linux or Unix ]
```
sudo -E java -Droot="/greengrass/v2" -Dlog.store=FILE \
-jar ./GreengrassInstaller/lib/Greengrass.jar \
--trusted-plugin /path/to/com.example.CustomProvisioning.jar \
--init-config ./GreengrassInstaller/config.yaml \
--component-default-user ggc_user:ggc_group \
--setup-system-service true
```
------
#### [ Windows Command Prompt (CMD) ]
```
java -Droot="C:\greengrass\v2" "-Dlog.store=FILE" ^
-jar ./GreengrassInstaller/lib/Greengrass.jar ^
--trusted-plugin /path/to/com.example.CustomProvisioning.jar ^
--init-config ./GreengrassInstaller/config.yaml ^
--component-default-user ggc_user ^
--setup-system-service true
```
------
#### [ PowerShell ]
```
java -Droot="C:\greengrass\v2" "-Dlog.store=FILE" `
-jar ./GreengrassInstaller/lib/Greengrass.jar `
--trusted-plugin /path/to/com.example.CustomProvisioning.jar `
--init-config ./GreengrassInstaller/config.yaml `
--component-default-user ggc_user `
--setup-system-service true
```
------
**Importante**
Nos dispositivos principais do Windows, você deve especificar `--setup-system-service true` a configuração do software AWS IoT Greengrass Core como um serviço do sistema.
Se você especificar `--setup-system-service true`, o instalador imprimirá `Successfully set up Nucleus as a system service` se ele configurou e executou o software como um serviço do sistema. Caso contrário, o instalador não emitirá nenhuma mensagem se instalar o software com êxito.
**nota**
Não é possível usar o argumento `deploy-dev-tools` para implantar ferramentas de desenvolvimento local ao executar o instalador sem o argumento `--provision true`. Para informações sobre a implantação da CLI do Greengrass diretamente no dispositivo, consulte [Interface de linha de comando do Greengrass](gg-cli.md).
1. Verifique a instalação visualizando os arquivos na pasta raiz.
------
#### [ Linux or Unix ]
```
ls /greengrass/v2
```
------
#### [ Windows Command Prompt (CMD) ]
```
dir C:\greengrass\v2
```
------
#### [ PowerShell ]
```
ls C:\greengrass\v2
```
------
Se a instalação for bem-sucedida, a pasta raiz conterá várias pastas, como `config`, `packages` e `logs`.
Se você instalou o software AWS IoT Greengrass Core como um serviço do sistema, o instalador executa o software para você. Caso contrário, será preciso executar o software manualmente. Para obter mais informações, consulte [Execute o software AWS IoT Greengrass Core](run-greengrass-core-v2.md).
Para obter mais informações sobre como configurar e usar o software AWS IoT Greengrass, consulte o seguinte:
+ [Configurar o software AWS IoT Greengrass principal](configure-greengrass-core-v2.md)
+ [Desenvolver componentes do AWS IoT Greengrass](develop-greengrass-components.md)
+ [Implemente AWS IoT Greengrass componentes em dispositivos](manage-deployments.md)
+ [Interface de linha de comando do Greengrass](gg-cli.md)
# Desenvolver plug-ins de provisionamento personalizados
Para desenvolver um plug-in de provisionamento personalizado, crie uma classe Java que implemente a interface `com.aws.greengrass.provisioning.DeviceIdentityInterface`. Você pode incluir o arquivo JAR do núcleo do Greengrass em seu projeto para acessar essa interface e as classes dela. Essa interface define um método que insere uma configuração de plug-in e gera uma configuração de provisionamento. A configuração de provisionamento define configurações para o sistema e o [componente do núcleo do Greengrass](greengrass-nucleus-component.md). O instalador do software AWS IoT Greengrass Core usa essa configuração de provisionamento para configurar o software AWS IoT Greengrass Core em um dispositivo.
Depois de desenvolver um plug-in de provisionamento personalizado, crie-o como um arquivo JAR que você pode fornecer ao instalador do software AWS IoT Greengrass Core para executar o plug-in durante a instalação. O instalador executa seu plug-in de provisionamento personalizado na mesma JVM que o instalador usa, para que você possa criar um JAR que contenha somente o código do plug-in.
**nota**
O [plug-in de provisionamento de frota da AWS IoT](fleet-provisioning.md) implementa o `DeviceIdentityInterface` para usar o provisionamento de frota durante a instalação. O plug-in de provisionamento de frota é de código aberto, então você pode explorar seu código-fonte para ver um exemplo de como usar a interface do plug-in de provisionamento. Para obter mais informações, consulte o [plug-in de provisionamento de AWS IoT frota](https://github.com/aws-greengrass/aws-greengrass-fleet-provisioning-by-claim) ativado. GitHub
**Topics**
+ [Requisitos](#custom-provisioning-plugin-requirements)
+ [Implemente a DeviceIdentityInterface interface](#implement-device-identity-interface)
## Requisitos
Para desenvolver um plug-in de provisionamento personalizado, você deve criar uma classe Java que atenda aos seguintes requisitos:
+ Usa o pacote `com.aws.greengrass` ou um pacote dentro do pacote `com.aws.greengrass`.
+ Tem um construtor sem argumentos.
+ Implementa a interface `DeviceIdentityInterface`. Para obter mais informações, consulte [Implemente a DeviceIdentityInterface interface](#implement-device-identity-interface).
## Implemente a DeviceIdentityInterface interface
Para usar a interface `com.aws.greengrass.provisioning.DeviceIdentityInterface` em seu plug-in personalizado, adicione o núcleo do Greengrass como uma dependência ao seu projeto.
**Para usar o DeviceIdentityInterface em um projeto de plug-in de provisionamento personalizado**
+ Você pode adicionar o arquivo JAR do núcleo do Greengrass como uma biblioteca ou adicionar o núcleo do Greengrass como uma dependência do Maven. Execute um destes procedimentos:
+ Para adicionar o arquivo JAR do núcleo do Greengrass como uma biblioteca, baixe o software AWS IoT Greengrass Core, que contém o JAR do núcleo do Greengrass. Você pode baixar a versão mais recente do software AWS IoT Greengrass Core no seguinte local:
+ [https://d2s8p88vqu9w66.cloudfront. net/releases/greengrass](https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip)-nucleus-latest.zip
Você pode encontrar o arquivo JAR do núcleo do Greengrass (`Greengrass.jar`) na pasta `lib` do arquivo ZIP. Adicione esse arquivo JAR ao seu projeto.
+ Para consumir o núcleo do Greengrass em um projeto Maven, adicione uma dependência do artefato `nucleus` no grupo `com.aws.greengrass`. Você também deve adicionar o repositório `greengrass-common`, porque o núcleo do Greengrass não está disponível no Repositório Central do Maven.
```
...
greengrass-common
greengrass common
https://d2jrmugq4soldf.cloudfront.net/snapshots
...
com.aws.greengrass
nucleus
2.5.0-SNAPSHOT
provided
```
### A DeviceIdentityInterface interface
A interface `com.aws.greengrass.provisioning.DeviceIdentityInterface` tem o seguinte formato.
**nota**
[Você também pode explorar essas classes no [pacote com.aws.greengrass.provisioning do código-fonte do núcleo Greengrass](https://github.com/aws-greengrass/aws-greengrass-nucleus/tree/main/src/main/java/com/aws/greengrass/provisioning) em.](https://github.com/aws-greengrass/aws-greengrass-nucleus) GitHub
```
public interface com.aws.greengrass.provisioning.DeviceIdentityInterface {
ProvisionConfiguration updateIdentityConfiguration(ProvisionContext context)
throws RetryableProvisioningException, InterruptedException;
// Return the name of the plugin.
String name();
}
com.aws.greengrass.provisioning.ProvisionConfiguration {
SystemConfiguration systemConfiguration;
NucleusConfiguration nucleusConfiguration
}
com.aws.greengrass.provisioning.ProvisionConfiguration.SystemConfiguration {
String certificateFilePath;
String privateKeyPath;
String rootCAPath;
String thingName;
}
com.aws.greengrass.provisioning.ProvisionConfiguration.NucleusConfiguration {
String awsRegion;
String iotCredentialsEndpoint;
String iotDataEndpoint;
String iotRoleAlias;
}
com.aws.greengrass.provisioning.ProvisioningContext {
Map parameterMap;
String provisioningPolicy; // The policy is always "PROVISION_IF_NOT_PROVISIONED".
}
com.aws.greengrass.provisioning.exceptions.RetryableProvisioningException {}
```
Cada valor de configuração no `SystemConfiguration` e `NucleusConfiguration` é necessário para instalar o software AWS IoT Greengrass Core, mas você pode retornar`null`. Se seu plug-in de provisionamento personalizado retornar `null` para qualquer valor de configuração, você deverá fornecer esse valor na configuração do sistema ou do núcleo ao criar o `config.yaml` arquivo a ser fornecido ao AWS IoT Greengrass instalador do software Core. Se seu plug-in de provisionamento personalizado retornar um valor não nulo para uma opção que você também define em `config.yaml`, o instalador substituirá o valor em `config.yaml` pelo valor retornado pelo plug-in.
# Argumentos de instalação
O software AWS IoT Greengrass Core inclui um instalador que configura o software e provisiona os recursos da AWS necessários para a execução do dispositivo principal do Greengrass. O instalador inclui os seguintes argumentos que podem ser especificados para configurar a instalação:
`-h`, `--help`
(Opcional) Mostra as informações de ajuda do instalador.
`--version`
(Opcional) Mostra a versão do software AWS IoT Greengrass Core.
`-Droot`
(Opcional) O caminho para a pasta a ser usada como raiz do software AWS IoT Greengrass Core.
Esse argumento define uma propriedade da JVM, portanto, você deve especificá-la antes de `-jar`, ao executar o instalador. Por exemplo, especifique `java -Droot="/greengrass/v2" -jar /path/to/Greengrass.jar`.
Padrão:
+ Linux: `~/.greengrass`
+ Windows: : `%USERPROFILE%/.greengrass`
`-ar`, `--aws-region`
A Região da AWS que o software AWS IoT Greengrass Core usa para recuperar ou criar os recursos da AWS necessários.
`-p`, `--provision`
(Opcional) É possível registrar esse dispositivo como um objeto da AWS IoT e provisionar os recursos da AWS que o dispositivo principal exige. Se você especificar `true`, o software AWS IoT Greengrass Core provisiona qualquer objeto da AWS IoT, (opcional) qualquer grupo de objetos da AWS IoT, um perfil do IAM e um alias de perfil da AWS IoT.
Padrão: `false`
`-tn`, `--thing-name`
(Opcional) O nome do objeto da AWS IoT que você registra como esse dispositivo principal. Se o objeto com o nome não existir na sua Conta da AWS, o software AWS IoT Greengrass Core o criará.
O nome do objeto não pode conter caracteres de dois pontos (`:`).
Especifique `--provision true` para aplicar esse argumento.
Padrão: `GreengrassV2IotThing_` mais um UUID aleatório.
`-tgn`, `--thing-group-name`
(Opcional) O nome do grupo de objetos da AWS IoT em que você adiciona o objeto da AWS IoT desse dispositivo principal. Se uma implantação tem como alvo esse grupo de coisas, esse dispositivo principal recebe essa implantação quando se conecta ao AWS IoT Greengrass. Se o grupo de coisas com esse nome não existir na sua Conta da AWS, o software de núcleo do AWS IoT Greengrass o criará.
O nome do grupo de objetos não pode conter caracteres de dois pontos (`:`).
Especifique `--provision true` para aplicar esse argumento.
`-tpn`, `--thing-policy-name`
Esse recurso está disponível para a versão 2.4.0 e posteriores do [componente de núcleo do Greengrass](greengrass-nucleus-component.md).
(Opcional) O nome da política de AWS IoT a ser anexada ao certificado de objeto da AWS IoT desse dispositivo principal. Se a política de AWS IoT com esse nome não existir na sua Conta da AWS, o software AWS IoT Greengrass Core a criará.
O software AWS IoT Greengrass Core cria uma política de AWS IoT permissiva por padrão. Você pode restringir essa política ou criar uma política personalizada na qual você restringe as permissões 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).
Especifique `--provision true` para aplicar esse argumento.
Padrão: `GreengrassV2IoTThingPolicy`
`-trn`, `--tes-role-name`
(Opcional) O nome do perfil do IAM a ser usado para adquirir credenciais da AWS que permitem que o dispositivo principal interaja com os serviços da AWS. Se o perfil com esse nome não existir na sua Conta da AWS, o software AWS IoT Greengrass Core o criará com a política de `GreengrassV2TokenExchangeRoleAccess`. Esse perfil não tem acesso aos buckets do S3 nos quais você hospeda artefatos de componentes. Portanto, adicione permissões aos buckets e objetos do S3 dos seus artefatos ao criar um componente. Para obter mais informações, consulte [Autorize os dispositivos principais a interagir com os serviços AWS](device-service-role.md).
Especifique `--provision true` para aplicar esse argumento.
Padrão: `GreengrassV2TokenExchangeRole`
`-tra`, `--tes-role-alias-name`
(Opcional) O nome do alias do perfil da AWS IoT que aponta para o perfil do IAM que fornece credenciais da AWS para esse dispositivo principal. Se o alias do perfil com esse nome não existir na Conta da AWS, o software AWS IoT Greengrass Core o criará e o apontará para o perfil do IAM especificado por você.
Especifique `--provision true` para aplicar esse argumento.
Padrão: `GreengrassV2TokenExchangeRoleAlias`
`-ss`, `--setup-system-service`
(Opcional) Você pode configurar o software AWS IoT Greengrass Core como um serviço do sistema que é executado quando esse dispositivo é inicializado. O nome do serviço do sistema é `greengrass`. Para obter mais informações, consulte [Configurar o Greengrass nucleus como um serviço do sistema](configure-greengrass-core-v2.md#configure-system-service).
Em sistemas operacionais Linux, esse argumento exige que o sistema init systemd esteja disponível no dispositivo.
Nos dispositivos principais do Windows, é preciso configurar o software AWS IoT Greengrass Core como um serviço do sistema.
Padrão: `false`
`-u`, `--component-default-user`
O nome ou ID do usuário que o software AWS IoT Greengrass Core usa para executar componentes. Por exemplo, é possível especificar **ggc\$1user**. Esse valor é necessário quando você executa o instalador nos sistemas operacionais Windows.
Como opção, você também pode especificar o grupo nos sistemas operacionais Linux. Especifique o usuário e o grupo separando-os por dois pontos. Por exemplo, **ggc\$1user:ggc\$1group**.
As seguintes considerações adicionais se aplicam aos sistemas operacionais Linux:
+ Se você executar como raiz, o usuário padrão do componente é o usuário definido no arquivo de configuração. Se o arquivo de configuração não definir um usuário, o padrão será `ggc_user:ggc_group`. Se `ggc_user` ou `ggc_group` não existirem, o software os cria.
+ Se você executar como um usuário não raiz, o software AWS IoT Greengrass Core usará esse usuário para executar componentes.
+ Caso um grupo não seja especificado, o software AWS IoT Greengrass Core usará o grupo primário do usuário do sistema.
Para obter mais informações, consulte [Configurar o usuário que executa os componentes](configure-greengrass-core-v2.md#configure-component-user).
`-d`, `--deploy-dev-tools`
(Opcional) Você pode baixar e implantar o componente da [CLI do Greengrass](greengrass-cli-component.md) nesse dispositivo principal. Você pode usar essa ferramenta para desenvolver e depurar componentes nesse dispositivo principal.
Recomendamos que você use este componente somente em ambientes de desenvolvimento, não em ambientes de produção. Este componente fornece acesso a informações e operações que você normalmente não precisará em um ambiente de produção. Siga o princípio do privilégio mínimo implantando este componente somente nos dispositivos principais em que você precisar dele.
Especifique `--provision true` para aplicar esse argumento.
Padrão: `false`
`-init`, `--init-config`
(Opcional) O caminho para o arquivo de configuração a ser usado para instalar o software AWS IoT Greengrass Core. Por exemplo, você pode usar essa opção para configurar novos dispositivos principais com uma configuração de núcleo específica.
O arquivo de configuração que você especifica se mescla com o arquivo de configuração existente no dispositivo principal. Isso inclui os componentes e as configurações dos componentes no dispositivo principal. Recomendamos que o arquivo de configuração liste somente as configurações que você está tentando alterar.
`-tp`, `--trusted-plugin`
(Opcional) O caminho para um arquivo JAR a ser carregado como um plug-in confiável. Use essa opção para fornecer arquivos JAR do plug-in de provisionamento, como para instalar com [provisionamento de frota](fleet-provisioning.md) ou [provisionamento personalizado](custom-provisioning.md), ou para instalar com a chave privada e o certificado em um [módulo de segurança de hardware](hardware-security.md).
`-s`, `--start`
(Opcional) Você pode iniciar o software AWS IoT Greengrass Core após a instalação e, opcionalmente, provisionar recursos.
Padrão: `true`
# Execute o software AWS IoT Greengrass Core
Depois de [instalar o software AWS IoT Greengrass Core](install-greengrass-core-v2.md), execute-o para conectar seu dispositivo AWS IoT Greengrass a.
Ao instalar o software AWS IoT Greengrass Core, você pode especificar se deseja instalá-lo como um serviço do sistema com o [systemd.](https://en.wikipedia.org/wiki/Systemd) Se você escolher essa opção, o instalador executará o software para você e o configurará para ser executado quando o dispositivo for inicializado.
**Importante**
Nos dispositivos principais do Windows, você deve configurar o software AWS IoT Greengrass Core como um serviço do sistema.
**Topics**
+ [Verifique se o software AWS IoT Greengrass Core funciona como um serviço do sistema](#check-system-service)
+ [Execute o software AWS IoT Greengrass principal como um serviço do sistema](#run-greengrass-core-system-service)
+ [Execute o software AWS IoT Greengrass Core sem um serviço de sistema](#run-greengrass-core-no-system-service)
## Verifique se o software AWS IoT Greengrass Core funciona como um serviço do sistema
Ao instalar o software AWS IoT Greengrass Core, você pode especificar o `--setup-system-service true` argumento para instalar o software AWS IoT Greengrass Core como um serviço do sistema. Os dispositivos Linux exigem que o sistema [systemd](https://en.wikipedia.org/wiki/Systemd) init configure o software AWS IoT Greengrass Core como um serviço do sistema. Se você usar essa opção, o instalador executará o software para você e o configurará para ser executado quando o dispositivo for inicializado. O instalador exibirá a seguinte mensagem se instalar com êxito o software AWS IoT Greengrass Core como um serviço do sistema.
```
Successfully set up Nucleus as a system service
```
Se você instalou anteriormente o software AWS IoT Greengrass Core e não tem a saída do instalador, você pode verificar se o software foi instalado como um serviço do sistema.
**Para verificar se o software AWS IoT Greengrass Core está instalado como um serviço do sistema**
+ Execute o comando a seguir para verificar o status do serviço de sistema do Greengrass.
------
#### [ Linux or Unix (systemd) ]
```
sudo systemctl status greengrass.service
```
A resposta será semelhante ao exemplo a seguir se o software AWS IoT Greengrass Core estiver instalado como um serviço do sistema e ativo.
```
● greengrass.service - Greengrass Core
Loaded: loaded (/etc/systemd/system/greengrass.service; enabled; vendor preset: disabled)
Active: active (running) since Thu 2021-02-11 01:33:44 UTC; 4 days ago
Main PID: 16107 (sh)
CGroup: /system.slice/greengrass.service
├─16107 /bin/sh /greengrass/v2/alts/current/distro/bin/loader
└─16111 java -Dlog.store=FILE -Droot=/greengrass/v2 -jar /greengrass/v2/alts/current/distro/lib/Greengrass...
```
Se `systemctl` ou `greengrass.service` não for encontrado, o software AWS IoT Greengrass Core não está instalado como um serviço do sistema. Para executar o software, consulte [Execute o software AWS IoT Greengrass Core sem um serviço de sistema](#run-greengrass-core-no-system-service).
------
#### [ Windows Command Prompt (CMD) ]
```
sc query greengrass
```
A resposta será semelhante ao exemplo a seguir se o software AWS IoT Greengrass Core estiver instalado como um serviço do Windows e ativo.
```
SERVICE_NAME: greengrass
TYPE : 10 WIN32_OWN_PROCESS
STATE : 4 RUNNING
(STOPPABLE, NOT_PAUSABLE, ACCEPTS_SHUTDOWN)
WIN32_EXIT_CODE : 0 (0x0)
SERVICE_EXIT_CODE : 0 (0x0)
CHECKPOINT : 0x0
WAIT_HINT : 0x0
```
------
#### [ PowerShell ]
```
Get-Service greengrass
```
A resposta será semelhante ao exemplo a seguir se o software AWS IoT Greengrass Core estiver instalado como um serviço do Windows e ativo.
```
Status Name DisplayName
------ ---- -----------
Running greengrass greengrass
```
------
## Execute o software AWS IoT Greengrass principal como um serviço do sistema
Se o software AWS IoT Greengrass Core estiver instalado como um serviço do sistema, você poderá usar o gerenciador de serviços do sistema para iniciar, parar e gerenciar o software. Para obter mais informações, consulte [Configurar o Greengrass nucleus como um serviço do sistema](configure-greengrass-core-v2.md#configure-system-service).
**Para executar o software AWS IoT Greengrass Core**
+ Execute o comando a seguir para iniciar o software AWS IoT Greengrass Core.
------
#### [ Linux or Unix (systemd) ]
```
sudo systemctl start greengrass.service
```
------
#### [ Windows Command Prompt (CMD) ]
```
sc start greengrass
```
------
#### [ PowerShell ]
```
Start-Service greengrass
```
------
## Execute o software AWS IoT Greengrass Core sem um serviço de sistema
Nos dispositivos principais do Linux, se o software AWS IoT Greengrass Core não estiver instalado como um serviço do sistema, você poderá executar o script do carregador do software para executar o software.
**Para executar o software AWS IoT Greengrass Core sem um serviço de sistema**
+ Execute o comando a seguir para iniciar o software AWS IoT Greengrass Core. Se você executar esse comando em um terminal, deverá manter a sessão do terminal aberta para manter o software AWS IoT Greengrass Core em execução.
+ Substitua `/greengrass/v2` ou *C:\$1greengrass\$1v2* pela pasta raiz do Greengrass que você usa.
```
sudo /greengrass/v2/alts/current/distro/bin/loader
```
O software imprime a seguinte mensagem se for iniciado com êxito.
```
Launched Nucleus successfully.
```
# Execute AWS IoT Greengrass o software Core em um contêiner Docker
AWS IoT Greengrass pode ser configurado para ser executado em um contêiner Docker. O Docker é uma plataforma que fornece as ferramentas para criar, executar, testar e implantar aplicações baseadas em contêineres do Linux. Ao executar uma imagem do AWS IoT Greengrass Docker, você pode escolher se deseja fornecer suas AWS credenciais ao contêiner do Docker e permitir que o instalador do software AWS IoT Greengrass Core provisione automaticamente os AWS recursos que um dispositivo principal do Greengrass requer para operar. Se você não quiser fornecer AWS credenciais, poderá provisionar AWS recursos manualmente e executar o software AWS IoT Greengrass Core no contêiner do Docker.
**Topics**
+ [Plataformas compatíveis e requisitos](#greengrass-docker-supported-platforms)
+ [Downloads de software:](#greengrass-docker-downloads)
+ [Escolha como provisionar AWS recursos](#greengrass-docker-resource-provisioning)
+ [Crie a AWS IoT Greengrass imagem a partir de um Dockerfile](build-greengrass-dockerfile.md)
+ [Execute AWS IoT Greengrass no Docker com provisionamento automático](run-greengrass-docker-automatic-provisioning.md)
+ [Execute AWS IoT Greengrass no Docker com provisionamento manual](run-greengrass-docker-manual-provisioning.md)
+ [Solução de problemas AWS IoT Greengrass em um contêiner Docker](docker-troubleshooting.md)
## Plataformas compatíveis e requisitos
Os computadores host devem atender aos seguintes requisitos mínimos para instalar e executar o software AWS IoT Greengrass Core em um contêiner Docker:
+ Sistema operacional baseado em Linux com conexão à Internet.
+ [Docker Engine](https://docs.docker.com/engine/install/), versão 18.09 ou posterior.
+ (Opcional) [Docker Compose](https://docs.docker.com/compose/install/) versão 1.22 ou posterior. O Docker Compose é necessário somente se você quiser usar a CLI do Docker Compose para executar suas imagens do Docker.
Para executar componentes da função do Lambda dentro do contêiner Docker, você deve configurar o contêiner para atender aos requisitos adicionais. Para obter mais informações, consulte [Requisitos da função do Lambda](setting-up.md#greengrass-v2-lambda-requirements).
### Execute componentes no modo de processo
AWS IoT Greengrass não suporta a execução de funções Lambda ou componentes AWS fornecidos pelo Lambda em um ambiente de tempo de execução isolado dentro do AWS IoT Greengrass contêiner Docker. Você deve executar esses componentes no modo de processo sem nenhum isolamento.
Ao configurar um componente da função do Lambda, defina o modo de isolamento como **Sem contêiner**. Para obter mais informações, consulte [Executar funções AWS Lambda.](run-lambda-functions.md).
Ao implantar qualquer um dos componentes AWS fornecidos a seguir, atualize a configuração de cada componente para definir o `containerMode` parâmetro como. `NoContainer` Para obter mais informações sobre atualizações de configuração, consulte [Atualizar configurações do componente](update-component-configurations.md).
+ [CloudWatch métricas](cloudwatch-metrics-component.md)
+ [Device Defender](device-defender-component.md)
+ [Firehose](kinesis-firehose-component.md)
+ [Adaptador de protocolo Modbus-RTU](modbus-rtu-protocol-adapter-component.md)
+ [Amazon SNS](sns-component.md)
## AWS IoT Greengrass Downloads do software Docker
AWS IoT Greengrass fornece um Dockerfile para criar uma imagem de contêiner que tenha o software AWS IoT Greengrass principal e as dependências instaladas em uma imagem base do Amazon Linux 2 (x86\$164). Você pode modificar a imagem base no Dockerfile para ser executada AWS IoT Greengrass em uma arquitetura de plataforma diferente.
Baixe o pacote Dockerfile em. [GitHub](https://github.com/aws-greengrass/aws-greengrass-docker)
O Dockerfile usa uma versão mais antiga do Greengrass. Você deve atualizar o arquivo para usar a versão do Greengrass que deseja. Para obter informações sobre como criar a imagem do AWS IoT Greengrass contêiner a partir do Dockerfile, consulte. [Crie a imagem do AWS IoT Greengrass contêiner a partir de um Dockerfile](build-greengrass-dockerfile.md)
## Escolha como provisionar AWS recursos
Ao instalar o software AWS IoT Greengrass Core em um contêiner Docker, você pode escolher se deseja provisionar automaticamente os AWS recursos que um dispositivo principal do Greengrass requer para operar ou usar os recursos que você provisiona manualmente.
+ **Provisionamento automático de recursos — o instalador provisiona** a AWS IoT AWS IoT coisa, o grupo de coisas, a função do IAM e o alias da AWS IoT função quando você executa a imagem do AWS IoT Greengrass contêiner pela primeira vez. O instalador também pode implantar as ferramentas de desenvolvimento local no dispositivo principal, para que você possa usar o dispositivo para desenvolver e testar componentes de software personalizados. Para provisionar automaticamente esses recursos, você deve fornecer credenciais da AWS como variáveis de ambiente para a imagem do Docker.
Para usar o provisionamento automático, você deve definir a variável de ambiente `PROVISION=true` do Docker e montar um arquivo de credencial para fornecer suas credenciais da AWS ao contêiner.
+ **Provisionamento manual de recursos** — se você não quiser fornecer AWS credenciais ao contêiner, poderá provisionar manualmente os AWS recursos antes de executar a imagem do contêiner. AWS IoT Greengrass Você deve criar um arquivo de configuração para fornecer informações sobre esses recursos ao instalador do software AWS IoT Greengrass Core dentro do contêiner Docker.
Para usar o provisionamento manual, você deve definir a variável de ambiente `PROVISION=false` do Docker. O aprovisionamento manual é a opção padrão.
Para obter mais informações, consulte [Crie a imagem do AWS IoT Greengrass contêiner a partir de um Dockerfile](build-greengrass-dockerfile.md).
# Crie a imagem do AWS IoT Greengrass contêiner a partir de um Dockerfile
AWS fornece um Dockerfile que você pode baixar e usar para executar o software AWS IoT Greengrass Core em um contêiner Docker. Os Dockerfiles contêm código-fonte para criar imagens de AWS IoT Greengrass contêineres.
Antes de criar uma imagem de AWS IoT Greengrass contêiner, você deve configurar seu Dockerfile para selecionar a versão do software AWS IoT Greengrass Core que você deseja instalar. Também é possível configurar variáveis de ambiente para escolher como provisionar recursos durante a instalação e personalizar outras opções de instalação. Esta seção descreve como configurar e criar uma imagem do AWS IoT Greengrass Docker a partir de um Dockerfile.
## Baixar o pacote do Dockerfile
Você pode baixar o pacote AWS IoT Greengrass Dockerfile em: GitHub
[Repositório Docker do AWS Greengrass](https://github.com/aws-greengrass/aws-greengrass-docker)
Depois de baixar o pacote, extraia o conteúdo para a pasta `download-directory/aws-greengrass-docker-nucleus-version` no seu computador. O Dockerfile usa uma versão mais antiga do Greengrass. Você deve atualizar o arquivo para usar a versão do Greengrass que deseja.
## Especifique a versão AWS IoT Greengrass do software principal
Use o seguinte argumento de compilação no Dockerfile para especificar a versão do software AWS IoT Greengrass Core que você deseja usar na imagem do AWS IoT Greengrass Docker. Por padrão, o Dockerfile usa a versão mais recente do software AWS IoT Greengrass Core.
`GREENGRASS_RELEASE_VERSION`
A versão do software AWS IoT Greengrass Core. Por padrão, o Dockerfile baixa a versão mais recente disponível do núcleo do Greengrass. Defina o valor para a versão do núcleo que deseja baixar.
## Definição de variáveis de ambiente
As variáveis de ambiente permitem que você personalize como o software AWS IoT Greengrass Core é instalado no contêiner Docker. Você pode definir variáveis de ambiente para sua imagem do AWS IoT Greengrass Docker de várias maneiras.
+ Para usar as mesmas variáveis de ambiente para criar várias imagens, defina as variáveis de ambiente diretamente no Dockerfile.
+ Se você usa `docker run` para iniciar o contêiner, passe variáveis de ambiente como argumentos no comando ou defina variáveis de ambiente em um arquivo de variáveis de ambiente e, em seguida, passe o arquivo como argumento. Para obter mais informações sobre como configurar variáveis de ambiente no Docker, consulte as [variáveis de ambiente](https://docs.docker.com/engine/reference/commandline/run/#env) na documentação do Docker.
+ Se você usa `docker-compose up` para iniciar o contêiner, defina variáveis de ambiente em um arquivo de variáveis de ambiente e, em seguida, passe o arquivo como argumento. Para obter mais informações sobre como configurar variáveis de ambiente no Compose, consulte a [documentação do Docker](https://docs.docker.com/compose/environment-variables/).
Você pode configurar as seguintes variáveis de ambiente para a imagem do AWS IoT Greengrass Docker.
**nota**
Não modifique a variável `TINI_KILL_PROCESS_GROUP` no Dockerfile. Essa variável permite o encaminhamento `SIGTERM` para todos PIDs no grupo PID para que o software AWS IoT Greengrass Core possa ser desligado corretamente quando o contêiner do Docker for interrompido.
`GGC_ROOT_PATH`
(Opcional) O caminho para a pasta dentro do contêiner a ser usada como raiz do software AWS IoT Greengrass Core.
Padrão: `/greengrass/v2`
`PROVISION`
(Opcional) Determina se o AWS IoT Greengrass Core provisiona AWS recursos.
+ Se você especificar`true`, o software AWS IoT Greengrass Core registra a imagem do contêiner como uma AWS IoT coisa e provisiona os AWS recursos que o dispositivo principal do Greengrass exige. O software AWS IoT Greengrass Core provisiona AWS IoT qualquer coisa, (opcional) qualquer grupo de AWS IoT coisas, uma função do IAM e um alias de AWS IoT função. Para obter mais informações, consulte [Execute AWS IoT Greengrass em um contêiner Docker com provisionamento automático de recursos](run-greengrass-docker-automatic-provisioning.md).
+ Se você especificar`false`, deverá criar um arquivo de configuração para fornecer ao instalador AWS IoT Greengrass principal que especifique o uso dos AWS recursos e certificados que você criou manualmente. Para obter mais informações, consulte [Execute AWS IoT Greengrass em um contêiner Docker com provisionamento manual de recursos](run-greengrass-docker-manual-provisioning.md).
Padrão: `false`
`AWS_REGION`
(Opcional) O Região da AWS que o software AWS IoT Greengrass Core usa para recuperar ou criar AWS os recursos necessários.
Padrão: `us-east-1`.
`THING_NAME`
(Opcional) O nome da AWS IoT coisa que você registra como esse dispositivo principal. Se a coisa com esse nome não existir no seu Conta da AWS, o software AWS IoT Greengrass Core a cria.
Especifique `PROVISION=true` para aplicar esse argumento.
Padrão: `GreengrassV2IotThing_` mais um UUID aleatório.
`THING_GROUP_NAME`
(Opcional) O nome do grupo ao AWS IoT qual você adiciona esse dispositivo principal é AWS IoT Se uma implantação for direcionada a esse grupo, esse e outros dispositivos principais desse grupo receberão essa implantação quando se conectarem AWS IoT Greengrass. Se o grupo de coisas com esse nome não existir no seu Conta da AWS, o software AWS IoT Greengrass Core o criará.
Especifique `PROVISION=true` para aplicar esse argumento.
`TES_ROLE_NAME`
(Opcional) O nome da função do IAM a ser usada para adquirir AWS credenciais que permitem que o dispositivo principal do Greengrass interaja com os AWS serviços. Se a função com esse nome não existir na sua Conta da AWS, o software AWS IoT Greengrass Core a criará com a `GreengrassV2TokenExchangeRoleAccess` política. Esse perfil não tem acesso aos buckets do S3 nos quais você hospeda artefatos de componentes. Portanto, adicione permissões aos buckets e objetos do S3 dos seus artefatos ao criar um componente. Para obter mais informações, consulte [Autorize os dispositivos principais a interagir com os serviços AWS](device-service-role.md).
Padrão: `GreengrassV2TokenExchangeRole`
`TES_ROLE_ALIAS_NAME`
(Opcional) O nome do alias da AWS IoT função que aponta para a função do IAM que fornece AWS credenciais para o dispositivo principal do Greengrass. Se o alias de função com esse nome não existir no seu Conta da AWS, o software AWS IoT Greengrass Core o criará e o direcionará para a função do IAM que você especificar.
Padrão: `GreengrassV2TokenExchangeRoleAlias`
`COMPONENT_DEFAULT_USER`
(Opcional) O nome ou ID do usuário e do grupo do sistema que o software AWS IoT Greengrass Core usa para executar componentes. Especifique o usuário e o grupo, separados por dois pontos. O grupo é opcional. Por exemplo, é possível especificar **ggc\$1user:ggc\$1group** ou **ggc\$1user**.
+ Se você executar como raiz, o padrão será o usuário e o grupo definidos pelo arquivo de configuração. Se o arquivo de configuração não definir um usuário e grupo, o padrão será `ggc_user:ggc_group`. Se `ggc_user` ou `ggc_group` não existirem, o software os criará.
+ Se você executa como usuário não root, o software AWS IoT Greengrass Core usa esse usuário para executar componentes.
+ Se você não especificar um grupo, o software AWS IoT Greengrass Core usa o grupo primário do usuário do sistema.
Para obter mais informações, consulte [Configurar o usuário que executa os componentes](configure-greengrass-core-v2.md#configure-component-user).
`DEPLOY_DEV_TOOLS`
Define se o [componente CLI do Greengrass](greengrass-cli-component.md) deve ser baixado e implantado na imagem do contêiner. É possível usar a CLI do Greengrass para desenvolver e depurar componentes localmente.
Recomendamos que você use este componente somente em ambientes de desenvolvimento, não em ambientes de produção. Este componente fornece acesso a informações e operações que você normalmente não precisará em um ambiente de produção. Siga o princípio do privilégio mínimo implantando este componente somente nos dispositivos principais em que você precisar dele.
Padrão: `false`
`INIT_CONFIG`
(Opcional) O caminho para o arquivo de configuração a ser usado para instalar o software AWS IoT Greengrass Core. Por exemplo, você pode usar essa opção para configurar novos dispositivos principais do Greengrass com uma configuração de núcleo específica ou para especificar recursos provisionados manualmente. Monte o arquivo de configuração no caminho especificado nesse argumento.
`TRUSTED_PLUGIN`
Este atributo está disponível para a versão 2.4.0 e posterior do [componente de núcleo do Greengrass](greengrass-nucleus-component.md).
(Opcional) O caminho para um arquivo JAR a ser carregado como um plug-in confiável. Use esta opção para fornecer arquivos JAR do plug-in de provisionamento, como para instalação com [provisionamento de frota](fleet-provisioning.md) ou [provisionamento personalizado](custom-provisioning.md).
`THING_POLICY_NAME`
Este atributo está disponível para a versão 2.4.0 e posterior do [componente de núcleo do Greengrass](greengrass-nucleus-component.md).
(Opcional) O nome da AWS IoT política a ser anexada ao certificado de AWS IoT coisas desse dispositivo principal. Se a AWS IoT política com esse nome não existir em sua, Conta da AWS o software AWS IoT Greengrass Core a criará.
Especifique `PROVISION=true` para aplicar esse argumento.
O software AWS IoT Greengrass Core cria uma AWS IoT política permissiva por padrão. Você pode restringir essa política ou criar uma política personalizada na qual você restringe as permissões 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).
## Especificar as dependências a serem instaladas
A instrução RUN no AWS IoT Greengrass Dockerfile prepara o ambiente do contêiner para executar o AWS IoT Greengrass instalador do software Core. É possível personalizar as dependências que são instaladas antes da execução do instalador do software de núcleo do AWS IoT Greengrass no contêiner do Docker.
## Crie a AWS IoT Greengrass imagem
Use o AWS IoT Greengrass Dockerfile para criar uma imagem de AWS IoT Greengrass contêiner. É possível usar a CLI do Docker ou a CLI do Docker Compose para criar a imagem e iniciar o contêiner. Também é possível usar a CLI do Docker para criar a imagem e, em seguida, usar o Docker Compose para iniciar o contêiner a partir dessa imagem.
------
#### [ Docker ]
1. Na máquina host, execute o comando a seguir para alternar para o diretório que contém o Dockerfile configurado.
```
cd download-directory/aws-greengrass-docker-nucleus-version
```
1. Execute o comando a seguir para criar a imagem do AWS IoT Greengrass contêiner a partir do Dockerfile.
```
sudo docker build -t "platform/aws-iot-greengrass:nucleus-version" ./
```
------
#### [ Docker Compose ]
1. Na máquina host, execute o comando a seguir para alternar para o diretório que contém o Dockerfile e o arquivo do Compose.
```
cd download-directory/aws-greengrass-docker-nucleus-version
```
1. Execute o comando a seguir para usar o arquivo Compose para criar a imagem do AWS IoT Greengrass contêiner.
```
docker-compose -f docker-compose.yml build
```
------
Você criou com sucesso a imagem do AWS IoT Greengrass contêiner. A imagem do Docker tem o software AWS IoT Greengrass Core instalado. Agora você pode executar o software AWS IoT Greengrass Core em um contêiner Docker.
# Execute AWS IoT Greengrass em um contêiner Docker com provisionamento automático de recursos
Este tutorial mostra como instalar e executar o software AWS IoT Greengrass Core em um contêiner Docker com AWS recursos provisionados automaticamente e ferramentas de desenvolvimento local. Você pode usar esse ambiente de desenvolvimento para explorar os AWS IoT Greengrass recursos em um contêiner do Docker. O software requer credenciais da AWS para provisionar esses recursos e implantar as ferramentas de desenvolvimento local.
Se você não puder fornecer AWS credenciais para o contêiner, poderá provisionar os AWS recursos que o dispositivo principal precisa para operar. Também é possível implantar as ferramentas de desenvolvimento em um dispositivo principal para usar como dispositivo de desenvolvimento. Isso permite que você forneça menos permissões ao dispositivo ao executar o contêiner. Para obter mais informações, consulte [Execute AWS IoT Greengrass em um contêiner Docker com provisionamento manual de recursos](run-greengrass-docker-manual-provisioning.md).
## Pré-requisitos
Para concluir este tutorial, você precisará do seguinte:
+ Um Conta da AWS. Se você não tiver uma, consulte [Configurar um Conta da AWS](setting-up.md#set-up-aws-account).
+ Um usuário AWS do IAM com permissões para provisionar os recursos do IAM AWS IoT e do IAM para um dispositivo principal do Greengrass. O instalador do software AWS IoT Greengrass Core usa suas AWS credenciais para provisionar automaticamente esses recursos. Para obter informações sobre a política mínima do IAM para provisionar recursos automaticamente, consulte [Política mínima de IAM para o instalador provisionar recursos](provision-minimal-iam-policy.md).
+ Uma imagem AWS IoT Greengrass do Docker. Você pode [criar uma imagem a partir do AWS IoT Greengrass Dockerfile](build-greengrass-dockerfile.md).
+ O computador host em que você executa o contêiner do Docker deve atender aos seguintes requisitos:
+ Sistema operacional baseado em Linux com conexão à Internet.
+ [Docker Engine](https://docs.docker.com/engine/install/), versão 18.09 ou posterior.
+ (Opcional) [Docker Compose](https://docs.docker.com/compose/install/) versão 1.22 ou posterior. O Docker Compose é necessário somente se você quiser usar a CLI do Docker Compose para executar suas imagens do Docker.
## Configure suas AWS credenciais
Nesta etapa, você cria um arquivo de credencial no computador host que contém suas credenciais de segurança da AWS . Ao executar a imagem do AWS IoT Greengrass Docker, você deve montar a pasta que contém esse arquivo de credencial `/root/.aws/` no contêiner do Docker. O AWS IoT Greengrass instalador usa essas credenciais para provisionar recursos no seu Conta da AWS. Para obter informações sobre a política mínima do IAM que o instalador exige para provisionar recursos automaticamente, consulte [Política mínima de IAM para o instalador provisionar recursos](provision-minimal-iam-policy.md).
1. Recupere um dos seguintes.
+ Credenciais de longo prazo para um usuário do IAM. Para obter informações sobre como recuperar credenciais de longo prazo, consulte [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*.
+ (Recomendado) Credenciais temporárias para uma função do IAM. Para obter informações sobre como recuperar credenciais temporárias, consulte [Usar credenciais temporárias com a AWS CLI](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html#using-temp-creds-sdk-cli) no *Guia do usuário do IAM*.
1. Crie uma pasta onde você coloca seu arquivo de credencial.
```
mkdir ./greengrass-v2-credentials
```
1. Utilize um editor de texto para criar um arquivo de configuração com o nome `credentials` na pasta `./greengrass-v2-credentials`.
Por exemplo, você pode executar o seguinte comando para usar o GNU nano para criar o arquivo `credentials`.
```
nano ./greengrass-v2-credentials/credentials
```
1. Adicione suas AWS credenciais ao `credentials` arquivo no formato a seguir.
```
[default]
aws_access_key_id = AKIAIOSFODNN7EXAMPLE
aws_secret_access_key = wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
aws_session_token = AQoEXAMPLEH4aoAH0gNCAPy...truncated...zrkuWJOgQs8IZZaIv2BXIa2R4Olgk
```
Inclua `aws_session_token` somente para credenciais temporárias.
**Importante**
Remova o arquivo de credencial do computador host depois de iniciar o AWS IoT Greengrass contêiner. Se você não remover o arquivo de credenciais, suas AWS credenciais permanecerão montadas dentro do contêiner. Para obter mais informações, consulte [Execute o software AWS IoT Greengrass principal em um contêiner](#run-greengrass-image-automatic-provisioning).
## Criar um arquivo de ambiente
Este tutorial usa um arquivo de ambiente para definir as variáveis de ambiente que serão passadas para o instalador do software AWS IoT Greengrass Core dentro do contêiner Docker. Você também pode usar [o argumento `-e` ou `--env`](https://docs.docker.com/engine/reference/commandline/run/#env) em seu comando `docker run` para definir variáveis de ambiente no contêiner do Docker ou definir as variáveis em [um bloco `environment`](https://docs.docker.com/compose/compose-file/compose-file-v3/#environment) no arquivo `docker-compose.yml`.
1. Use um editor de texto para criar um arquivo de ambiente chamado `.env`.
Por exemplo, em um sistema baseado em Linux, você pode executar o comando a seguir para usar o GNU nano para criar o `.env` no diretório atual.
```
nano .env
```
1. Copie o conteúdo a seguir para o arquivo.
```
GGC_ROOT_PATH=/greengrass/v2
AWS_REGION=region
PROVISION=true
THING_NAME=MyGreengrassCore
THING_GROUP_NAME=MyGreengrassCoreGroup
TES_ROLE_NAME=GreengrassV2TokenExchangeRole
TES_ROLE_ALIAS_NAME=GreengrassCoreTokenExchangeRoleAlias
COMPONENT_DEFAULT_USER=ggc_user:ggc_group
```
Em seguida, substitua os valores a seguir:
+ `/greengrass/v2`. A pasta raiz do Greengrass que você deseja usar para instalação. Use a variável de ambiente `GGC_ROOT` para definir esse valor.
+ *region*. O Região da AWS local em que você criou os recursos.
+ *MyGreengrassCore*. O nome da AWS IoT coisa. Se o objeto não existir, o instalador o cria. O instalador baixa os certificados para autenticar a AWS IoT coisa.
+ *MyGreengrassCoreGroup*. O nome do grupo de AWS IoT coisas. 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.
+ *GreengrassV2TokenExchangeRole*. Substitua pelo nome da função de troca de tokens do IAM que permite que o dispositivo principal do Greengrass obtenha credenciais temporárias AWS . Se a função não existir, o instalador a cria, cria e anexa uma política chamada *GreengrassV2TokenExchangeRole* Access. Para obter mais informações, consulte [Autorize os dispositivos principais a interagir com os serviços AWS](device-service-role.md).
+ *GreengrassCoreTokenExchangeRoleAlias*. O alias da função de troca de tokens. Se o alias da função não existir, o instalador o cria e o direciona para a função de troca de tokens do IAM que você especifica. Para obter mais informações, consulte .
**nota**
É possível definir a variável de ambiente `DEPLOY_DEV_TOOLS` para `true` a fim de implantar o [componente CLI do Greengrass](greengrass-cli-component.md), que permite desenvolver componentes personalizados dentro do contêiner do Docker. Recomendamos que você use este componente somente em ambientes de desenvolvimento, não em ambientes de produção. Este componente fornece acesso a informações e operações que você normalmente não precisará em um ambiente de produção. Siga o princípio do privilégio mínimo implantando este componente somente nos dispositivos principais em que você precisar dele.
## Execute o software AWS IoT Greengrass principal em um contêiner
Este tutorial mostra como iniciar a imagem do Docker que você criou em um contêiner do Docker. Você pode usar a CLI do Docker ou a CLI do Docker Compose para AWS IoT Greengrass executar a imagem do software Core em um contêiner do Docker.
------
#### [ Docker ]
1. Execute o comando a seguir para iniciar o contêiner do Docker.
```
docker run --rm --init -it --name docker-image \
-v path/to/greengrass-v2-credentials:/root/.aws/:ro \
--env-file .env \
-p 8883 \
your-container-image:version
```
Esse exemplo de comando usa os seguintes argumentos para [docker run](https://docs.docker.com/engine/reference/commandline/run/):
+ [https://docs.docker.com/engine/reference/run/#clean-up---rm](https://docs.docker.com/engine/reference/run/#clean-up---rm). Limpa o contêiner quando ele sair.
+ [https://docs.docker.com/engine/reference/run/#specify-an-init-process](https://docs.docker.com/engine/reference/run/#specify-an-init-process). Usa um processo de inicialização no contêiner.
**nota**
O `--init` argumento é necessário para desligar o software AWS IoT Greengrass Core quando você interrompe o contêiner Docker.
+ [https://docs.docker.com/engine/reference/run/#foreground](https://docs.docker.com/engine/reference/run/#foreground). (Opcional) Executa o contêiner do Docker em primeiro plano como um processo interativo. Em vez disso, você pode substituir isso pelo argumento `-d` para executar o contêiner do Docker no modo desanexado. Para obter mais informações, consulte [Detached vs foreground](https://docs.docker.com/engine/reference/run/#detached-vs-foreground) na documentação do Docker.
+ [https://docs.docker.com/engine/reference/run/#name---name](https://docs.docker.com/engine/reference/run/#name---name). Executa um contêiner chamado `aws-iot-greengrass`
+ [https://docs.docker.com/storage/volumes/](https://docs.docker.com/storage/volumes/). Monta um volume no contêiner do Docker para disponibilizar o arquivo de configuração e os arquivos de certificado para AWS IoT Greengrass execução dentro do contêiner.
+ [https://docs.docker.com/engine/reference/commandline/run/#env](https://docs.docker.com/engine/reference/commandline/run/#env). (Opcional) Especifica o arquivo de ambiente para definir as variáveis de ambiente que serão passadas para o instalador do software AWS IoT Greengrass Core dentro do contêiner Docker. Esse argumento é necessário somente se você criou um [arquivo de ambiente](run-greengrass-docker-manual-provisioning.md#create-env-file-manual-provisioning) para definir variáveis de ambiente. Se você não criou um arquivo de ambiente, pode usar argumentos `--env` para definir variáveis de ambiente diretamente no comando de execução do Docker.
+ [https://docs.docker.com/engine/reference/commandline/run/#publish](https://docs.docker.com/engine/reference/commandline/run/#publish). (Opcional) Publica a porta 8883 do contêiner na máquina host. Esse argumento é necessário se você quiser se conectar e se comunicar pelo MQTT porque o AWS IoT Greengrass usa a porta 8883 para tráfego MQTT. Para abrir outras portas, use argumentos `-p` adicionais.
**nota**
Para executar seu contêiner do Docker com maior segurança, você pode usar os argumentos `--cap-drop` e `--cap-add` para habilitar seletivamente os recursos do Linux para seu contêiner. Para obter mais informações, consulte [Runtime privilege and Linux capabilities](https://docs.docker.com/engine/reference/run/#runtime-privilege-and-linux-capabilities) no site de documentação do Docker.
1. Remova as credenciais `./greengrass-v2-credentials` do dispositivo host.
```
rm -rf ./greengrass-v2-credentials
```
**Importante**
Você está removendo essas credenciais porque elas fornecem amplas permissões que o dispositivo principal precisa somente durante a configuração. Se você não remover essas credenciais, os componentes do Greengrass e outros processos em execução no contêiner poderão acessá-las. Se você precisar fornecer AWS credenciais para um componente do Greengrass, use o serviço de troca de tokens. Para obter mais informações, consulte [Interaja com AWS os serviços](interact-with-aws-services.md).
------
#### [ Docker Compose ]
1. Use um editor de texto para criar um arquivo Compose do Docker chamado `docker-compose.yml`.
Por exemplo, em um sistema baseado em Linux, você pode executar o comando a seguir para usar o GNU nano para criar o `docker-compose.yml` no diretório atual.
```
nano docker-compose.yml
```
**nota**
Você também pode baixar e usar a versão mais recente do arquivo Compose AWS fornecido em. [GitHub](https://github.com/aws-greengrass/aws-greengrass-docker/releases/)
1. Adicione o conteúdo a seguir ao arquivo do Compose. O arquivo deve ser semelhante ao exemplo a seguir. *docker-image*Substitua pelo nome da sua imagem do Docker.
```
version: '3.7'
services:
greengrass:
init: true
container_name: aws-iot-greengrass
image: docker-image
volumes:
- ./greengrass-v2-credentials:/root/.aws/:ro
env_file: .env
ports:
- "8883:8883"
```
Neste exemplo, os seguintes parâmetros no arquivo do Compose são opcionais:
+ `ports`: publica a porta 8883 do contêiner na máquina host. Esse parâmetro é necessário se você quiser se conectar e se comunicar pelo MQTT porque AWS IoT Greengrass usa a porta 8883 para tráfego MQTT.
+ `env_file`—Especifica o arquivo de ambiente para definir as variáveis de ambiente que serão passadas para o instalador do software AWS IoT Greengrass Core dentro do contêiner Docker. Esse parâmetro é necessário somente se você criou um [arquivo de ambiente](run-greengrass-docker-manual-provisioning.md#create-env-file-manual-provisioning) para definir variáveis de ambiente. Se você não criou um arquivo de ambiente, pode usar o parâmetro [environment](https://docs.docker.com/compose/compose-file/compose-file-v3/#environment) para definir variáveis de ambiente diretamente em seu arquivo Compose.
**nota**
Para executar seu contêiner do Docker com maior segurança, você pode usar os argumentos `cap_drop` e `cap_add` em seu arquivo do Compose para habilitar seletivamente os recursos do Linux para seu contêiner. Para obter mais informações, consulte [Runtime privilege and Linux capabilities](https://docs.docker.com/engine/reference/run/#runtime-privilege-and-linux-capabilities) no site de documentação do Docker.
1. Execute o comando a seguir para iniciar o contêiner do Docker.
```
docker-compose -f docker-compose.yml up
```
1. Remova as credenciais `./greengrass-v2-credentials` do dispositivo host.
```
rm -rf ./greengrass-v2-credentials
```
**Importante**
Você está removendo essas credenciais porque elas fornecem amplas permissões que o dispositivo principal precisa somente durante a configuração. Se você não remover essas credenciais, os componentes do Greengrass e outros processos em execução no contêiner poderão acessá-las. Se você precisar fornecer AWS credenciais para um componente do Greengrass, use o serviço de troca de tokens. Para obter mais informações, consulte [Interaja com AWS os serviços](interact-with-aws-services.md).
------
## Próximas etapas
AWS IoT Greengrass O software principal agora está sendo executado em um contêiner Docker. Execute o comando a seguir para recuperar o ID do contêiner em execução no momento.
```
docker ps
```
Em seguida, você pode executar o comando a seguir para acessar o contêiner e explorar o software AWS IoT Greengrass principal executado dentro do contêiner.
```
docker exec -it container-id /bin/bash
```
Para obter mais informações sobre a criação de um componente simples, consulte [Etapa 4: desenvolver e testar um componente no dispositivo](create-first-component.md) em [Tutorial: Conceitos básicos do AWS IoT Greengrass V2](getting-started.md).
**nota**
Quando você usa `docker exec` para executar comandos dentro do contêiner do Docker, esses comandos não são registrados nos logs do Docker. Para registrar os comandos nos logs do Docker, anexe um shell interativo ao contêiner do Docker. Para obter mais informações, consulte [Anexar um shell interativo ao contêiner do Docker](docker-troubleshooting.md#debugging-docker-attach-shell).
O arquivo de log AWS IoT Greengrass principal é chamado `greengrass.log` e está localizado em`/greengrass/v2/logs`. Os arquivos de log do componente também estão localizados no mesmo diretório. Para copiar logs do Greengrass para um diretório temporário no host, execute o seguinte comando:
```
docker cp container-id:/greengrass/v2/logs /tmp/logs
```
Se você quiser manter os logs após a saída ou remoção de um contêiner, recomendamos que você vincule e monte somente o diretório `/greengrass/v2/logs` no diretório de logs temporários no host, em vez de montar todo o diretório Greengrass. Para obter mais informações, consulte [Manter os logs do Greengrass fora do contêiner do Docker](docker-troubleshooting.md#debugging-docker-persist-logs).
Para interromper a execução de um contêiner AWS IoT Greengrass Docker, execute `docker stop` ou`docker-compose -f docker-compose.yml stop`. Essa ação envia `SIGTERM` para o processo do Greengrass e encerra todos os processos associados que foram iniciados no contêiner. O contêiner do Docker é inicializado com o `docker-init` executável como processo PID 1, o que ajuda a eliminar quaisquer processos zumbis restantes. Para obter mais informações, consulte [Specify an init process](https://docs.docker.com/engine/reference/run/#specify-an-init-process) na documentação do Docker.
Para obter informações sobre como solucionar problemas com a execução do AWS IoT Greengrass em um contêiner do Docker, consulte [Solução de problemas AWS IoT Greengrass em um contêiner Docker](docker-troubleshooting.md).
# Execute AWS IoT Greengrass em um contêiner Docker com provisionamento manual de recursos
Este tutorial mostra como instalar e executar o software AWS IoT Greengrass Core no contêiner Docker com recursos provisionados AWS manualmente.
**Topics**
+ [Pré-requisitos](#docker-manual-provisioning-prereqs)
+ [Recupere endpoints AWS IoT](#retrieve-iot-endpoints)
+ [Crie qualquer AWS IoT coisa](#create-iot-thing)
+ [Criar o certificado do objeto](#create-thing-certificate-mp)
+ [Criar um perfil de troca de token](#create-token-exchange-role)
+ [Baixar certificados para o dispositivo](#download-thing-certificates)
+ [Criar um arquivo de configuração](#create-docker-install-configuration-file)
+ [Criar um arquivo de ambiente](#create-env-file-manual-provisioning)
+ [Execute o software AWS IoT Greengrass principal em um contêiner](#run-greengrass-image-manual-provisioning)
+ [Próximas etapas](#run-greengrass-docker-next-steps)
## Pré-requisitos
Para concluir este tutorial, você precisará do seguinte:
+ Um Conta da AWS. Se você não tiver uma, consulte [Configurar um Conta da AWS](setting-up.md#set-up-aws-account).
+ Uma imagem AWS IoT Greengrass do Docker. Você pode [criar uma imagem a partir do AWS IoT Greengrass Dockerfile](build-greengrass-dockerfile.md).
+ O computador host em que você executa o contêiner do Docker deve atender aos seguintes requisitos:
+ Sistema operacional baseado em Linux com conexão à Internet.
+ [Docker Engine](https://docs.docker.com/engine/install/), versão 18.09 ou posterior.
+ (Opcional) [Docker Compose](https://docs.docker.com/compose/install/) versão 1.22 ou posterior. O Docker Compose é necessário somente se você quiser usar a CLI do Docker Compose para executar suas imagens do Docker.
## Recupere endpoints AWS IoT
Obtenha os AWS IoT endpoints para você Conta da AWS e salve-os para usar mais tarde. Seu dispositivo usa esses endpoints para se conectar à AWS IoT. Faça o seguinte:
1. Obtenha o endpoint de AWS IoT dados para você Conta da AWS.
```
aws iot describe-endpoint --endpoint-type iot:Data-ATS
```
Se a solicitação for bem-sucedida, a resposta será semelhante ao exemplo a seguir.
```
{
"endpointAddress": "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
}
```
1. Obtenha o endpoint AWS IoT de credenciais para seu. Conta da AWS
```
aws iot describe-endpoint --endpoint-type iot:CredentialProvider
```
Se a solicitação for bem-sucedida, a resposta será semelhante ao exemplo a seguir.
```
{
"endpointAddress": "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
}
```
## Crie qualquer AWS IoT coisa
AWS IoT *as coisas* representam dispositivos e entidades lógicas que se conectam AWS IoT a. Os principais dispositivos do Greengrass são AWS IoT coisas. Quando você registra um dispositivo como uma AWS IoT coisa, esse dispositivo pode usar um certificado digital para se autenticar AWS.
Nesta seção, você cria AWS IoT algo que representa seu dispositivo.
**Para criar qualquer AWS IoT coisa**
1. Crie qualquer AWS IoT coisa para o seu dispositivo. Execute o comando a seguir no computador de desenvolvimento.
+ *MyGreengrassCore*Substitua pelo nome da coisa a ser usada. Esse nome também é o nome do dispositivo principal do Greengrass.
**nota**
O nome do objeto não pode conter caracteres de dois pontos (`:`).
```
aws iot create-thing --thing-name MyGreengrassCore
```
Se a solicitação for bem-sucedida, a resposta será semelhante ao exemplo a seguir.
```
{
"thingName": "MyGreengrassCore",
"thingArn": "arn:aws:iot:us-west-2:123456789012:thing/MyGreengrassCore",
"thingId": "8cb4b6cd-268e-495d-b5b9-1713d71dbf42"
}
```
1. (Opcional) Adicione a AWS IoT coisa a um grupo de coisas novo ou existente. Use grupos de objetos para gerenciar frotas de dispositivos principais do Greengrass. Ao implantar componentes de software nos dispositivos, é possível segmentar dispositivos individuais ou grupos de dispositivos. É possível adicionar um dispositivo a um grupo de objetos com uma implantação ativa do Greengrass para implantar os componentes de software desse grupo de objetos no dispositivo. Faça o seguinte:
1. (Opcional) Crie um grupo de AWS IoT coisas.
+ *MyGreengrassCoreGroup*Substitua pelo nome do grupo de coisas a ser criado.
**nota**
O nome do grupo de objetos não pode conter caracteres de dois pontos (`:`).
```
aws iot create-thing-group --thing-group-name MyGreengrassCoreGroup
```
Se a solicitação for bem-sucedida, a resposta será semelhante ao exemplo a seguir.
```
{
"thingGroupName": "MyGreengrassCoreGroup",
"thingGroupArn": "arn:aws:iot:us-west-2:123456789012:thinggroup/MyGreengrassCoreGroup",
"thingGroupId": "4df721e1-ff9f-4f97-92dd-02db4e3f03aa"
}
```
1. Adicione a AWS IoT coisa a um grupo de coisas.
+ *MyGreengrassCore*Substitua pelo nome da sua AWS IoT coisa.
+ *MyGreengrassCoreGroup*Substitua pelo nome do grupo de coisas.
```
aws iot add-thing-to-thing-group --thing-name MyGreengrassCore --thing-group-name MyGreengrassCoreGroup
```
O comando não terá nenhuma saída se a solicitação for bem-sucedida.
## Criar o certificado do objeto
Quando você registra um dispositivo como uma AWS IoT coisa, esse dispositivo pode usar um certificado digital para se autenticar AWS. Esse certificado permite que o dispositivo se comunique com AWS IoT AWS IoT Greengrass e.
Nesta seção, você cria e baixa certificados que o dispositivo pode usar para se conectar com a AWS.
**Para criar o certificado do objeto**
1. Crie uma pasta na qual você baixa os certificados da AWS IoT coisa.
```
mkdir greengrass-v2-certs
```
1. Crie e baixe os certificados da AWS IoT coisa.
```
aws iot create-keys-and-certificate --set-as-active --certificate-pem-outfile greengrass-v2-certs/device.pem.crt --public-key-outfile greengrass-v2-certs/public.pem.key --private-key-outfile greengrass-v2-certs/private.pem.key
```
Se a solicitação for bem-sucedida, a resposta será semelhante ao exemplo a seguir.
```
{
"certificateArn": "arn:aws:iot:us-west-2:123456789012:cert/aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4",
"certificateId": "aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4",
"certificatePem": "-----BEGIN CERTIFICATE-----
MIICiTCCAfICCQD6m7oRw0uXOjANBgkqhkiG9w
0BAQUFADCBiDELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAldBMRAwDgYDVQQHEwdTZ
WF0dGxlMQ8wDQYDVQQKEwZBbWF6b24xFDASBgNVBAsTC0lBTSBDb25zb2xlMRIw
EAYDVQQDEwlUZXN0Q2lsYWMxHzAdBgkqhkiG9w0BCQEWEG5vb25lQGFtYXpvbi5
jb20wHhcNMTEwNDI1MjA0NTIxWhcNMTIwNDI0MjA0NTIxWjCBiDELMAkGA1UEBh
MCVVMxCzAJBgNVBAgTAldBMRAwDgYDVQQHEwdTZWF0dGxlMQ8wDQYDVQQKEwZBb
WF6b24xFDASBgNVBAsTC0lBTSBDb25zb2xlMRIwEAYDVQQDEwlUZXN0Q2lsYWMx
HzAdBgkqhkiG9w0BCQEWEG5vb25lQGFtYXpvbi5jb20wgZ8wDQYJKoZIhvcNAQE
BBQADgY0AMIGJAoGBAMaK0dn+a4GmWIWJ21uUSfwfEvySWtC2XADZ4nB+BLYgVI
k60CpiwsZ3G93vUEIO3IyNoH/f0wYK8m9TrDHudUZg3qX4waLG5M43q7Wgc/MbQ
ITxOUSQv7c7ugFFDzQGBzZswY6786m86gpEIbb3OhjZnzcvQAaRHhdlQWIMm2nr
AgMBAAEwDQYJKoZIhvcNAQEFBQADgYEAtCu4nUhVVxYUntneD9+h8Mg9q6q+auN
KyExzyLwaxlAoo7TJHidbtS4J5iNmZgXL0FkbFFBjvSfpJIlJ00zbhNYS5f6Guo
EDmFJl0ZxBHjJnyp378OD8uTs7fLvjx79LjSTbNYiytVbZPQUQ5Yaxu2jXnimvw
3rrszlaEXAMPLE=
-----END CERTIFICATE-----",
"keyPair": {
"PublicKey": "-----BEGIN PUBLIC KEY-----\
MIIBIjANBgkqhkEXAMPLEQEFAAOCAQ8AMIIBCgKCAQEAEXAMPLE1nnyJwKSMHw4h\
MMEXAMPLEuuN/dMAS3fyce8DW/4+EXAMPLEyjmoF/YVF/gHr99VEEXAMPLE5VF13\
59VK7cEXAMPLE67GK+y+jikqXOgHh/xJTwo+sGpWEXAMPLEDz18xOd2ka4tCzuWEXAMPLEahJbYkCPUBSU8opVkR7qkEXAMPLE1DR6sx2HocliOOLtu6Fkw91swQWEXAMPLE\\GB3ZPrNh0PzQYvjUStZeccyNCx2EXAMPLEvp9mQOUXP6plfgxwKRX2fEXAMPLEDa\
hJLXkX3rHU2xbxJSq7D+XEXAMPLEcw+LyFhI5mgFRl88eGdsAEXAMPLElnI9EesG\
FQIDAQAB\
-----END PUBLIC KEY-----\
",
"PrivateKey": "-----BEGIN RSA PRIVATE KEY-----\
key omitted for security reasons\
-----END RSA PRIVATE KEY-----\
"
}
}
```
Salve o nome do recurso da Amazon (ARN) do certificado para usar na configuração do certificado posteriormente.
Em seguida, configure o certificado da coisa. Para obter mais informações, consulte [Configurar o certificado do objeto](manual-installation.md#configure-thing-certificate).
## Criar um perfil de troca de token
Os dispositivos principais do Greengrass usam uma função de serviço do IAM, chamada função de *troca de tokens*, para autorizar chamadas para serviços. AWS O dispositivo usa o provedor de AWS IoT credenciais para obter AWS credenciais temporárias para essa função, o que permite que o dispositivo interaja AWS IoT, envie registros para o Amazon CloudWatch Logs e baixe artefatos de componentes personalizados do Amazon S3. Para obter mais informações, consulte [Autorize os dispositivos principais a interagir com os serviços AWS](device-service-role.md).
Você usa um *alias de AWS IoT função* para configurar a função de troca de tokens para os dispositivos principais do Greengrass. Os aliases de perfil permitem que você altere o perfil de troca de tokens de um dispositivo, mas mantenha a mesma configuração do dispositivo. Para mais informações, consulte [Autorizar de chamadas diretas para serviços da AWS](https://docs.aws.amazon.com/iot/latest/developerguide/authorizing-direct-aws.html) no *Guia do desenvolvedor do AWS IoT Core *.
Nesta seção, você cria uma função do IAM de troca de tokens e um alias de AWS IoT função que aponta para a função. Se você já configurou um dispositivo principal do Greengrass, pode usar o perfil de troca de tokens e o alias de perfil em vez de criar novos. Em seguida, você configura o objeto da AWS IoT do dispositivo para usar esse perfil e alias.
**Para criar um perfil do IAM de troca de token**
1. Crie um perfil do IAM que seu dispositivo possa usar como um perfil de troca de tokens. Faça o seguinte:
1. Crie um arquivo que contenha o documento de política de confiança exigido pelo perfil de troca de token.
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 device-role-trust-policy.json
```
Copie o seguinte JSON no arquivo.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "credentials.iot.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
1. Crie o perfil de troca de token com o documento de política de confiança.
+ *GreengrassV2TokenExchangeRole*Substitua pelo nome da função do IAM a ser criada.
```
aws iam create-role --role-name GreengrassV2TokenExchangeRole --assume-role-policy-document file://device-role-trust-policy.json
```
Se a solicitação for bem-sucedida, a resposta será semelhante ao exemplo a seguir.
```
{
"Role": {
"Path": "/",
"RoleName": "GreengrassV2TokenExchangeRole",
"RoleId": "AROAZ2YMUHYHK5OKM77FB",
"Arn": "arn:aws:iam::123456789012:role/GreengrassV2TokenExchangeRole",
"CreateDate": "2021-02-06T00:13:29+00:00",
"AssumeRolePolicyDocument": {
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "credentials.iot.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
}
```
1. Crie um arquivo que contenha o documento de política de acesso exigido pelo perfil de troca de token.
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 device-role-access-policy.json
```
Copie o seguinte JSON no arquivo.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents",
"logs:DescribeLogStreams",
"s3:GetBucketLocation"
],
"Resource": "*"
}
]
}
```
**nota**
Essa política de acesso não permite acesso a artefatos de componentes nos buckets do S3. Para implantar componentes personalizados que definem artefatos no Amazon S3, é preciso adicionar permissões ao perfil para permitir que seu dispositivo principal recupere artefatos de componentes. Para obter mais informações, consulte [Permitir acesso aos buckets do S3 para artefatos de componentes](device-service-role.md#device-service-role-access-s3-bucket).
Se você ainda não tem um bucket do S3 para artefatos de componentes, é possível adicionar essas permissões depois de criar um bucket.
1. Crie uma política do IAM a partir do documento de política.
+ *GreengrassV2TokenExchangeRoleAccess*Substitua pelo nome da política do IAM a ser criada.
```
aws iam create-policy --policy-name GreengrassV2TokenExchangeRoleAccess --policy-document file://device-role-access-policy.json
```
Se a solicitação for bem-sucedida, a resposta será semelhante ao exemplo a seguir.
```
{
"Policy": {
"PolicyName": "GreengrassV2TokenExchangeRoleAccess",
"PolicyId": "ANPAZ2YMUHYHACI7C5Z66",
"Arn": "arn:aws:iam::123456789012:policy/GreengrassV2TokenExchangeRoleAccess",
"Path": "/",
"DefaultVersionId": "v1",
"AttachmentCount": 0,
"PermissionsBoundaryUsageCount": 0,
"IsAttachable": true,
"CreateDate": "2021-02-06T00:37:17+00:00",
"UpdateDate": "2021-02-06T00:37:17+00:00"
}
}
```
1. Anexe a política do IAM ao perfil de troca de token.
+ Substitua *GreengrassV2TokenExchangeRole* pelo nome da perfil do IAM.
+ Substitua o ARN da política pelo ARN da política do IAM que você criou na etapa anterior.
```
aws iam attach-role-policy --role-name GreengrassV2TokenExchangeRole --policy-arn arn:aws:iam::123456789012:policy/GreengrassV2TokenExchangeRoleAccess
```
O comando não terá nenhuma saída se a solicitação for bem-sucedida.
1. Crie um alias de AWS IoT função que aponte para a função de troca de tokens.
+ *GreengrassCoreTokenExchangeRoleAlias*Substitua pelo nome do alias de função a ser criado.
+ Substitua o ARN do perfil pelo ARN do perfil do IAM que você criou na etapa anterior.
```
aws iot create-role-alias --role-alias GreengrassCoreTokenExchangeRoleAlias --role-arn arn:aws:iam::123456789012:role/GreengrassV2TokenExchangeRole
```
Se a solicitação for bem-sucedida, a resposta será semelhante ao exemplo a seguir.
```
{
"roleAlias": "GreengrassCoreTokenExchangeRoleAlias",
"roleAliasArn": "arn:aws:iot:us-west-2:123456789012:rolealias/GreengrassCoreTokenExchangeRoleAlias"
}
```
**nota**
Para criar um alias do perfil, é preciso ter permissão para passar o perfil do IAM de troca de token para a AWS IoT. Se você receber uma mensagem de erro ao tentar criar um alias de função, verifique se o AWS usuário tem essa permissão. Para obter mais informações, consulte [Conceder permissões a um usuário para passar uma função para um AWS serviço](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_passrole.html) no *Guia do AWS Identity and Access Management usuário*.
1. Crie e anexe uma AWS IoT política que permita que seu dispositivo principal do Greengrass use o alias de função para assumir a função de troca de tokens. Se você já configurou um dispositivo principal do Greengrass, pode anexar sua AWS IoT política de alias de função em vez de criar uma nova. Faça o seguinte:
1. (Opcional) Crie um arquivo que contenha o documento AWS IoT de política exigido pelo alias da funçã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 greengrass-v2-iot-role-alias-policy.json
```
Copie o JSON a seguir no arquivo.
+ Substitua o ARN do recurso pelo ARN do alias da do perfil.
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "iot:AssumeRoleWithCertificate",
"Resource": "arn:aws:iot:us-west-2:123456789012:rolealias/GreengrassCoreTokenExchangeRoleAlias"
}
]
}
```
1. Crie uma AWS IoT política a partir do documento de política.
+ *GreengrassCoreTokenExchangeRoleAliasPolicy*Substitua pelo nome da AWS IoT política a ser criada.
```
aws iot create-policy --policy-name GreengrassCoreTokenExchangeRoleAliasPolicy --policy-document file://greengrass-v2-iot-role-alias-policy.json
```
Se a solicitação for bem-sucedida, a resposta será semelhante ao exemplo a seguir.
```
{
"policyName": "GreengrassCoreTokenExchangeRoleAliasPolicy",
"policyArn": "arn:aws:iot:us-west-2:123456789012:policy/GreengrassCoreTokenExchangeRoleAliasPolicy",
"policyDocument": "{
\\"Version\\":\\"2012-10-17 \\",
\\"Statement\\": [
{
\\"Effect\\": \\"Allow\\",
\\"Action\\": \\"iot:AssumeRoleWithCertificate\\",
\\"Resource\\": \\"arn:aws:iot:us-west-2:123456789012:rolealias/GreengrassCoreTokenExchangeRoleAlias\\"
}
]
}",
"policyVersionId": "1"
}
```
1. Anexe a AWS IoT política ao certificado da AWS IoT coisa.
+ *GreengrassCoreTokenExchangeRoleAliasPolicy*Substitua pelo nome da AWS IoT política de alias de função.
+ Substitua o ARN de destino pelo ARN do certificado do objeto da AWS IoT .
```
aws iot attach-policy --policy-name GreengrassCoreTokenExchangeRoleAliasPolicy --target arn:aws:iot:us-west-2:123456789012:cert/aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4
```
O comando não terá nenhuma saída se a solicitação for bem-sucedida.
## Baixar certificados para o dispositivo
Anteriormente, você baixou o certificado do dispositivo para o computador de desenvolvimento. Nesta secção, transfere o certificado da autoridade de certificação (CA) de raiz da Amazon. Em seguida, se você planeja executar o software AWS IoT Greengrass Core no Docker em um computador diferente do seu computador de desenvolvimento, copie os certificados para esse computador host. O software AWS IoT Greengrass Core usa esses certificados para se conectar ao serviço de AWS IoT nuvem.
**Para baixar certificados para o dispositivo**
1. No seu computador de desenvolvimento, baixe o certificado da autoridade de certificação raiz (CA) da Amazon. AWS IoT os certificados são associados ao certificado CA raiz da Amazon por padrão.
------
#### [ Linux or Unix ]
```
sudo curl -o ./greengrass-v2-certs/AmazonRootCA1.pem https://www.amazontrust.com/repository/AmazonRootCA1.pem
```
------
#### [ Windows Command Prompt (CMD) ]
```
curl -o .\greengrass-v2-certs\AmazonRootCA1.pem https://www.amazontrust.com/repository/AmazonRootCA1.pem
```
------
#### [ PowerShell ]
```
iwr -Uri https://www.amazontrust.com/repository/AmazonRootCA1.pem -OutFile .\greengrass-v2-certs\AmazonRootCA1.pem
```
------
1. Se você planeja executar o software AWS IoT Greengrass Core no Docker em um dispositivo diferente do seu computador de desenvolvimento, copie os certificados para o computador host. Se o SSH e o SCP estiverem habilitados no computador de desenvolvimento e no computador host, será possível usar o comando `scp` no computador de desenvolvimento para transferir os certificados. *device-ip-address*Substitua pelo endereço IP do seu computador host.
```
scp -r greengrass-v2-certs/ device-ip-address:~
```
## Criar um arquivo de configuração
1. No computador host, crie uma pasta para colocar seu arquivo de configuração.
```
mkdir ./greengrass-v2-config
```
1. Utilize um editor de texto para criar um arquivo de configuração com o nome `config.yaml` na pasta `./greengrass-v2-config`.
Por exemplo, você pode executar o seguinte comando para usar o GNU nano para criar o `config.yaml`.
```
nano ./greengrass-v2-config/config.yaml
```
1. Copie o conteúdo YAML a seguir para o arquivo. Esse arquivo de configuração parcial especifica os parâmetros do sistema e os parâmetros do núcleo do Greengrass.
```
---
system:
certificateFilePath: "/tmp/certs/device.pem.crt"
privateKeyPath: "/tmp/certs/private.pem.key"
rootCaPath: "/tmp/certs/AmazonRootCA1.pem"
rootpath: "/greengrass/v2"
thingName: "MyGreengrassCore"
services:
aws.greengrass.Nucleus:
componentType: "NUCLEUS"
version: "nucleus-version"
configuration:
awsRegion: "region"
iotRoleAlias: "GreengrassCoreTokenExchangeRoleAlias"
iotDataEndpoint: "device-data-prefix-ats.iot.region.amazonaws.com"
iotCredEndpoint: "device-credentials-prefix.credentials.region.amazonaws.com"
```
Em seguida, substitua os seguintes valores:
+ */tmp/certs*. O diretório no contêiner do Docker no qual você monta os certificados baixados ao iniciar o contêiner.
+ `/greengrass/v2`. A pasta raiz do Greengrass que você deseja usar para instalação. Use a variável de ambiente `GGC_ROOT` para definir esse valor.
+ *MyGreengrassCore*. O nome da AWS IoT coisa.
+ *nucleus-version*. A versão do software AWS IoT Greengrass Core a ser instalada. Esse valor deve corresponder à versão da imagem do Docker ou do Dockerfile que você baixou. Se você baixou a imagem do Docker do Greengrass com a tag `latest`, use ****docker inspect *image-id***** para ver a versão da imagem.
+ *region*. O Região da AWS local em que você criou seus AWS IoT recursos. Também é necessário especificar o mesmo valor para a variável de ambiente `AWS_REGION` em seu [arquivo de ambiente](#create-env-file-manual-provisioning).
+ *GreengrassCoreTokenExchangeRoleAlias*. O alias da função de troca de tokens.
+ *device-data-prefix*. O prefixo do seu endpoint AWS IoT de dados.
+ *device-credentials-prefix*. O prefixo do seu endpoint de AWS IoT credenciais.
## Criar um arquivo de ambiente
Este tutorial usa um arquivo de ambiente para definir as variáveis de ambiente que serão passadas para o instalador do software AWS IoT Greengrass Core dentro do contêiner Docker. Você também pode usar [o argumento `-e` ou `--env`](https://docs.docker.com/engine/reference/commandline/run/#env) em seu comando `docker run` para definir variáveis de ambiente no contêiner do Docker ou definir as variáveis em [um bloco `environment`](https://docs.docker.com/compose/compose-file/compose-file-v3/#environment) no arquivo `docker-compose.yml`.
1. Use um editor de texto para criar um arquivo de ambiente chamado `.env`.
Por exemplo, em um sistema baseado em Linux, você pode executar o comando a seguir para usar o GNU nano para criar o `.env` no diretório atual.
```
nano .env
```
1. Copie o conteúdo a seguir para o arquivo.
```
GGC_ROOT_PATH=/greengrass/v2
AWS_REGION=region
PROVISION=false
COMPONENT_DEFAULT_USER=ggc_user:ggc_group
INIT_CONFIG=/tmp/config/config.yaml
```
Em seguida, substitua os valores a seguir:
+ `/greengrass/v2`. O caminho para a pasta raiz a ser usada para instalar o software AWS IoT Greengrass Core.
+ *region*. O Região da AWS local em que você criou seus AWS IoT recursos. Você deve especificar o mesmo valor para o parâmetro de configuração `awsRegion` em seu [arquivo de configuração](#create-docker-install-configuration-file).
+ */tmp/config/*. A pasta na qual você monta o arquivo de configuração ao iniciar o contêiner do Docker.
**nota**
É possível definir a variável de ambiente `DEPLOY_DEV_TOOLS` para `true` a fim de implantar o [componente CLI do Greengrass](greengrass-cli-component.md), que permite desenvolver componentes personalizados dentro do contêiner do Docker. Recomendamos que você use este componente somente em ambientes de desenvolvimento, não em ambientes de produção. Este componente fornece acesso a informações e operações que você normalmente não precisará em um ambiente de produção. Siga o princípio do privilégio mínimo implantando este componente somente nos dispositivos principais em que você precisar dele.
## Execute o software AWS IoT Greengrass principal em um contêiner
Este tutorial mostra como iniciar a imagem do Docker que você criou em um contêiner do Docker. Você pode usar a CLI do Docker ou a CLI do Docker Compose para AWS IoT Greengrass executar a imagem do software Core em um contêiner do Docker.
------
#### [ Docker ]
+ Este tutorial mostra como iniciar a imagem do Docker que você criou em um contêiner do Docker.
```
docker run --rm --init -it --name docker-image \
-v path/to/greengrass-v2-config:/tmp/config/:ro \
-v path/to/greengrass-v2-certs:/tmp/certs:ro \
--env-file .env \
-p 8883 \
your-container-image:version
```
Esse exemplo de comando usa os seguintes argumentos para [docker run](https://docs.docker.com/engine/reference/commandline/run/):
+ [https://docs.docker.com/engine/reference/run/#clean-up---rm](https://docs.docker.com/engine/reference/run/#clean-up---rm). Limpa o contêiner quando ele sair.
+ [https://docs.docker.com/engine/reference/run/#specify-an-init-process](https://docs.docker.com/engine/reference/run/#specify-an-init-process). Usa um processo de inicialização no contêiner.
**nota**
O `--init` argumento é necessário para desligar o software AWS IoT Greengrass Core quando você interrompe o contêiner Docker.
+ [https://docs.docker.com/engine/reference/run/#foreground](https://docs.docker.com/engine/reference/run/#foreground). (Opcional) Executa o contêiner do Docker em primeiro plano como um processo interativo. Em vez disso, você pode substituir isso pelo argumento `-d` para executar o contêiner do Docker no modo desanexado. Para obter mais informações, consulte [Detached vs foreground](https://docs.docker.com/engine/reference/run/#detached-vs-foreground) na documentação do Docker.
+ [https://docs.docker.com/engine/reference/run/#name---name](https://docs.docker.com/engine/reference/run/#name---name). Executa um contêiner chamado `aws-iot-greengrass`
+ [https://docs.docker.com/storage/volumes/](https://docs.docker.com/storage/volumes/). Monta um volume no contêiner do Docker para disponibilizar o arquivo de configuração e os arquivos de certificado para AWS IoT Greengrass execução dentro do contêiner.
+ [https://docs.docker.com/engine/reference/commandline/run/#env](https://docs.docker.com/engine/reference/commandline/run/#env). (Opcional) Especifica o arquivo de ambiente para definir as variáveis de ambiente que serão passadas para o instalador do software AWS IoT Greengrass Core dentro do contêiner Docker. Esse argumento é necessário somente se você criou um [arquivo de ambiente](#create-env-file-manual-provisioning) para definir variáveis de ambiente. Se você não criou um arquivo de ambiente, pode usar argumentos `--env` para definir variáveis de ambiente diretamente no comando de execução do Docker.
+ [https://docs.docker.com/engine/reference/commandline/run/#publish](https://docs.docker.com/engine/reference/commandline/run/#publish). (Opcional) Publica a porta 8883 do contêiner na máquina host. Esse argumento é necessário se você quiser se conectar e se comunicar pelo MQTT porque o AWS IoT Greengrass usa a porta 8883 para tráfego MQTT. Para abrir outras portas, use argumentos `-p` adicionais.
**nota**
Para executar seu contêiner do Docker com maior segurança, você pode usar os argumentos `--cap-drop` e `--cap-add` para habilitar seletivamente os recursos do Linux para seu contêiner. Para obter mais informações, consulte [Runtime privilege and Linux capabilities](https://docs.docker.com/engine/reference/run/#runtime-privilege-and-linux-capabilities) no site de documentação do Docker.
------
#### [ Docker Compose ]
1. Use um editor de texto para criar um arquivo Compose do Docker chamado `docker-compose.yml`.
Por exemplo, em um sistema baseado em Linux, você pode executar o comando a seguir para usar o GNU nano para criar o `docker-compose.yml` no diretório atual.
```
nano docker-compose.yml
```
**nota**
Você também pode baixar e usar a versão mais recente do arquivo Compose AWS fornecido em. [GitHub](https://github.com/aws-greengrass/aws-greengrass-docker/releases/)
1. Adicione o conteúdo a seguir ao arquivo do Compose. O arquivo deve ser semelhante ao exemplo a seguir. *your-container-name:version*Substitua pelo nome da sua imagem do Docker.
```
version: '3.7'
services:
greengrass:
init: true
build:
context: .
container_name: aws-iot-greengrass
image: your-container-name:version
volumes:
- /path/to/greengrass-v2-config:/tmp/config/:ro
- /path/to/greengrass-v2-certs:/tmp/certs:ro
env_file: .env
ports:
- "8883:8883"
```
Neste exemplo, os seguintes parâmetros no arquivo do Compose são opcionais:
+ `ports`: publica a porta 8883 do contêiner na máquina host. Esse parâmetro é necessário se você quiser se conectar e se comunicar pelo MQTT porque AWS IoT Greengrass usa a porta 8883 para tráfego MQTT.
+ `env_file`—Especifica o arquivo de ambiente para definir as variáveis de ambiente que serão passadas para o instalador do software AWS IoT Greengrass Core dentro do contêiner Docker. Esse parâmetro é necessário somente se você criou um [arquivo de ambiente](#create-env-file-manual-provisioning) para definir variáveis de ambiente. Se você não criou um arquivo de ambiente, pode usar o parâmetro [environment](https://docs.docker.com/compose/compose-file/compose-file-v3/#environment) para definir variáveis de ambiente diretamente em seu arquivo Compose.
**nota**
Para executar seu contêiner do Docker com maior segurança, você pode usar os argumentos `cap_drop` e `cap_add` em seu arquivo do Compose para habilitar seletivamente os recursos do Linux para seu contêiner. Para obter mais informações, consulte [Runtime privilege and Linux capabilities](https://docs.docker.com/engine/reference/run/#runtime-privilege-and-linux-capabilities) no site de documentação do Docker.
1. Execute o seguinte comando para iniciar o contêiner.
```
docker-compose -f docker-compose.yml up
```
------
## Próximas etapas
AWS IoT Greengrass O software principal agora está sendo executado em um contêiner Docker. Execute o comando a seguir para recuperar o ID do contêiner em execução no momento.
```
docker ps
```
Em seguida, você pode executar o comando a seguir para acessar o contêiner e explorar o software AWS IoT Greengrass principal executado dentro do contêiner.
```
docker exec -it container-id /bin/bash
```
Para obter mais informações sobre a criação de um componente simples, consulte [Etapa 4: desenvolver e testar um componente no dispositivo](create-first-component.md) em [Tutorial: Conceitos básicos do AWS IoT Greengrass V2](getting-started.md).
**nota**
Quando você usa `docker exec` para executar comandos dentro do contêiner do Docker, esses comandos não são registrados nos logs do Docker. Para registrar os comandos nos logs do Docker, anexe um shell interativo ao contêiner do Docker. Para obter mais informações, consulte [Anexar um shell interativo ao contêiner do Docker](docker-troubleshooting.md#debugging-docker-attach-shell).
O arquivo de log AWS IoT Greengrass principal é chamado `greengrass.log` e está localizado em`/greengrass/v2/logs`. Os arquivos de log do componente também estão localizados no mesmo diretório. Para copiar logs do Greengrass para um diretório temporário no host, execute o seguinte comando:
```
docker cp container-id:/greengrass/v2/logs /tmp/logs
```
Se você quiser manter os logs após a saída ou remoção de um contêiner, recomendamos que você vincule e monte somente o diretório `/greengrass/v2/logs` no diretório de logs temporários no host, em vez de montar todo o diretório Greengrass. Para obter mais informações, consulte [Manter os logs do Greengrass fora do contêiner do Docker](docker-troubleshooting.md#debugging-docker-persist-logs).
Para interromper a execução de um contêiner AWS IoT Greengrass Docker, execute `docker stop` ou`docker-compose -f docker-compose.yml stop`. Essa ação envia `SIGTERM` para o processo do Greengrass e encerra todos os processos associados que foram iniciados no contêiner. O contêiner do Docker é inicializado com o `docker-init` executável como processo PID 1, o que ajuda a eliminar quaisquer processos zumbis restantes. Para obter mais informações, consulte [Specify an init process](https://docs.docker.com/engine/reference/run/#specify-an-init-process) na documentação do Docker.
Para obter informações sobre como solucionar problemas com a execução do AWS IoT Greengrass em um contêiner do Docker, consulte [Solução de problemas AWS IoT Greengrass em um contêiner Docker](docker-troubleshooting.md).
# Solução de problemas AWS IoT Greengrass em um contêiner Docker
Use as informações a seguir para ajudá-lo a solucionar problemas com a execução AWS IoT Greengrass em um contêiner do Docker e para depurar problemas AWS IoT Greengrass no contêiner do Docker.
**Topics**
+ [Solução de problemas ao executar o contêiner do Docker](#troubleshooting-container-errors)
+ [Depuração em um contêiner AWS IoT Greengrass Docker](#debugging-greengrass-in-docker)
## Solução de problemas ao executar o contêiner do Docker
Use as informações a seguir para ajudar a solucionar problemas com a execução AWS IoT Greengrass em um contêiner do Docker.
**Topics**
+ [Erro: não é possível realizar um login interativo em um dispositivo não TTY](#docker-troubleshootin-ecr-get-login-password)
+ [Erro: Opções desconhecidas: - no-include-email](#docker-troubleshooting-cli-version)
+ [Erro: Um firewall está bloqueando o compartilhamento de arquivos entre janelas e os contêineres.](#docker-troubleshooting-firewall)
+ [Erro: ocorreu um erro (AccessDeniedException) ao chamar a GetAuthorizationToken operação: Usuário: arn:aws:iam: ::user/ não *account-id* está autorizado a executar: ecr: on resource: \$1 GetAuthorizationToken](#docker-troubleshooting-ecr-perms)
+ [Erro: você atingiu seu limite de taxa de pull](#docker-troubleshooting-too-many-requests)
### Erro: não é possível realizar um login interativo em um dispositivo não TTY
Este erro pode ocorrer ao executar o comando `aws ecr get-login-password`. Verifique se você instalou a AWS CLI versão mais recente 2 ou a versão 1. Recomendamos que você use a AWS CLI versão 2. Para obter mais informações, consulte [Instalar a AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html) no *Guia do usuário da AWS Command Line Interface *.
### Erro: Opções desconhecidas: - no-include-email
Este erro pode ocorrer ao executar o comando `aws ecr get-login`. Verifique se você tem a AWS CLI versão mais recente instalada (por exemplo, Executar:`pip install awscli --upgrade --user`). Para obter mais informações, consulte [Instalando o AWS Command Line Interface no Microsoft Windows](https://docs.aws.amazon.com/cli/latest/userguide/awscli-install-windows.html) no *Guia AWS Command Line Interface do Usuário*.
### Erro: Um firewall está bloqueando o compartilhamento de arquivos entre janelas e os contêineres.
Esse erro ou uma mensagem `Firewall Detected` podem ser recebidos ao executar o Docker em um computador Windows. Esse erro também poderá ocorrer se você estiver conectado em uma rede privada virtual (VPN), e as configurações de rede estiverem impedindo a montagem da unidade compartilhada. Nesse caso, desative a VPN e execute novamente o contêiner do Docker.
### Erro: ocorreu um erro (AccessDeniedException) ao chamar a GetAuthorizationToken operação: Usuário: arn:aws:iam: ::user/ não *account-id* está autorizado a executar: ecr: on resource: \$1 GetAuthorizationToken
É possível que você receba esse erro ao executar o comando `aws ecr get-login-password` se não tiver permissões suficientes para acessar um repositório do Amazon ECR. Para obter mais informações, consulte [Exemplos de políticas de repositório do Amazon ECR](https://docs.aws.amazon.com/AmazonECR/latest/userguide/repository-policy-examples.html) e [Como acessar um repositório do Amazon ECR](https://docs.aws.amazon.com/AmazonECR/latest/userguide/security_iam_id-based-policy-examples.html) no *Guia do usuário do Amazon ECR*.
### Erro: você atingiu seu limite de taxa de pull
O Docker Hub limita o número de solicitações de pull que usuários anônimos e gratuitos do Docker Hub podem fazer. Se você exceder os limites de taxa para solicitações de pull de usuários anônimos ou gratuitos, você receberá um dos seguintes erros:
```
ERROR: toomanyrequests: Too Many Requests.
```
```
You have reached your pull rate limit.
```
Para resolver esses erros, espere algumas horas antes de tentar outra solicitação de pull. Se você planeja enviar um grande número de solicitações de pull, consulte o [site do Docker Hub](https://www.docker.com/increase-rate-limits) para informações sobre limites de taxa e opções para autenticar e atualizar sua conta do Docker.
## Depuração em um contêiner AWS IoT Greengrass Docker
Para depurar problemas com um contêiner do Docker, você pode manter os logs de runtime do Greengrass ou anexar um shell interativo ao contêiner do Docker.
### Manter os logs do Greengrass fora do contêiner do Docker
Depois de parar um AWS IoT Greengrass contêiner, você pode usar o `docker cp ` comando a seguir para copiar os registros do Greengrass do contêiner Docker para um diretório de registros temporário.
```
docker cp container-id:/greengrass/v2/logs /tmp/logs
```
Para manter os registros mesmo após a saída ou remoção de um contêiner, você deve executar o contêiner do AWS IoT Greengrass Docker após a montagem do diretório. `/greengrass/v2/logs`
Para vincular e montar o `/greengrass/v2/logs` diretório, faça o seguinte ao executar um novo AWS IoT Greengrass contêiner do Docker.
+ Inclua `-v /tmp/logs:/greengrass/v2/logs:ro` no comando `docker run`.
Modifique o bloco `volumes` no arquivo Compose para incluir a linha a seguir antes de executar o comando `docker-compose up`.
```
volumes:
- /tmp/logs:/greengrass/v2/logs:ro
```
Em seguida, você pode verificar seus registros `/tmp/logs` em seu host para ver os registros do Greengrass enquanto AWS IoT Greengrass está sendo executado dentro do contêiner do Docker.
Para informações sobre a execução de contêineres do Docker do Greengrass, consulte [Execute AWS IoT Greengrass no Docker com provisionamento manual](run-greengrass-docker-manual-provisioning.md) e [Execute AWS IoT Greengrass no Docker com provisionamento automático](run-greengrass-docker-automatic-provisioning.md)
### Anexar um shell interativo ao contêiner do Docker
Quando você usa `docker exec` para executar comandos dentro do contêiner do Docker, esses comandos não são capturados nos logs do Docker. Registrar seus comandos nos logs do Docker ajuda a investigar o estado do contêiner do Docker do Greengrass. Execute um destes procedimentos:
+ Execute o seguinte comando em um terminal separado para conectar a entrada, a saída e o erro padrão do terminal ao contêiner em execução. Isso permite visualizar e controlar o contêiner do Docker a partir do terminal atual.
```
docker attach container-id
```
+ Execute o comando a seguir em um terminal separado. Isso permite executar os comandos no modo interativo, mesmo que o contêiner não esteja conectado.
```
docker exec -it container-id sh -c "command > /proc/1/fd/1"
```
Para AWS IoT Greengrass solução geral de problemas, consulte[Solução de problemas AWS IoT Greengrass V2](troubleshooting.md).
# Configurar o software AWS IoT Greengrass principal
O software AWS IoT Greengrass Core fornece opções que você pode usar para configurar o software. Você pode criar implantações para configurar o software AWS IoT Greengrass Core em cada dispositivo principal.
**Topics**
+ [Implementar o componente do Greengrass nucleus](#configure-nucleus-component)
+ [Configurar o Greengrass nucleus como um serviço do sistema](#configure-system-service)
+ [Controlar a alocação de memória com opções de JVM](#jvm-tuning)
+ [Configurar o usuário que executa os componentes](#configure-component-user)
+ [Configurar limites de recursos do sistema para componentes](#configure-component-system-resource-limits)
+ [Conectar-se à porta 443 ou por meio de um proxy de rede](#configure-alpn-network-proxy)
+ [Usar um certificado de dispositivo assinado por uma CA privada](#configure-nucleus-private-ca)
+ [Definir os tempos limite do MQTT e as configurações de cache](#configure-mqtt)
+ [Configurar o Greengrass Nucleus na rede IPv6](#configure-ipv6)
## Implementar o componente do Greengrass nucleus
AWS IoT Greengrass fornece o software AWS IoT Greengrass Core como um componente que você pode implantar em seus dispositivos principais do Greengrass. É possível criar uma implantação para aplicar a mesma configuração a vários dispositivos principais do Greengrass. Para obter mais informações, consulte [Greengrass nucleus](greengrass-nucleus-component.md) e [Atualizar o software de núcleo do AWS IoT Greengrass (OTA)](update-greengrass-core-v2.md).
## Configurar o Greengrass nucleus como um serviço do sistema
Você deve configurar o software AWS IoT Greengrass Core como um serviço do sistema no sistema inicial do seu dispositivo para fazer o seguinte:
+ Inicie o software AWS IoT Greengrass Core quando o dispositivo for inicializado. Essa é uma prática recomendada se você gerencia grandes frotas de dispositivos.
+ Instale e execute os componentes do plug-in. Vários componentes AWS fornecidos são componentes de plug-ins, o que permite que eles interajam diretamente com o núcleo do Greengrass. Para obter mais informações sobre tipos de componentes, consulte [Tipos de componentes](develop-greengrass-components.md#component-types).
+ Aplique atualizações over-the-air (OTA) ao software principal do dispositivo AWS IoT Greengrass principal. Para obter mais informações, consulte [Atualizar o software de núcleo do AWS IoT Greengrass (OTA)](update-greengrass-core-v2.md).
+ Permita que os componentes reiniciem o software AWS IoT Greengrass principal ou o dispositivo principal quando uma implantação atualiza o componente para uma nova versão ou atualiza determinados parâmetros de configuração. Para mais informações, consulte a [etapa do ciclo de vida do bootstrap](component-recipe-reference.md#bootstrap-lifecycle-definition).
**Importante**
Nos dispositivos principais do Windows, você deve configurar o software AWS IoT Greengrass Core como um serviço do sistema.
**Topics**
+ [Configurar o núcleo como um serviço do sistema (Linux)](#configure-system-service-linux)
+ [Configurar o núcleo como um serviço do sistema (Windows)](#configure-system-service-windows)
### Configurar o núcleo como um serviço do sistema (Linux)
Os dispositivos Linux são compatíveis com diferentes sistemas de inicialização, como initd, systemd e systemV. Você usa o `--setup-system-service true` argumento ao instalar o software AWS IoT Greengrass Core para iniciar o núcleo como um serviço do sistema e configurá-lo para ser iniciado quando o dispositivo for inicializado. O instalador configura o software AWS IoT Greengrass Core como um serviço do sistema com o systemd.
Também é possível configurar manualmente o núcleo para ser executado como um serviço do sistema. O exemplo a seguir é um arquivo de serviço systemd.
```
[Unit]
Description=Greengrass Core
[Service]
Type=simple
PIDFile=/greengrass/v2/alts/loader.pid
RemainAfterExit=no
Restart=on-failure
RestartSec=10
ExecStart=/bin/sh /greengrass/v2/alts/current/distro/bin/loader
[Install]
WantedBy=multi-user.target
```
Depois de configurar o serviço do sistema, você pode executar os seguintes comandos para configurar a inicialização do dispositivo na inicialização e para iniciar ou parar o software AWS IoT Greengrass Core.
+ Para verificar o status do serviço (systemd)
```
sudo systemctl status greengrass.service
```
+ Para permitir que o núcleo inicie quando o dispositivo for inicializado.
```
sudo systemctl enable greengrass.service
```
+ Para impedir que o núcleo seja iniciado quando o dispositivo for inicializado.
```
sudo systemctl disable greengrass.service
```
+ Para iniciar o software AWS IoT Greengrass Core.
```
sudo systemctl start greengrass.service
```
+ Para parar o software AWS IoT Greengrass Core.
```
sudo systemctl stop greengrass.service
```
### Configurar o núcleo como um serviço do sistema (Windows)
Você usa o `--setup-system-service true` argumento ao instalar o software AWS IoT Greengrass Core para iniciar o núcleo como um serviço do Windows e configurá-lo para ser iniciado quando o dispositivo for inicializado.
Depois de configurar o serviço, você pode executar os seguintes comandos para configurar a inicialização do dispositivo na inicialização e para iniciar ou parar o software AWS IoT Greengrass Core. Você deve executar o prompt de comando ou PowerShell como administrador para executar esses comandos.
------
#### [ Windows Command Prompt (CMD) ]
+ Para verificar o status do serviço
```
sc query "greengrass"
```
+ Para permitir que o núcleo inicie quando o dispositivo for inicializado.
```
sc config "greengrass" start=auto
```
+ Para impedir que o núcleo seja iniciado quando o dispositivo for inicializado.
```
sc config "greengrass" start=disabled
```
+ Para iniciar o software AWS IoT Greengrass Core.
```
sc start "greengrass"
```
+ Para parar o software AWS IoT Greengrass Core.
```
sc stop "greengrass"
```
**nota**
Em dispositivos Windows, o software AWS IoT Greengrass Core ignora esse sinal de desligamento enquanto desliga os processos dos componentes do Greengrass. Se o software AWS IoT Greengrass Core ignorar o sinal de desligamento ao executar esse comando, aguarde alguns segundos e tente novamente.
------
#### [ PowerShell ]
+ Para verificar o status do serviço
```
Get-Service -Name "greengrass"
```
+ Para permitir que o núcleo inicie quando o dispositivo for inicializado.
```
Set-Service -Name "greengrass" -Status stopped -StartupType automatic
```
+ Para impedir que o núcleo seja iniciado quando o dispositivo for inicializado.
```
Set-Service -Name "greengrass" -Status stopped -StartupType disabled
```
+ Para iniciar o software AWS IoT Greengrass Core.
```
Start-Service -Name "greengrass"
```
+ Para parar o software AWS IoT Greengrass Core.
```
Stop-Service -Name "greengrass"
```
**nota**
Em dispositivos Windows, o software AWS IoT Greengrass Core ignora esse sinal de desligamento enquanto desliga os processos dos componentes do Greengrass. Se o software AWS IoT Greengrass Core ignorar o sinal de desligamento ao executar esse comando, aguarde alguns segundos e tente novamente.
------
## Controlar a alocação de memória com opções de JVM
Se você estiver executando AWS IoT Greengrass em um dispositivo com memória limitada, poderá usar as opções da máquina virtual Java (JVM) para controlar o tamanho máximo da pilha, os modos de coleta de lixo e as opções do compilador, que controlam a quantidade de memória usada pelo software Core. AWS IoT Greengrass O tamanho do heap na JVM determina a quantidade de memória que uma aplicação pode usar antes que a [coleta de resíduos](https://docs.oracle.com/javase/8/docs/technotes/guides/vm/gctuning/introduction.html) ocorra ou antes que a aplicação fique sem memória. O tamanho máximo do heap especifica a quantidade máxima de memória que a JVM pode alocar ao expandir o heap durante uma atividade intensa.
Para controlar a alocação de memória, crie uma nova implantação ou revise uma implantação existente que inclua o componente do núcleo e especifique as opções de JVM no parâmetro de configuração `jvmOptions` na [configuração do componente do núcleo](greengrass-nucleus-component.md#greengrass-nucleus-component-configuration-jvm-options).
Dependendo dos seus requisitos, você pode executar o software AWS IoT Greengrass Core com alocação de memória reduzida ou com alocação mínima de memória.
**Alocação de memória reduzida**
Para executar o software AWS IoT Greengrass Core com alocação de memória reduzida, recomendamos que você use o seguinte exemplo de atualização de mesclagem de configuração para definir as opções de JVM na configuração do núcleo:
```
{
"jvmOptions": "-XX:+UseSerialGC -XX:TieredStopAtLevel=1"
}
```
**Alocação mínima de memória**
Para executar o software AWS IoT Greengrass Core com alocação mínima de memória, recomendamos que você use o seguinte exemplo de atualização de mesclagem de configuração para definir as opções de JVM na configuração do núcleo:
```
{
"jvmOptions": "-Xmx32m -XX:+UseSerialGC -Xint"
}
```
**Importante**
A execução AWS IoT Greengrass do software Core com alocação mínima de memória pode ter um impacto significativo no desempenho de sistemas de baixa especificação, pois a JVM processará mais quando usar menos memória. Recomendamos ajustar as opções para equilibrar suas necessidades de memória e performance.
Esses exemplos de atualizações de mesclagem de configurações usam as seguintes opções de JVM:
`-XX:+UseSerialGC`
Especifica o uso da coleta de resíduos serial para o espaço de do heap da JVM. O coleta de resíduos serial é mais lento, mas usa menos memória do que outras implementações de coleta de resíduos da JVM.
`-XX:TieredStopAtLevel=1`
Instrui a JVM a usar o compilador Java just-in-time (JIT) uma vez. Como o código compilado pelo JIT usa espaço na memória do dispositivo, usar o compilador JIT mais de uma vez consome mais memória do que uma única compilação.
`-XmxNNm`
Define o tamanho máximo do heap da JVM.
Definir o tamanho máximo da pilha muito baixo pode causar desempenho ou out-of-memory erros mais lentos. Recomendamos medir o uso atual dele antes de definir um tamanho máximo com a opção `-XmxNNm`. Configure sua JVM com a opção `-XX:NativeMemoryTracking=detail` JVM. Em seguida, meça o uso atual do heap usando a solicitação de comando `VM.native_memory` no [Utilitário jcmd](https://docs.oracle.com/javase/8/docs/technotes/guides/troubleshoot/tooldescr006.html).
Se a medição do heap não for uma opção, use `-Xmx64m` como valor inicial para limitar o tamanho do heap a 64 MB. Em seguida, é possível diminuir gradualmente o tamanho máximo do heap a partir daí. Para alocação mínima de memória, use `-Xmx32m` como valor inicial para limitar o tamanho do heap a 32 MB.
É possível aumentar ou diminuir o valor do `-Xmx` dependendo dos seus requisitos reais. No entanto, é altamente recomendável que você não defina o tamanho máximo do heap abaixo de 16 MB. A quantidade de tamanho do heap da JVM necessária também pode variar com o tempo, com base nos componentes do plug-in implantados no dispositivo principal. Se o tamanho máximo da pilha for muito baixo para o seu ambiente, o software AWS IoT Greengrass Core poderá encontrar erros inesperados devido à memória insuficiente. Se você tiver uma performance mais lenta ou encontrar erros devido à memória insuficiente, reverta para uma configuração conhecida como boa. Por exemplo, se o tamanho normal do heap confirmado for `41428KB`, use `-Xmx40m` para limitar um pouco o uso dele.
`-Xint`
Instrui a JVM a não usar o compilador just-in-time (JIT). Em vez disso, a JVM é executada no modo somente interpretado. Esse modo é mais lento (potencialmente 20 vezes mais lento para implantações em sistemas de baixo custo) do que executar código compilado JIT. No entanto, o código compilado não usa nenhum espaço na memória.
Para obter informações sobre como criar atualizações de mesclagem de configurações, consulte [Atualizar configurações do componente](update-component-configurations.md).
## Configurar o usuário que executa os componentes
O software AWS IoT Greengrass principal pode executar processos de componentes como usuário e grupo do sistema diferente daquele que executa o software. Isso aumenta a segurança, porque você pode executar o software AWS IoT Greengrass Core como root ou como usuário administrador, sem conceder essas permissões aos componentes que são executados no dispositivo principal.
A tabela a seguir indica quais tipos de componentes o software AWS IoT Greengrass Core pode ser executado como usuário especificado por você. Para obter mais informações, consulte [Tipos de componentes](develop-greengrass-components.md#component-types).
| Tipo de componente | Configurar usuário do componente |
| --- | --- |
| Núcleo | ![\[No\]](http://docs.aws.amazon.com/pt_br/greengrass/v2/developerguide/images/icon-no.png) Não |
| Plug-in | ![\[No\]](http://docs.aws.amazon.com/pt_br/greengrass/v2/developerguide/images/icon-no.png) Não |
| Genérico | ![\[Yes\]](http://docs.aws.amazon.com/pt_br/greengrass/v2/developerguide/images/icon-yes.png) Sim |
| Lambda (sem contêineres) | ![\[Yes\]](http://docs.aws.amazon.com/pt_br/greengrass/v2/developerguide/images/icon-yes.png) Sim |
| Lambda (em contêineres) | ![\[Yes\]](http://docs.aws.amazon.com/pt_br/greengrass/v2/developerguide/images/icon-yes.png) Sim |
Crie o usuário do componente antes de especificá-lo em uma configuração de implantação. Em dispositivos baseados em Windows, você também deve armazenar o nome de usuário e a senha do usuário na instância do gerenciador de credenciais da conta. LocalSystem Para obter mais informações, consulte [Configurar um usuário do componente em dispositivos Windows](#create-component-user-windows).
Ao configurar o usuário do componente em um dispositivo baseado em Linux, você também pode especificar um grupo. Especifique o usuário e o grupo separando-os por dois pontos (`:`), no seguinte formato: `user:group`. Se você não especificar um grupo, o software AWS IoT Greengrass Core assumirá como padrão o grupo primário do usuário. É possível usar o nome ou o ID para identificar o usuário e o grupo.
Em dispositivos baseados em Linux, também é possível executar componentes como um usuário do sistema que não existe, também chamado de usuário desconhecido, para aumentar a segurança. Um processo Linux pode sinalizar qualquer outro processo executado pelo mesmo usuário. Um usuário desconhecido não executa outros processos, então você pode executar componentes como um usuário desconhecido para evitar que outros componentes sejam sinalizados no dispositivo principal. Para executar componentes como um usuário desconhecido, especifique uma ID de usuário que não exista no dispositivo principal. Você também pode especificar uma ID de grupo que não existe para ser executada como um grupo desconhecido.
É possível configurar o usuário para cada componente e para cada dispositivo principal.
+ **Configurar para um componente**
É possível configurar cada componente para ser executado com um usuário específico desse componente. Ao criar uma implantação, você pode especificar o usuário para cada componente na configuração `runWith` deles. O software AWS IoT Greengrass Core executa componentes como o usuário especificado, se você os configurar. Caso contrário, o padrão é executar componentes como o usuário padrão configurado para o dispositivo principal. Para mais informações sobre como especificar o usuário do componente na configuração de implantação, consulte o parâmetro de configuração [`runWith`](create-deployments.md#component-run-with-config) em [Criar implantações](create-deployments.md).
+ **Configurar o usuário padrão para um dispositivo principal**
Você pode configurar um usuário padrão que o software AWS IoT Greengrass Core usa para executar componentes. Quando o software AWS IoT Greengrass Core executa um componente, ele verifica se você especificou um usuário para esse componente e o usa para executar o componente. Se o componente não especificar um usuário, o software AWS IoT Greengrass Core executará o componente como o usuário padrão que você configurou para o dispositivo principal. Para obter mais informações, consulte [Configurar o usuário padrão do componente](#configure-default-component-user).
**nota**
Em dispositivos baseados em Windows, é necessário especificar pelo menos um usuário padrão para executar componentes.
Em dispositivos baseados em Linux, as seguintes considerações se aplicam se você não configurar um usuário para executar componentes:
Se você executar o software AWS IoT Greengrass Core como root, o software não executará componentes. É necessário especificar um usuário padrão para executar componentes se você executar como raiz.
Se você executar o software AWS IoT Greengrass Core como usuário não root, o software executará componentes como esse usuário.
**Topics**
+ [Configurar um usuário do componente em dispositivos Windows](#create-component-user-windows)
+ [Configurar o usuário padrão do componente](#configure-default-component-user)
### Configurar um usuário do componente em dispositivos Windows
**Para configurar um usuário do componente em um dispositivo baseado no Windows**
1. Crie o usuário do componente na LocalSystem conta do dispositivo.
```
net user /add component-user password
```
1. Use o [ PsExec utilitário da Microsoft](https://docs.microsoft.com/en-us/sysinternals/downloads/psexec) para armazenar o nome de usuário e a senha do usuário do componente na instância do Credential Manager da LocalSystem conta.
```
psexec -s cmd /c cmdkey /generic:component-user /user:component-user /pass:password
```
**nota**
Em dispositivos baseados em Windows, a LocalSystem conta executa o núcleo Greengrass, e você deve usar o PsExec utilitário para armazenar as informações do usuário do componente 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.
### Configurar o usuário padrão do componente
É possível usar uma implantação para configurar o usuário padrão em um dispositivo principal. Nessa implantação, você atualiza a configuração do [componente do núcleo](greengrass-nucleus-component.md).
**nota**
Você também pode definir o usuário padrão ao instalar o software AWS IoT Greengrass Core com a `--component-default-user` opção. Para obter mais informações, consulte [Instalar o software do AWS IoT Greengrass Core](install-greengrass-core-v2.md).
[Crie uma implantação](create-deployments.md) que especifique a seguinte atualização de configuração para o componente `aws.greengrass.Nucleus`.
------
#### [ Linux ]
```
{
"runWithDefault": {
"posixUser": "ggc_user:ggc_group"
}
}
```
------
#### [ Windows ]
```
{
"runWithDefault": {
"windowsUser": "ggc_user"
}
}
```
**nota**
O usuário que você especificar deve existir, e o nome de usuário e a senha desse usuário devem ser armazenados na instância do gerenciador de credenciais da LocalSystem conta em seu dispositivo Windows. Para obter mais informações, consulte [Configurar um usuário do componente em dispositivos Windows](#create-component-user-windows).
------
O exemplo a seguir define uma implantação para um dispositivo baseado em Linux que configura o `ggc_user` como usuário padrão e o `ggc_group` como grupo padrão. A atualização da configuração `merge` requer um objeto JSON serializado.
```
{
"components": {
"aws.greengrass.Nucleus": {
"version": "2.16.1",
"configurationUpdate": {
"merge": "{\"runWithDefault\":{\"posixUser\":\"ggc_user:ggc_group\"}}"
}
}
}
}
```
## Configurar limites de recursos do sistema para componentes
**nota**
Esse recurso está disponível para a versão 2.4.0 e posterior do componente de núcleo do [Greengrass](greengrass-nucleus-component.md). AWS IoT Greengrass atualmente não oferece suporte a esse recurso nos dispositivos principais do Windows.
É possível configurar a quantidade máxima de uso da CPU e RAM que os processos de um componente podem usar no dispositivo principal.
A tabela a seguir mostra os tipos de componentes que oferecem suporte aos limites de recursos do sistema. Para obter mais informações, consulte [Tipos de componentes](develop-greengrass-components.md#component-types).
| Tipo de componente | Configurar limites de recursos do sistema |
| --- | --- |
| Núcleo | ![\[No\]](http://docs.aws.amazon.com/pt_br/greengrass/v2/developerguide/images/icon-no.png) Não |
| Plug-in | ![\[No\]](http://docs.aws.amazon.com/pt_br/greengrass/v2/developerguide/images/icon-no.png) Não |
| Genérico | ![\[Yes\]](http://docs.aws.amazon.com/pt_br/greengrass/v2/developerguide/images/icon-yes.png) Sim |
| Lambda (sem contêineres) | ![\[Yes\]](http://docs.aws.amazon.com/pt_br/greengrass/v2/developerguide/images/icon-yes.png) Sim |
| Lambda (em contêineres) | ![\[No\]](http://docs.aws.amazon.com/pt_br/greengrass/v2/developerguide/images/icon-no.png) Não |
**Importante**
Os limites de recursos do sistema não são suportados quando você [executa o software AWS IoT Greengrass Core em um contêiner Docker](run-greengrass-docker.md).
É possível configurar limites de recursos do sistema para cada componente e para cada dispositivo principal.
+ **Configurar para um componente**
É possível configurar cada componente com limites de recursos do sistema específicos para esse componente. Ao criar uma implantação, você pode especificar os limites de recursos do sistema para cada componente. Se o componente é compatível com os limites de recursos do sistema, o software AWS IoT Greengrass Core aplicará os limites aos processos do componente. Se você não especificar os limites de recursos do sistema para um componente, o software AWS IoT Greengrass Core usará todos os padrões que você configurou para o dispositivo principal. Para obter mais informações, consulte [Criar implantações](create-deployments.md).
+ **Configurar padrões para um dispositivo principal**
Você pode configurar os limites padrão de recursos do sistema que o software AWS IoT Greengrass Core aplica aos componentes que suportam esses limites. Quando o software AWS IoT Greengrass Core executa um componente, ele aplica os limites de recursos do sistema que você especifica para esse componente. Se esse componente não especificar limites de recursos do sistema, o software AWS IoT Greengrass Core aplicará os limites padrão de recursos do sistema que você configura para o dispositivo principal. Se você não especificar limites padrão de recursos do sistema, o software AWS IoT Greengrass Core não aplicará nenhum limite de recursos do sistema por padrão. Para obter mais informações, consulte [Configurar limites padrão de recursos do sistema](#configure-default-component-system-resource-limits).
### Configurar limites padrão de recursos do sistema
É possível implantar o [componente do Greengrass nucleus](greengrass-nucleus-component.md) para configurar os limites padrão de recursos do sistema para um dispositivo principal. Para configurar os limites padrão de recursos do sistema, [crie uma implantação](create-deployments.md) que especifique a seguinte atualização de configuração para o componente `aws.greengrass.Nucleus`.
```
{
"runWithDefault": {
"systemResourceLimits": {
"cpu": cpuTimeLimit,
"memory": memoryLimitInKb
}
}
}
```
O exemplo a seguir define uma implantação que configura o limite de tempo da CPU em `2`, o que equivale a 50% de uso em um dispositivo com 4 núcleos de CPU. Este exemplo também configura o uso da memória para 100 MB.
```
{
"components": {
"aws.greengrass.Nucleus": {
"version": "2.16.1",
"configurationUpdate": {
"merge": "{\"runWithDefault\":{\"systemResourceLimits\":\"cpus\":2,\"memory\":102400}}}"
}
}
}
}
```
## Conectar-se à porta 443 ou por meio de um proxy de rede
AWS IoT Greengrass os dispositivos principais se comunicam AWS IoT Core usando o protocolo de mensagens MQTT com autenticação de cliente TLS. Por convenção, o MQTT sobre TLS usa a porta 8883. No entanto, como uma medida de segurança, ambientes restritivos podem limitar o tráfego de entrada e saída a um pequeno intervalo de portas TCP. Por exemplo, um firewall corporativo pode abrir a porta 443 para o tráfego HTTPS, mas fechar outras portas que são usadas por protocolos menos comuns, como a porta 8883 para tráfego MQTT. Outros ambientes restritivos podem exigir que todo o tráfego passe por um proxy antes de se conectar à Internet.
**nota**
Os principais dispositivos do Greengrass que executam o [componente Greengrass nucleus](greengrass-nucleus-component.md) v2.0.3 e versões anteriores usam a porta 8443 para se conectar ao endpoint do plano de dados. AWS IoT Greengrass Esses dispositivos devem ser capazes de se conectar a esse endpoint na porta 8443. Para obter mais informações, consulte [Permitir o tráfego de dispositivos por meio de um proxy ou firewall](allow-device-traffic.md).
Para habilitar a comunicação nesses cenários, AWS IoT Greengrass fornece as seguintes opções de configuração:
+ **Comunicação MQTT pela porta 443**. Se a rede permitir conexões com a porta 443, será possível configurar o dispositivo principal do Greengrass para usar a porta 443 para tráfego MQTT em vez da porta 8883 padrão. Isso pode ser uma conexão direta com a porta 443 ou uma conexão por meio de um servidor de proxy de rede. Diferentemente da configuração padrão, que usa autenticação de cliente baseada em certificado, o MQTT na porta 443 usa o [perfil de serviço do dispositivo](device-service-role.md) para autenticação.
Para obter mais informações, consulte [Configurar o MQTT na porta 443](#configure-mqtt-port-443).
+ **Comunicação HTTPS pela porta 443**. O software AWS IoT Greengrass Core envia tráfego HTTPS pela porta 8443 por padrão, mas você pode configurá-lo para usar a porta 443. AWS IoT Greengrass usa a extensão TLS da [Application Layer Protocol Network](https://tools.ietf.org/html/rfc7301) (ALPN) para habilitar essa conexão. Assim como na configuração padrão, o HTTPS na porta 443 usa autenticação de cliente baseada em certificado.
**Importante**
Para usar o ALPN e habilitar a comunicação HTTPS pela porta 443, seu dispositivo principal deve executar a atualização 252 ou posterior do Java 8. Todas as atualizações do Java versão 9 e posteriores também oferecem suporte ao ALPN.
Para obter mais informações, consulte [Configurar o HTTPS na porta 443](#configure-https-port-443).
+ **Conexão por meio de um proxy de rede**. É possível configurar um servidor proxy de rede para atuar como intermediário para conexão ao dispositivo principal do Greengrass. O AWS IoT Greengrass é compatível com a autenticação básica para proxies HTTP e HTTPS.
Os dispositivos do Greengrass nucleus devem executar o [Greengrass nucleus](greengrass-nucleus-component.md) v2.5.0 ou posterior para usar proxies HTTPS.
O software AWS IoT Greengrass principal passa a configuração do proxy para os componentes por meio das variáveis de `NO_PROXY` ambiente `ALL_PROXY` `HTTP_PROXY``HTTPS_PROXY`,,, e. Os componentes devem usar essas configurações para conectarem-se pelo proxy. Os componentes usam bibliotecas comuns (como boto3, cURL e o pacote `requests` do python) que normalmente usam essas variáveis de ambiente por padrão para fazer conexões. Se um componente também especifica essas variáveis de ambiente, o AWS IoT Greengrass não as substitui.
Para obter mais informações, consulte [Configurar uma proxy de rede](#configure-network-proxy).
### Configurar o MQTT na porta 443
É possível configurar o MQTT pela porta 443 em dispositivos principais existentes ou ao instalar o software AWS IoT Greengrass Core em um novo dispositivo principal.
**Topics**
+ [Configurar o MQTT pela porta 443 em dispositivos principais existentes](#configure-mqtt-port-443-deployment)
+ [Configurar o MQTT pela porta 443 durante a instalação](#configure-mqtt-port-443-installer)
#### Configurar o MQTT pela porta 443 em dispositivos principais existentes
É possível usar uma implantação para configurar o MQTT pela porta 443 em um dispositivo principal único ou em um grupo de dispositivos principais. Nessa implantação, você atualiza a configuração do [componente do núcleo](greengrass-nucleus-component.md). O núcleo reinicia quando você atualiza a configuração `mqtt` dele.
Para configurar o MQTT na porta 443, [crie uma implantação](create-deployments.md) que especifique a seguinte atualização de configuração para o componente `aws.greengrass.Nucleus`.
```
{
"mqtt": {
"port": 443
}
}
```
O exemplo a seguir define uma implantação que configura o MQTT na porta 443. A atualização da configuração `merge` requer um objeto JSON serializado.
```
{
"components": {
"aws.greengrass.Nucleus": {
"version": "2.16.1",
"configurationUpdate": {
"merge": "{\"mqtt\":{\"port\":443}}"
}
}
}
}
```
#### Configurar o MQTT pela porta 443 durante a instalação
Você pode configurar o MQTT pela porta 443 ao instalar o software AWS IoT Greengrass Core em um dispositivo principal. Use o argumento do instalador `--init-config` para configurar o MQTT pela porta 443. É possível especificar esse argumento ao instalar com [provisionamento manual](manual-installation.md), [provisionamento de frota](fleet-provisioning.md) ou [provisionamento personalizado](custom-provisioning.md).
### Configurar o HTTPS na porta 443
Esse atributo exige o [Greengrass nucleus](greengrass-nucleus-component.md) v2.0.4 ou posterior.
É possível configurar o HTTPS pela porta 443 em dispositivos principais existentes ou ao instalar o software AWS IoT Greengrass Core em um novo dispositivo principal.
**Topics**
+ [Configurar o HTTPS pela porta 443 em dispositivos principais existentes](#configure-https-port-443-deployment)
+ [Configurar o HTTPS pela porta 443 durante a instalação](#configure-https-port-443-installer)
#### Configurar o HTTPS pela porta 443 em dispositivos principais existentes
É possível usar uma implantação para configurar o HTTPS pela porta 443 em um dispositivo principal único ou em um grupo de dispositivos principais. Nessa implantação, você atualiza a configuração do [componente do núcleo](greengrass-nucleus-component.md).
Para configurar HTTPS pela porta 443, [crie uma implantação](create-deployments.md) que especifique a seguinte atualização de configuração para o componente `aws.greengrass.Nucleus`.
```
{
"greengrassDataPlanePort": 443
}
```
O exemplo a seguir define uma implantação que configura o HTTPS na porta 443. A atualização da configuração `merge` requer um objeto JSON serializado.
```
{
"components": {
"aws.greengrass.Nucleus": {
"version": "2.16.1",
"configurationUpdate": {
"merge": "{\"greengrassDataPlanePort\":443}"
}
}
}
}
```
#### Configurar o HTTPS pela porta 443 durante a instalação
Você pode configurar HTTPS pela porta 443 ao instalar o software AWS IoT Greengrass Core em um dispositivo principal. Use o argumento do instalador `--init-config` para configurar o HTTPS pela porta 443. É possível especificar esse argumento ao instalar com [provisionamento manual](manual-installation.md), [provisionamento de frota](fleet-provisioning.md) ou [provisionamento personalizado](custom-provisioning.md).
### Configurar uma proxy de rede
Siga o procedimento nesta seção para configurar os dispositivos principais do Greengrass para se conectarem à Internet por meio de um proxy de rede HTTP ou HTTPS. Para mais informações sobre os endpoints e portas usados pelos dispositivos principais, consulte [Permitir o tráfego de dispositivos por meio de um proxy ou firewall](allow-device-traffic.md).
**Importante**
Se o seu dispositivo principal executa uma versão do [Greengrass nucleus](greengrass-nucleus-component.md) anterior à v2.4.0, o perfil do seu dispositivo deve permitir o seguinte para usar um proxy de rede:
`iot:Connect`
`iot:Publish`
`iot:Receive`
`iot:Subscribe`
Isso é necessário porque o dispositivo usa AWS credenciais do serviço de troca de tokens para autenticar as conexões MQTT com. AWS IoT O dispositivo usa o MQTT para receber e instalar implantações do Nuvem AWS, portanto, seu dispositivo não funcionará a menos que você defina essas permissões em sua função. Os dispositivos normalmente usam certificados X.509 para autenticar conexões MQTT, mas os dispositivos não podem fazer isso para se autenticar quando usam um proxy.
Para mais informações sobre como configurar os perfis do dispositivo, consulte [Autorize os dispositivos principais a interagir com os serviços AWS](device-service-role.md).
**Topics**
+ [Configurar um proxy de rede nos dispositivos principais existentes](#configure-network-proxy-deployment)
+ [Configurar um proxy de rede durante a instalação](#configure-network-proxy-installer)
+ [Ative o dispositivo principal para confiar em um proxy HTTPS](#https-proxy-certificate-trust)
+ [O objeto networkProxy](#network-proxy-object)
#### Configurar um proxy de rede nos dispositivos principais existentes
É possível usar uma implantação para configurar um proxy de rede em um único dispositivo principal ou em um grupo de dispositivos principais. Nessa implantação, você atualiza a configuração do [componente do núcleo](greengrass-nucleus-component.md). O núcleo reinicia quando você atualiza a configuração `networkProxy` dele.
Para configurar um proxy de rede, [crie uma implantação](create-deployments.md) para o componente `aws.greengrass.Nucleus` que mescla a seguinte atualização de configuração. Essa atualização de configuração contém o [objeto NetworkProxy](#network-proxy-object).
```
{
"networkProxy": {
"noProxyAddresses": "http://192.168.0.1,www.example.com",
"proxy": {
"url": "https://my-proxy-server:1100"
}
}
}
```
O exemplo a seguir define uma implantação que configura o proxy de rede. A atualização da configuração `merge` requer um objeto JSON serializado.
```
{
"components": {
"aws.greengrass.Nucleus": {
"version": "2.16.1",
"configurationUpdate": {
"merge": "{\"networkProxy\":{\"noProxyAddresses\":\"http://192.168.0.1,www.example.com\",\"proxy\":{\"url\":\"https://my-proxy-server:1100\",\"username\":\"Mary_Major\",\"password\":\"pass@word1357\"}}}"
}
}
}
}
```
#### Configurar um proxy de rede durante a instalação
Você pode configurar um proxy de rede ao instalar o software AWS IoT Greengrass Core em um dispositivo principal. Use o argumento do instalador `--init-config` para configurar o proxy de rede. É possível especificar esse argumento ao instalar com [provisionamento manual](manual-installation.md), [provisionamento de frota](fleet-provisioning.md) ou [provisionamento personalizado](custom-provisioning.md).
#### Ative o dispositivo principal para confiar em um proxy HTTPS
Ao configurar um dispositivo principal para usar um proxy HTTPS, é necessário adicionar a cadeia de certificados do servidor proxy à do dispositivo principal para permitir que ele confie no proxy HTTPS. Caso contrário, o dispositivo poderá encontrar erros ao tentar rotear o tráfego por meio do proxy. Adicione o certificado CA do servidor proxy ao arquivo de certificado CA raiz da Amazon do dispositivo principal.
**Para ativar o dispositivo principal para confiar em um proxy HTTPS**
1. Encontre o arquivo de certificado CA raiz da Amazon no dispositivo principal.
+ Se você instalou o software AWS IoT Greengrass Core com [provisionamento automático, o](quick-installation.md) arquivo de certificado CA raiz da Amazon existe em. `/greengrass/v2/rootCA.pem`
+ Se você instalou o software AWS IoT Greengrass Core com [provisionamento [manual](manual-installation.md) ou de frota, o](fleet-provisioning.md) arquivo de certificado CA raiz da Amazon pode existir em. `/greengrass/v2/AmazonRootCA1.pem`
Se o certificado CA raiz da Amazon não existir nesses locais, verifique a propriedade `system.rootCaPath` em `/greengrass/v2/config/effectiveConfig.yaml` para encontrar a localização.
1. Adicione o conteúdo do arquivo de certificado de CA do servidor proxy ao arquivo de certificado de CA raiz da Amazon.
O exemplo a seguir mostra um certificado de CA do servidor de proxy adicionado ao arquivo de certificado de CA raiz da Amazon.
```
-----BEGIN CERTIFICATE-----
MIIEFTCCAv2gAwIQWgIVAMHSAzWG/5YVRYtRQOxXUTEpHuEmApzGCSqGSIb3DQEK
\nCwUAhuL9MQswCQwJVUzEPMAVUzEYMBYGA1UECgwP1hem9uLmNvbSBJbmMuMRww
... content of proxy CA certificate ...
+vHIRlt0e5JAm5\noTIZGoFbK82A0/nO7f/t5PSIDAim9V3Gc3pSXxCCAQoFYnui
GaPUlGk1gCE84a0X\n7Rp/lND/PuMZ/s8YjlkY2NmYmNjMCAXDTE5MTEyN2cM216
gJMIADggEPADf2/m45hzEXAMPLE=
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
MIIDQTCCAimgF6AwIBAgITBmyfz/5mjAo54vB4ikPmljZKyjANJmApzyMZFo6qBg
ADA5MQswCQYDVQQGEwJVUzEPMA0tMVT8QtPHRh8jrdkGA1UEChMGDV3QQDExBBKW
... content of root CA certificate ...
o/ufQJQWUCyziar1hem9uMRkwFwYVPSHCb2XV4cdFyQzR1KldZwgJcIQ6XUDgHaa
5MsI+yMRQ+hDaXJiobldXgjUka642M4UwtBV8oK2xJNDd2ZhwLnoQdeXeGADKkpy
rqXRfKoQnoZsG4q5WTP46EXAMPLE
-----END CERTIFICATE-----
```
#### O objeto networkProxy
Use o objeto `networkProxy` para especificar informações sobre o proxy de rede. Esse objeto contém as informações a seguir:
`noProxyAddresses`
(Opcional) Uma lista separada por vírgulas de endereços IP ou nomes de host isentos do proxy.
`proxy`
O proxy para se conectar. Esse objeto contém as informações a seguir:
`url`
O URL do servidor de proxy, no formato `scheme://userinfo@host:port`.
+ `scheme`: o esquema, que deve ser `http` ou `https`.
**Importante**
Os dispositivos do Greengrass nucleus devem executar o [Greengrass nucleus](greengrass-nucleus-component.md) v2.5.0 ou posterior para usar proxies HTTPS.
Se você configurar um proxy HTTPS, deverá adicionar o certificado de CA do servidor proxy ao certificado de CA raiz da Amazon do dispositivo principal. Para obter mais informações, consulte [Ative o dispositivo principal para confiar em um proxy HTTPS](#https-proxy-certificate-trust).
+ `userinfo`: (opcional) as informações de nome de usuário e senha. Se você especificar essas informações no `url`, o dispositivo principal do Greengrass ignorará os campos `username` e `password`.
+ `host`: o nome do host ou endereço IP do servidor de proxy.
+ `port`: (opcional) o número da porta. Se você não especifica a porta, o dispositivo principal do Greengrass usa os seguintes valores padrão:
+ `http`: 80
+ `https`: 443
`username`
(Opcional) O nome de usuário que autentica o servidor de proxy.
`password`
(Opcional) A senha que autentica o servidor de proxy.
## Usar um certificado de dispositivo assinado por uma CA privada
Se você estiver usando uma autoridade de certificação (CA) privada personalizada, é necessário definir o Greengrass nucleus **greengrassDataPlaneEndpoint** como **iotdata**. É possível definir essa opção durante a implantação ou instalação usando o [argumento do instalador](configure-installer.md) **--init-config**.
É possível personalizar o endpoint do plano de dados do Greengrass ao qual o dispositivo se conecta. É possível definir essa opção de configuração para **iotdata** para definir o endpoint do plano de dados do Greengrass como o mesmo endpoint de dados de IoT, que pode ser especificado com **iotDataEndpoint**.
## Definir os tempos limite do MQTT e as configurações de cache
No AWS IoT Greengrass ambiente, os componentes podem usar o MQTT para se comunicar com AWS IoT Core eles. O software AWS IoT Greengrass Core gerencia mensagens MQTT para componentes. Quando o dispositivo principal perde a conexão com a Nuvem AWS, o software armazena em cache as mensagens MQTT para tentar novamente mais tarde, quando a conexão for restaurada. É possível definir configurações como o tempo limite das mensagens e o tamanho do cache. Para mais informações, consulte os parâmetros de configuração `mqtt`e `mqtt.spooler` do [componente do Greengrass nucleus](greengrass-nucleus-component.md).
AWS IoT Core impõe cotas de serviço em seu agente de mensagens MQTT. Essas cotas podem se aplicar às mensagens que você envia entre os dispositivos principais e o AWS IoT Core. Para mais informações, consulte [cotas de serviço do agente de mensagens do AWS IoT Core](https://docs.aws.amazon.com/general/latest/gr/iot-core.html#message-broker-limits) em *Referência geral da AWS*.
## Configurar o Greengrass Nucleus na rede IPv6
[O Greengrass Nucleus conversa com o Greengrass por meio do AWS IoT Core Greengrass. APIs](https://docs.aws.amazon.com/general/latest/gr/greengrassv2.html) APIs Suporte ao Greengrass em ambiente IPv6 dualstack.
Para habilitar endpoints de pilha dupla para: IPv6
+ Adicione as propriedades do sistema `aws.useDualstackEndpoint=true`, `java.net.preferIPv6Addresses=true` e `jvmOptions`
+ Defina `s3EndpointType` como `DUALSTACK`
Defina essa opção durante a [implantação](https://docs.aws.amazon.com/greengrass/v2/developerguide/create-deployments.html) ou provisione-a manualmente com o [argumento do instalador](https://docs.aws.amazon.com/greengrass/v2/developerguide/configure-installer.html) `--init-config`. Consulte [Uso de endpoints de pilha dupla do Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/API/dual-stack-endpoints.html) para obter mais detalhes.
**Example código para implantação:**
```
{
"jvmOptions": "-Daws.useDualstackEndpoint=true",
"s3EndpointType":"DUALSTACK"
}
```
**Example `config.yaml` por meio do provisionamento manual:**
```
---
system:
...
services:
aws.greengrass.Nucleus:
...
configuration:
...
jvmOptions: "-Daws.useDualstackEndpoint=true -Djava.net.preferIPv6Addresses=true"
s3EndpointType: "DUALSTACK"
```
# Atualizar o software de núcleo do AWS IoT Greengrass (OTA)
O software de núcleo do AWS IoT Greengrass engloba o [componente de núcleo do Greengrass](greengrass-nucleus-component.md) e outros componentes opcionais que você pode implantar em seus dispositivos para executar atualizações sem fios (OTA) do software. Esse recurso está incorporado ao software de núcleo do AWS IoT Greengrass.
As atualizações OTA são mais eficientes para:
+ Corrigir vulnerabilidades de segurança.
+ Resolver problemas de estabilidade do software.
+ Implantar atributos novos ou melhorados.
**Topics**
+ [Requisitos](#ota-update-requirements)
+ [Considerações sobre dispositivos principais](#ota-update-considerations)
+ [Comportamento da atualização do núcleo do Greengrass](#ota-update-behavior-nucleus)
+ [Executar uma atualização OTA](#create-ota-update)
## Requisitos
Os seguintes requisitos se aplicam à implantação de atualizações OTA do software de núcleo do AWS IoT Greengrass.
+ O dispositivo principal do Greengrass deve ter conexão com a Nuvem AWS para receber a implantação.
+ O dispositivo principal do Greengrass deve ser configurado corretamente e provisionado com certificados e chaves para autenticação com o AWS IoT Core e o AWS IoT Greengrass.
+ O software de núcleo do AWS IoT Greengrass deve ser configurado e executado como um serviço do sistema. As atualizações OTA não funcionarão se você executar o núcleo do arquivo JAR, `Greengrass.jar`. Para obter mais informações, consulte [Configurar o Greengrass nucleus como um serviço do sistema](configure-greengrass-core-v2.md#configure-system-service).
## Considerações sobre dispositivos principais
Antes de executar uma atualização OTA, esteja ciente do impacto nos dispositivos principais que você atualiza e nos dispositivos cliente conectados:
+ O núcleo do Greengrass é encerrado.
+ Todos os componentes em execução no dispositivo principal também são encerrados. Se esses componentes gravarem em recursos locais, eles poderão deixá-los em um estado incorreto, a menos que sejam devidamente encerrados. Os componentes podem usar a [comunicação entre processos](interprocess-communication.md) para instruir o componente do núcleo a adiar a atualização até que eles limpem os recursos que usam.
+ Enquanto o componente do núcleo é encerrado, o dispositivo principal perde a conexão com a Nuvem AWS e os dispositivos locais. O dispositivo principal não roteará mensagens dos dispositivos cliente enquanto estiver sendo encerrado.
+ As funções do Lambda de longa duração executadas como componentes perdem as informações dinâmicas de estado e descartam todos os trabalhos pendentes.
## Comportamento da atualização do núcleo do Greengrass
Quando você implanta um componente, o AWS IoT Greengrass instala as versões compatíveis mais recentes de todas as dependências desse componente. Por esse motivo, novas versões de patch dos componentes públicos fornecidos pela AWS poderão ser implantadas automaticamente nos dispositivos principais se você adicionar novos dispositivos a um grupo de itens ou atualizar a implantação direcionada a esses dispositivos. Algumas atualizações automáticas, como a atualização do núcleo, podem fazer com que seus dispositivos sejam reiniciados inesperadamente.
Quando a versão do [componente de núcleo do Greengrass](greengrass-nucleus-component.md) muda, o software de núcleo do AWS IoT Greengrass, que inclui o núcleo e todos os outros componentes de seu dispositivo, é reiniciado para aplicar as alterações. Devido ao [impacto nos dispositivos principais](#ota-update-considerations) quando o componente de núcleo é atualizado, você talvez queira controlar quando uma nova versão do patch do núcleo é implantada nos dispositivos. Para isso, você deve incluir o componente de núcleo do Greengrass diretamente em sua implantação. Incluir um componente diretamente significa que você inclui uma versão específica dele na configuração de implantação e não recorre a dependências do componente para implantá-lo nos dispositivos. Para obter mais informações sobre como definir dependências em fórmulas de componentes, consulte [Formato da fórmula](component-recipe-reference.md#recipe-format).
Consulte a tabela a seguir para entender o comportamento da atualização do componente de núcleo do Greengrass com base em suas ações e configurações de implantação.
| Ação | Configuração de implantação | Comportamento da atualização do núcleo |
| --- | --- | --- |
| Adicione novos dispositivos a um grupo de itens de destino de uma implantação existente sem revisar a implantação. | A implantação não inclui diretamente o núcleo do Greengrass.A implantação inclui diretamente pelo menos um componente fornecido pela AWS ou um componente personalizado que depende de um componente fornecido pela AWS ou do núcleo do Greengrass. | Em novos dispositivos, instala a versão de patch mais recente do núcleo que atende a todos os requisitos de dependência de componente.Em dispositivos existentes, não atualiza a versão instalada do núcleo. |
| Adicione novos dispositivos a um grupo de itens de destino de uma implantação existente sem revisar a implantação. | A implantação inclui diretamente uma versão específica do núcleo do Greengrass. | Em novos dispositivos, instala a versão do núcleo especificada.Em dispositivos existentes, não atualiza a versão instalada do núcleo. |
| Crie uma nova implantação ou revise uma existente. | A implantação não inclui diretamente o núcleo do Greengrass.A implantação inclui diretamente pelo menos um componente fornecido pela AWS ou um componente personalizado que depende de um componente fornecido pela AWS ou do núcleo do Greengrass. | Em todos os dispositivos de destino, instala a versão de patch mais recente do núcleo que atende a todos os requisitos de dependência de componente, inclusive em qualquer dispositivo novo que você adicionar ao grupo de itens de destino. |
| Crie uma nova implantação ou revise uma existente. | A implantação inclui diretamente uma versão específica do núcleo do Greengrass. | Em todos os dispositivos de destino, instala a versão do núcleo especificada, incluindo todos os dispositivos novos que você adicionar ao grupo de itens de destino. |
## Executar uma atualização OTA
Para executar uma atualização OTA, [crie uma implantação](create-deployments.md) que inclua o [componente de núcleo](greengrass-nucleus-component.md) e a versão que será instalada.
# Desinstalar o software de núcleo do AWS IoT Greengrass
Você pode desinstalar o software de núcleo do AWS IoT Greengrass para removê-lo de um dispositivo que você não deseja usar como dispositivo principal do Greengrass. Você também pode usar essas etapas para limpar uma instalação com falha.
**Para desinstalar o software de núcleo do AWS IoT Greengrass**
1. Se você executa o software como um serviço do sistema, deve interromper, desabilitar e remover o serviço. Execute os comandos abaixo conforme apropriado ao sistema operacional.
------
#### [ Linux ]
1. Interrompa o serviço .
```
sudo systemctl stop greengrass.service
```
1. Desabilite o serviço.
```
sudo systemctl disable greengrass.service
```
1. Remova o serviço.
```
sudo rm /etc/systemd/system/greengrass.service
```
1. Verifique se o serviço foi excluído.
```
sudo systemctl daemon-reload && sudo systemctl reset-failed
```
------
#### [ Windows (Command Prompt) ]
**nota**
Você deve executar o prompt de comando como administrador para executar esses comandos.
1. Interrompa o serviço .
```
sc stop "greengrass"
```
1. Desabilite o serviço.
```
sc config "greengrass" start=disabled
```
1. Remova o serviço.
```
sc delete "greengrass"
```
1. Reinicie o dispositivo.
------
#### [ Windows (PowerShell) ]
**nota**
Você deve executar o PowerShell como administrador para executar esses comandos.
1. Interrompa o serviço .
```
Stop-Service -Name "greengrass"
```
1. Desabilite o serviço.
```
Set-Service -Name "greengrass" -Status stopped -StartupType disabled
```
1. Remova o serviço.
+ Para o PowerShell 6.0 e posterior:
```
Remove-Service -Name "greengrass" -Confirm:$false -Verbose
```
+ Para versões do PowerShell anteriores à 6.0:
```
Get-Item HKLM:\SYSTEM\CurrentControlSet\Services\greengrass | Remove-Item -Force -Verbose
```
1. Reinicie o dispositivo.
------
1. Remova a pasta raiz do dispositivo. Substitua `/greengrass/v2` ou *C:\$1greengrass\$1v2* pelo caminho para a pasta raiz.
------
#### [ Linux ]
```
sudo rm -rf /greengrass/v2
```
------
#### [ Windows (Command Prompt) ]
```
rmdir /s /q C:\greengrass\v2
```
------
#### [ Windows (PowerShell) ]
```
cmd.exe /c "rmdir /s /q C:\greengrass\v2"
```
------
1. Exclua o dispositivo principal do serviço AWS IoT Greengrass. Essa etapa remove as informações de status do dispositivo principal da Nuvem AWS. Certifique-se de concluir essa etapa se você planeja reinstalar o software de núcleo do AWS IoT Greengrass em um dispositivo principal com o mesmo nome.
+ Para excluir um dispositivo principal do console do AWS IoT Greengrass, faça o seguinte:
1. Navegue até o [console do AWS IoT Greengrass](https://console.aws.amazon.com/greengrass).
1. Escolha **Dispositivos principais**.
1. Escolha o dispositivo principal que será excluído.
1. Escolha **Excluir**.
1. No modal de confirmação, escolha **Excluir**.
+ Para excluir um dispositivo principal com a AWS Command Line Interface, use a operação [DeleteCoreDevice](https://docs.aws.amazon.com/greengrass/v2/APIReference/API_DeleteCoreDevice.html). Execute o comando a seguir e substitua *MyGreengrassCore* pelo nome do dispositivo principal.
```
aws greengrassv2 delete-core-device --core-device-thing-name MyGreengrassCore
```