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á.
# Etapa 2: configurar o ambiente
**nota**
Essas etapas não se aplicam ao nucleus lite.
Siga as etapas nesta seção para configurar um dispositivo Linux ou Windows para usar como dispositivo principal do AWS IoT Greengrass .
## Configurar um dispositivo Linux (Raspberry Pi)
Essas etapas pressupõem que você use um Raspberry Pi com o sistema operacional Raspberry Pi. Se você usar um dispositivo ou sistema operacional diferente, consulte a documentação relevante para seu dispositivo.
**Para configurar um Raspberry Pi para AWS IoT Greengrass V2**
1. Configure o SSH no seu Raspberry Pi para se conectar remotamente a ele. Para mais informações, consulte [SSH (Secure shell)](https://www.raspberrypi.com/documentation/computers/remote-access.html#ssh) na *documentação do Raspberry Pi*.
1. Encontre o endereço IP do seu Raspberry Pi para se conectar a ele com o SSH. Para fazer isso, execute o seguinte comando no seu Raspberry Pi.
```
hostname -I
```
1. Conecte-se ao seu Raspberry Pi com o SSH.
Execute o comando a seguir no computador de desenvolvimento. *username*Substitua pelo nome do usuário a ser conectado e *pi-ip-address* substitua pelo endereço IP que você encontrou na etapa anterior.
```
ssh username@pi-ip-address
```
**Importante**
Se seu computador de desenvolvimento usa uma versão anterior do Windows, talvez você não tenha o comando `ssh` ou tenha `ssh`, mas não consiga se conectar ao seu Raspberry Pi. Para se conectar ao seu Raspberry Pi, você pode instalar e configurar o [PuTTY](https://www.chiark.greenend.org.uk/~sgtatham/putty/latest.html), que é um cliente SSH gratuito e de código aberto. Consulte a [documentação do PuTTY](https://tartarus.org/~simon/putty-snapshots/htmldoc/Chapter2.html#gs) para se conectar ao seu Raspberry Pi.
1. Instale o Java Runtime, que o software AWS IoT Greengrass Core exige para ser executado. No seu Raspberry Pi, use os seguintes comandos para instalar o Java 11.
```
sudo apt install default-jdk
```
Quando a instalação estiver concluída, execute o seguinte comando para verificar se o Java é executado no seu Raspberry Pi.
```
java -version
```
O comando imprime a versão do Java que é executada no dispositivo. O resultado pode ser semelhante ao seguinte exemplo.
```
openjdk version "11.0.9.1" 2020-11-04
OpenJDK Runtime Environment (build 11.0.9.1+1-post-Debian-1deb10u2)
OpenJDK 64-Bit Server VM (build 11.0.9.1+1-post-Debian-1deb10u2, mixed mode)
```
**Dica: defina os parâmetros do kernel em um Raspberry Pi**
Se o seu dispositivo for um Raspberry Pi, será possível concluir as etapas a seguir para visualizar e atualizar os parâmetros do kernel Linux:
Abra o arquivo `/boot/cmdline.txt`. Esse arquivo especifica os parâmetros do kernel Linux a serem aplicados quando o Raspberry Pi for inicializado.
Por exemplo, em um sistema baseado em Linux, você pode executar o comando a seguir para usar o GNU nano para abrir o arquivo.
```
sudo nano /boot/cmdline.txt
```
Verifique se o arquivo `/boot/cmdline.txt` contém os parâmetros do kernel a seguir. O parâmetro `systemd.unified_cgroup_hierarchy=0` especifica o uso de cgroups v1 em vez de cgroups v2.
```
cgroup_enable=memory cgroup_memory=1 systemd.unified_cgroup_hierarchy=0
```
Se o arquivo `/boot/cmdline.txt` não contiver esses parâmetros ou contiver esses parâmetros com valores diferentes, atualize o arquivo para conter esses parâmetros e valores.
Se você atualizou o arquivo `/boot/cmdline.txt`, reinicie o Raspberry Pi para aplicar as alterações.
```
sudo reboot
```
## Configurar um dispositivo Linux (outro)
**Para configurar um dispositivo Linux para AWS IoT Greengrass V2**
1. Instale o Java Runtime, que o software AWS IoT Greengrass Core exige para ser executado. Recomendamos que você use as versões de suporte de longo prazo do [Amazon Corretto](https://aws.amazon.com/corretto/) ou do [OpenJDK](https://openjdk.java.net/). A versão 8 ou superior é obrigatória. Os seguintes comandos mostram como instalar o OpenJDK no dispositivo.
+ Para distribuições com base em Debian ou em Ubuntu:
```
sudo apt install default-jdk
```
+ Para distribuições com base em Red Hat:
```
sudo yum install java-11-openjdk-devel
```
+ Para Amazon Linux 2:
```
sudo amazon-linux-extras install java-openjdk11
```
+ Para Amazon Linux 2023:
```
sudo dnf install java-11-amazon-corretto -y
```
Quando a instalação for concluída, execute o seguinte comando para verificar se o Java é executado no dispositivo Linux.
```
java -version
```
O comando imprime a versão do Java que é executada no dispositivo. Por exemplo, em uma distribuição baseada em Debian, o resultado pode ser semelhante ao seguinte exemplo.
```
openjdk version "11.0.9.1" 2020-11-04
OpenJDK Runtime Environment (build 11.0.9.1+1-post-Debian-1deb10u2)
OpenJDK 64-Bit Server VM (build 11.0.9.1+1-post-Debian-1deb10u2, mixed mode)
```
1. (Opcional) Crie o usuário e o grupo padrão do sistema que executa componentes no dispositivo. Você também pode optar por permitir que o instalador do software AWS IoT Greengrass Core crie esse usuário e grupo durante a instalação com o argumento do `--component-default-user` instalador. Para obter mais informações, consulte [Argumentos de instalação](configure-installer.md).
```
sudo useradd --system --create-home ggc_user
sudo groupadd --system ggc_group
```
1. Verifique se o usuário que executa o software AWS IoT Greengrass Core (normalmente`root`) tem permissão para executar `sudo` com qualquer usuário e qualquer grupo.
1. Execute o seguinte comando para abrir o arquivo `/etc/sudoers`.
```
sudo visudo
```
1. Verifique se a permissão do usuário se parece com o seguinte exemplo.
```
root ALL=(ALL:ALL) ALL
```
1. (Opcional) Para [executar funções do Lambda em contêineres](run-lambda-functions.md), habilite [cgroups](https://en.wikipedia.org/wiki/Cgroups) v1 e habilite e monte os cgroups de *memória* e *dispositivos*. Se você não planeja executar funções do Lambda em contêineres, ignore esta etapa.
Para habilitar essas opções de cgroups, inicialize o dispositivo com os seguintes parâmetros do kernel do Linux.
```
cgroup_enable=memory cgroup_memory=1 systemd.unified_cgroup_hierarchy=0
```
Para mais informações sobre como visualizar e definir parâmetros do kernel para o dispositivo, consulte a documentação do sistema operacional e do carregador de inicialização. Siga as instruções para definir permanentemente os parâmetros do kernel.
1. Instale todas as outras dependências necessárias no dispositivo, conforme indicado na lista de requisitos em [Requisitos do dispositivo](greengrass-nucleus-component.md#greengrass-v2-requirements).
## Configurar um dispositivo Windows
**Para configurar um dispositivo Windows para AWS IoT Greengrass V2**
1. Instale o Java Runtime, que o software AWS IoT Greengrass Core exige para ser executado. Recomendamos que você use as versões de suporte de longo prazo do [Amazon Corretto](https://aws.amazon.com/corretto/) ou do [OpenJDK](https://openjdk.java.net/). A versão 8 ou superior é obrigatória.
1. Verifique se o Java está disponível na variável de sistema [PATH](https://en.wikipedia.org/wiki/PATH_(variable)) e, caso contrário, adicione. A LocalSystem conta executa o software AWS IoT Greengrass Core, então você deve adicionar Java à variável de sistema PATH em vez da variável de usuário PATH para seu usuário. Faça o seguinte:
1. Pressione a tecla Windows para abrir o menu Iniciar.
1. Digite **environment variables** para pesquisar as opções do sistema no menu Iniciar.
1. Nos resultados da pesquisa do menu Iniciar, escolha **Editar as variáveis de ambiente do sistema** para abrir a janela **Propriedades do sistema**.
1. Escolha **Variáveis de ambiente...** para abrir a janela **Variáveis de ambiente**.
1. Em **Variáveis de Sistema**, selecione a variável **Path** e em seguida **Editar**. Na janela **Editar variável de ambiente**, você visualiza cada caminho em uma linha separada.
1. Verifique se o caminho para a pasta `bin` da instalação do Java está presente. O arquivo pode ser semelhante ao seguinte exemplo.
```
C:\\Program Files\\Amazon Corretto\\jdk11.0.13_8\\bin
```
1. Se a pasta `bin` da instalação do Java estiver ausente do **Path**, selecione **Novo** para adicioná-la e, em seguida, selecione **OK**.
1. Abra o prompt de comando do Windows (`cmd.exe`) como um administrador.
1. Crie o usuário padrão na LocalSystem conta no dispositivo Windows. *password*Substitua por uma senha segura.
```
net user /add ggc_user password
```
**dica**
Dependendo da configuração do Windows, a senha do usuário pode ser definida para expirar em uma data futura. Para garantir que as aplicações Greengrass continuem operando, monitore quando a senha expira e atualize-a antes disso. Também é possível definir que a senha nunca expire.
Para verificar quando um usuário e senha expiram, execute o comando a seguir.
```
net user ggc_user | findstr /C:expires
```
Para definir que a senha de um usuário nunca expire, execute o seguinte comando.
```
wmic UserAccount where "Name='ggc_user'" set PasswordExpires=False
```
Se você estiver usando o Windows 10 ou posterior, onde o [`wmic`comando está obsoleto](https://learn.microsoft.com/en-us/windows/win32/wmisdk/wmic), execute o comando a seguir. PowerShell
```
Get-CimInstance -Query "SELECT * from Win32_UserAccount WHERE name = 'ggc_user'" | Set-CimInstance -Property @{PasswordExpires="False"}
```
1. Baixe e instale o [PsExecutilitário](https://docs.microsoft.com/en-us/sysinternals/downloads/psexec) da Microsoft no dispositivo.
1. Use o PsExec utilitário para armazenar o nome de usuário e a senha do usuário padrão na instância do Credential Manager da LocalSystem conta. *password*Substitua pela senha do usuário que você definiu anteriormente.
```
psexec -s cmd /c cmdkey /generic:ggc_user /user:ggc_user /pass:password
```
Se **PsExec License Agreement** abrir, selecione **Accept** para concordar com a licença e execute o comando.
**nota**
Em dispositivos Windows, a LocalSystem conta executa o núcleo Greengrass, e você deve usar o PsExec utilitário para armazenar as informações padrão do usuário na conta. LocalSystem O uso do aplicativo Credential Manager armazena essas informações na conta do Windows do usuário atualmente conectado, em vez da LocalSystem conta.