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á.
# 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 para o [Greengrass nucleus](greengrass-nucleus-component.md) 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 com núcleo [Greengrass](greengrass-nucleus-component.md)[, instale AWS IoT Greengrass o software Core](manual-installation.md) com provisionamento manual. O [Greengrass nucleus lite](greengrass-nucleus-lite-component.md) v2.5.0 e versões posteriores oferecem suporte nativo ao TPM com provisionamento de frota.
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.17.0"
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.17.0"
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.17.0*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.17.0"
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.17.0"
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)
+ [Desenvolva AWS IoT Greengrass componentes](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. |