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á.
# 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"
```