Aviso de fim do suporte: em 7 de outubro de 2026, AWS o suporte para o. AWS IoT Greengrass Version 1 Depois de 7 de outubro de 2026, você não poderá mais acessar os AWS IoT Greengrass V1 recursos. Para obter mais informações, visite [Migrar de AWS IoT Greengrass Version 1](https://docs.aws.amazon.com/greengrass/v2/developerguide/migrate-from-v1.html).
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 AWS IoT Greengrass núcleo
Um AWS IoT Greengrass núcleo é uma AWS IoT coisa (dispositivo) que atua como um hub ou gateway em ambientes periféricos. Como outros AWS IoT dispositivos, existe um núcleo no registro, tem uma sombra de dispositivo e usa um certificado de dispositivo para se autenticar com AWS IoT Core e. AWS IoT Greengrass O dispositivo de núcleo executa o software de núcleo do AWS IoT Greengrass , que o permite gerenciar processos locais para grupos do Greengrass, como comunicação, sincronização de shadow e troca de tokens.
O software AWS IoT Greengrass Core fornece as seguintes funcionalidades:
+ Implantação e execução local de conectores e funções do Lambda.
+ Processe fluxos de dados localmente com exportações automáticas para o. Nuvem AWS
+ Mensagens MQTT pela rede local entre dispositivos, conectores e funções do Lambda usando assinaturas gerenciadas.
+ Mensagens MQTT entre dispositivos, conectores AWS IoT e funções Lambda usando assinaturas gerenciadas.
+ Conexões seguras entre dispositivos e o Nuvem AWS uso da autenticação e autorização do dispositivo.
+ Sincronização da shadow local de dispositivos. As shadows podem ser configuradas para serem sincronizadas com a Nuvem AWS.
+ Acesso controlado ao dispositivo local e recursos de volume.
+ Implantação de modelos de machine learning treinados em nuvem para executar inferência local.
+ Detecção automática de endereço IP que permite aos dispositivos descobrirem o dispositivo de núcleo do Greengrass.
+ Implantação central de configuração de grupo nova ou atualizada. Depois que os dados de configuração forem obtidos por download, o dispositivo de núcleo será reiniciado automaticamente.
+ Atualizações de software seguras over-the-air (OTA) de funções Lambda definidas pelo usuário.
+ Armazenamento criptografado e seguro de segredos locais e acesso controlado por conectores e funções do Lambda.
## AWS IoT Greengrass arquivo de configuração principal
O arquivo de configuração do software AWS IoT Greengrass Core é`config.json`. É possível encontrá-lo no diretório `/greengrass-root/config`.
**nota**
*greengrass-root*representa o caminho em que o software AWS IoT Greengrass Core está instalado em seu dispositivo. Normalmente, esse é o diretório `/greengrass`.
Se você usar a opção de **criação de grupo padrão** do AWS IoT Greengrass console, o `config.json` arquivo será implantado no dispositivo principal em um estado de funcionamento.
Você pode examinar o conteúdo desse arquivo executando o seguinte comando:
```
cat /greengrass-root/config/config.json
```
Veja a seguir um exemplo de arquivo `config.json`. Essa é a versão gerada quando você cria o núcleo a partir do AWS IoT Greengrass console.
------
#### [ GGC v1.11 ]
```
{
"coreThing": {
"caPath": "root.ca.pem",
"certPath": "hash.cert.pem",
"keyPath": "hash.private.key",
"thingArn": "arn:partition:iot:region:account-id:thing/core-thing-name",
"iotHost": "host-prefix-ats.iot.region.amazonaws.com",
"ggHost": "greengrass-ats.iot.region.amazonaws.com",
"keepAlive": 600,
"ggDaemonPort": 8000,
"systemComponentAuthTimeout": 5000
},
"runtime": {
"maxWorkItemCount": 1024,
"maxConcurrentLimit": 25,
"lruSize": 25,
"mountAllBlockDevices": "no",
"cgroup": {
"useSystemd": "yes"
}
},
"managedRespawn": false,
"crypto": {
"principals": {
"SecretsManager": {
"privateKeyPath": "file:///greengrass/certs/hash.private.key"
},
"IoTCertificate": {
"privateKeyPath": "file:///greengrass/certs/hash.private.key",
"certificatePath": "file:///greengrass/certs/hash.cert.pem"
}
},
"caPath": "file:///greengrass/certs/root.ca.pem"
},
"writeDirectory": "/var/snap/aws-iot-greengrass/current/ggc-write-directory",
"pidFileDirectory": "/var/snap/aws-iot-greengrass/current/pidFileDirectory"
}
```
O arquivo `config.json` é compatível com as seguintes propriedades:
**coreThing**
| Campo | Description | Observações |
| --- | --- | --- |
| caPath | O caminho para a CA AWS IoT raiz em relação ao `/greengrass-root/certs` diretório. | Para compatibilidade retroativa com versões anteriores à 1.7.0. Essa propriedade é ignorada quando o objeto `crypto` está presente. Certifique-se de que os [endpoints correspondem ao seu tipo de certificado](#certificate-endpoints). |
| certPath | O caminho para o certificado de dispositivo de núcleo relativo ao diretório `/greengrass-root/certs`. | Para compatibilidade retroativa com versões anteriores à 1.7.0. Essa propriedade é ignorada quando o objeto crypto está presente. |
| keyPath | O caminho para a chave privada do núcleo relativo ao diretório /greengrass-root/certs. | Para compatibilidade retroativa com versões anteriores à 1.7.0. Essa propriedade é ignorada quando o objeto crypto está presente. |
| thingArn | O Amazon Resource Name (ARN) da AWS IoT coisa que representa o dispositivo AWS IoT Greengrass principal. | Encontre o ARN do seu núcleo no AWS IoT Greengrass console, em Cores, ou executando o comando CLI [https://docs.aws.amazon.com/cli/latest/reference/greengrass/get-core-definition-version.html](https://docs.aws.amazon.com/cli/latest/reference/greengrass/get-core-definition-version.html). |
| iotHost | Seu AWS IoT endpoint. | Encontre o endpoint no AWS IoT console em **Configurações** ou executando o comando [https://docs.aws.amazon.com/cli/latest/reference/iot/describe-endpoint.html](https://docs.aws.amazon.com/cli/latest/reference/iot/describe-endpoint.html)CLI. Este comando retorna o endpoint do Amazon Trust Services (ATS). Para obter mais informações, consulte a documentação de [Autenticação do servidor](https://docs.aws.amazon.com/iot/latest/developerguide/server-authentication.html). Certifique-se de que os [endpoints correspondem ao seu tipo de certificado](#certificate-endpoints). Verifique se os [endpoints correspondem à sua Região da AWS](https://docs.aws.amazon.com/general/latest/gr/greengrass.html). |
| ggHost | Seu AWS IoT Greengrass endpoint. | Este é o seu endpoint `iotHost` com o prefixo do host substituído pelo *greengrass* (por exemplo, `greengrass-ats.iot.region.amazonaws.com`). Use o mesmo Região da AWS que`iotHost`. Certifique-se de que os [endpoints correspondem ao seu tipo de certificado](#certificate-endpoints). Verifique se os [endpoints correspondem à sua Região da AWS](https://docs.aws.amazon.com/general/latest/gr/greengrass.html). |
| iotMqttPort | Opcional. O número da porta a ser usada para comunicação com AWS IoT o MQTT. | Os valores válidos são 8883 ou 443. O valor padrão é 8883. Para obter mais informações, consulte [Conectar-se à porta 443 ou por meio de um proxy de rede](#alpn-network-proxy). |
| iotHttpPort | Opcional. O número da porta usada para criar as conexões HTTPS para AWS IoT. | Os valores válidos são 8443 ou 443. O valor padrão é 8443. Para obter mais informações, consulte [Conectar-se à porta 443 ou por meio de um proxy de rede](#alpn-network-proxy). |
| ggMqttPort | Opcional. O número da porta a ser usada para comunicação MQTT pela rede local. | Os valores válidos vão de 1024 a 65535. O valor padrão é 8883. Para obter mais informações, consulte [Configurar a porta MQTT para mensagens locais](#config-local-mqtt-port). |
| ggHttpPort | Opcional. O número da porta usada para criar as conexões HTTPS para o serviço AWS IoT Greengrass . | Os valores válidos são 8443 ou 443. O valor padrão é 8443. Para obter mais informações, consulte [Conectar-se à porta 443 ou por meio de um proxy de rede](#alpn-network-proxy). |
| keepAlive | Opcional. O período KeepAlive do MQTT, em segundos. | O intervalo válido é entre 30 e 1200. O valor padrão é 600. |
| networkProxy | Opcional. Um objeto que define um servidor de proxy para se conectar. | O servidor proxy pode ser HTTP ou HTTPS. Para obter mais informações, consulte [Conectar-se à porta 443 ou por meio de um proxy de rede](#alpn-network-proxy). |
| mqttOperationTimeout | Opcional. A quantidade de tempo (em segundos) para permitir que o núcleo do Greengrass conclua uma operação de publicação, assinatura ou cancelamento de assinatura em conexões MQTT com o AWS IoT Core. | O valor padrão é 5. O valor mínimo é 5. |
| ggDaemonPort | Opcional. O número da porta IPC do núcleo do Greengrass. | Essa propriedade está disponível na AWS IoT Greengrass versão v1.11.0 ou posterior. Os valores válidos estão entre 1.024 e 65.535. O valor padrão é 8000. |
| systemComponentAuthTimeout | Opcional. O tempo (em milissegundos) para permitir que o IPC do núcleo do Greengrass conclua a autenticação. | Essa propriedade está disponível na AWS IoT Greengrass versão v1.11.0 ou posterior. Os valores válidos estão entre 500 e 5000. O valor padrão é 5000. |
**runtime**
| Campo | Description | Observações |
| --- |--- |--- |
| maxWorkItemCount | Opcional. O número máximo de itens de trabalho que o daemon do Greengrass pode processar por vez. As solicitações que excederem esse limite serão ignoradas. A fila de itens de trabalho é compartilhada por componentes do sistema, funções do Lambda definidas pelo usuário, e conectores. | O valor padrão é 1024. O valor máximo é limitado pelo hardware do dispositivo. Aumentar esse valor aumenta a memória AWS IoT Greengrass usada. Você pode aumentar esse valor caso espere que seu núcleo receba tráfego pesado de mensagens MQTT. |
| maxConcurrentLimit | Opcional. O número máximo de trabalhadores do Lambda não fixados simultâneos que o daemon do Greengrass pode ter. Você pode especificar um número inteiro diferente para substituir esse parâmetro. | O valor padrão é 25. O valor mínimo é definido por `lruSize`. |
| lruSize | Opcional. Define o valor mínimo paramaxConcurrentLimit. | O valor padrão é 25. |
| mountAllBlockDevices | Opcional. Permite AWS IoT Greengrass usar montagens de associação para montar todos os dispositivos de bloco em um contêiner após configurar o OverlayFS. | Essa propriedade está disponível na AWS IoT Greengrass versão v1.11.0 ou posterior. Os valores válidos são `yes` e `no`. O valor padrão é `no`. Defina esse valor como `yes` se seu diretório `/usr` não estiver sob a hierarquia `/`. |
| postStartHealthCheckTimeout | Opcional. O tempo (em milissegundos) que o daemon Greengrass aguarda a conclusão da verificação de integridade depois de iniciar. | O tempo limite padrão é de 30 segundos (30000 ms). |
| `cgroup` |
| --- |
| useSystemd | Indica se o dispositivo usa [https://en.wikipedia.org/wiki/Systemd](https://en.wikipedia.org/wiki/Systemd). | Os valores válidos são yes ou no. Execute o script check\$1ggc\$1dependencies no [Módulo 1](module1.md) para ver se o dispositivo usa systemd. |
**crypto**
A `crypto` apresenta propriedades que oferecem suporte ao armazenamento da chave privada em um módulo de segurança de hardware (HSM) por meio de PKCS\$111 e armazenamento local secreto. Para obter mais informações, consulte [AWS IoT Greengrass princípios básicos de segurança](gg-sec.md#gg-principals), [Integração de segurança de hardware](hardware-security.md) e [Implante segredos até o AWS IoT Greengrass âmago](secrets.md). As configurações para armazenamento de chaves privadas no sistema de arquivos HSMs ou no sistema de arquivos são suportadas.
| Campo | Description | Observações |
| --- |--- |--- |
| caPath | O caminho absoluto para a CA AWS IoT raiz. | Deve ser um URI de arquivo no formato: `file:///absolute/path/to/file`. Certifique-se de que os [endpoints correspondem ao seu tipo de certificado](#certificate-endpoints). |
| `PKCS11` |
| --- |
| OpenSSLEngine | Opcional. O caminho absoluto para o arquivo `.so` do mecanismo OpenSSL para habilitar o suporte PKCS\$111 no OpenSSL. | Deve ser um caminho para o arquivo no sistema de arquivos. Esta propriedade será necessária se você estiver usando o atendente de atualizações OTA do Greengrass com segurança de hardware. Para obter mais informações, consulte [Configurar suporte para over-the-air atualizações](hardware-security.md#hardware-security-ota-updates). |
| P11Provider | O caminho absoluto para a biblioteca carregável libdl da implementação PKCS\$111. | Deve ser um caminho para o arquivo no sistema de arquivos. |
| slotLabel | O rótulo de slot usado para identificar o módulo de hardware. | Deve estar em conformidade com as especificações de rótulo PKCS\$111. |
| slotUserPin | O PIN do usuário usado para autenticar o núcleo do Greengrass no módulo. | É necessário ter permissões suficientes para executar C\$1Sign com as chaves privadas configuradas. |
| `principals` |
| --- |
| IoTCertificate | O certificado e a chave privada que o núcleo usa para fazer solicitações à AWS IoT. |
| IoTCertificate .privateKeyPath | O caminho para a chave privada do núcleo. | Para o armazenamento do sistema de arquivos, deve ser um URI de arquivo no formato: `file:///absolute/path/to/file`. Para o armazenamento HSM, deve ser um caminho [RFC 7512 PKCS\$111](https://tools.ietf.org/html/rfc7512) que especifica o rótulo do objeto. |
| IoTCertificate .certificatePath | O caminho absoluto para o certificado do dispositivo do núcleo. | Deve ser um URI de arquivo no formato: `file:///absolute/path/to/file`. |
| MQTTServerCertificate | Opcional. A chave privada que o núcleo usa em combinação com o certificado para atuar como um gateway ou servidor MQTT. |
| MQTTServerCertificate .privateKeyPath | O caminho para a chave privada do servidor MQTT local. | Use esse valor para especificar sua própria chave privada para o servidor MQTT local. Para o armazenamento do sistema de arquivos, deve ser um URI de arquivo no formato: `file:///absolute/path/to/file`. Para o armazenamento HSM, deve ser um caminho [RFC 7512 PKCS\$111](https://tools.ietf.org/html/rfc7512) que especifica o rótulo do objeto. Se essa propriedade for omitida, AWS IoT Greengrass gira a chave com base nas suas configurações de rotação. Se especificado, o cliente será responsável por girar a chave. |
| SecretsManager | A chave privada que protege a chave de dados usada para criptografia. Para obter mais informações, consulte [Implante segredos até o AWS IoT Greengrass âmago](secrets.md). |
| SecretsManager .privateKeyPath | O caminho para a chave privada do secrets manager local. | Somente uma chave RSA é compatível. Para o armazenamento do sistema de arquivos, deve ser um URI de arquivo no formato: `file:///absolute/path/to/file`. Para o armazenamento HSM, deve ser um caminho [RFC 7512 PKCS\$111](https://tools.ietf.org/html/rfc7512) que especifica o rótulo do objeto. A chave privada deve ser gerada usando o mecanismo de preenchimento [PKCS\$11 v1.5](https://tools.ietf.org/html/rfc2313). |
As seguintes propriedades de configuração também são compatíveis:
****
| Campo | Description | Observações |
| --- | --- | --- |
| mqttMaxConnectionRetryInterval | Opcional. O intervalo máximo (em segundos) entre novas tentativas de conexão MQTT caso a conexão caia. | Especifique esse valor como um inteiro não assinado. O padrão é `60`. |
| managedRespawn | Opcional. Indica que o atendente OTA precisa executar o código personalizado antes de uma atualização. | Os valores válidos são `true` ou `false`. Para obter mais informações, consulte [Atualizações OTA do software AWS IoT Greengrass Core](core-ota-update.md). |
| writeDirectory | Opcional. O diretório de gravação em que AWS IoT Greengrass cria todos os read/write recursos. | Para obter mais informações, consulte [Configurar um diretório de gravação para AWS IoT Greengrass](#write-directory). |
| pidFileDirectory | Opcional. AWS IoT Greengrass armazena seu ID de processo (PID) nesse diretório. | O valor padrão é `/var/run`. |
------
#### [ Extended life versions ]
As seguintes versões do software AWS IoT Greengrass Core estão na [fase de vida útil prolongada](maintenance-policy.md). Essas informações estão incluídas apenas para fins de referência.
GGC v1.10
```
{
"coreThing" : {
"caPath" : "root.ca.pem",
"certPath" : "hash.cert.pem",
"keyPath" : "hash.private.key",
"thingArn" : "arn:partition:iot:region:account-id:thing/core-thing-name",
"iotHost" : "host-prefix-ats.iot.region.amazonaws.com",
"ggHost" : "greengrass-ats.iot.region.amazonaws.com",
"keepAlive" : 600,
"systemComponentAuthTimeout": 5000
},
"runtime" : {
"maxWorkItemCount" : 1024,
"maxConcurrentLimit" : 25,
"lruSize": 25,
"cgroup" : {
"useSystemd" : "yes"
}
},
"managedRespawn" : false,
"crypto" : {
"principals" : {
"SecretsManager" : {
"privateKeyPath" : "file:///greengrass/certs/hash.private.key"
},
"IoTCertificate" : {
"privateKeyPath" : "file:///greengrass/certs/hash.private.key",
"certificatePath" : "file:///greengrass/certs/hash.cert.pem"
}
},
"caPath" : "file:///greengrass/certs/root.ca.pem"
}
}
```
O arquivo `config.json` é compatível com as seguintes propriedades:
**coreThing**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/greengrass/v1/developerguide/gg-core.html)
**runtime**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/greengrass/v1/developerguide/gg-core.html)
**crypto**
A `crypto` apresenta propriedades que oferecem suporte ao armazenamento da chave privada em um módulo de segurança de hardware (HSM) por meio de PKCS\$111 e armazenamento local secreto. Para obter mais informações, consulte [AWS IoT Greengrass princípios básicos de segurança](gg-sec.md#gg-principals), [Integração de segurança de hardware](hardware-security.md) e [Implante segredos até o AWS IoT Greengrass âmago](secrets.md). As configurações para armazenamento de chaves privadas no sistema de arquivos HSMs ou no sistema de arquivos são suportadas.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/greengrass/v1/developerguide/gg-core.html)
As seguintes propriedades de configuração também são compatíveis:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/greengrass/v1/developerguide/gg-core.html)
GGC v1.9
```
{
"coreThing" : {
"caPath" : "root.ca.pem",
"certPath" : "hash.cert.pem",
"keyPath" : "hash.private.key",
"thingArn" : "arn:partition:iot:region:account-id:thing/core-thing-name",
"iotHost" : "host-prefix-ats.iot.region.amazonaws.com",
"ggHost" : "greengrass-ats.iot.region.amazonaws.com",
"keepAlive" : 600
},
"runtime" : {
"cgroup" : {
"useSystemd" : "yes"
}
},
"managedRespawn" : false,
"crypto" : {
"principals" : {
"SecretsManager" : {
"privateKeyPath" : "file:///greengrass/certs/hash.private.key"
},
"IoTCertificate" : {
"privateKeyPath" : "file:///greengrass/certs/hash.private.key",
"certificatePath" : "file:///greengrass/certs/hash.cert.pem"
}
},
"caPath" : "file:///greengrass/certs/root.ca.pem"
}
}
```
O arquivo `config.json` é compatível com as seguintes propriedades:
**coreThing**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/greengrass/v1/developerguide/gg-core.html)
**runtime**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/greengrass/v1/developerguide/gg-core.html)
**crypto**
O objeto `crypto` é adicionado em v1.7.0. Ele apresenta propriedades que oferecem suporte ao armazenamento da chave privada em um módulo de segurança de hardware (HSM) por meio de PKCS\$111 e armazenamento local secreto. Para obter mais informações, consulte [AWS IoT Greengrass princípios básicos de segurança](gg-sec.md#gg-principals), [Integração de segurança de hardware](hardware-security.md) e [Implante segredos até o AWS IoT Greengrass âmago](secrets.md). As configurações para armazenamento de chaves privadas no sistema de arquivos HSMs ou no sistema de arquivos são suportadas.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/greengrass/v1/developerguide/gg-core.html)
As seguintes propriedades de configuração também são compatíveis:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/greengrass/v1/developerguide/gg-core.html)
**GGC v1.8**
```
{
"coreThing" : {
"caPath" : "root.ca.pem",
"certPath" : "hash.cert.pem",
"keyPath" : "hash.private.key",
"thingArn" : "arn:aws:iot:region:account-id:thing/core-thing-name",
"iotHost" : "host-prefix-ats.iot.region.amazonaws.com",
"ggHost" : "greengrass-ats.iot.region.amazonaws.com",
"keepAlive" : 600
},
"runtime" : {
"cgroup" : {
"useSystemd" : "yes"
}
},
"managedRespawn" : false,
"crypto" : {
"principals" : {
"SecretsManager" : {
"privateKeyPath" : "file:///greengrass/certs/hash.private.key"
},
"IoTCertificate" : {
"privateKeyPath" : "file:///greengrass/certs/hash.private.key",
"certificatePath" : "file:///greengrass/certs/hash.cert.pem"
}
},
"caPath" : "file:///greengrass/certs/root.ca.pem"
}
}
```
O arquivo `config.json` é compatível com as seguintes propriedades.
**coreThing**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/greengrass/v1/developerguide/gg-core.html)
**runtime**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/greengrass/v1/developerguide/gg-core.html)
**crypto**
O objeto `crypto` é adicionado em v1.7.0. Ele apresenta propriedades que oferecem suporte ao armazenamento da chave privada em um módulo de segurança de hardware (HSM) por meio de PKCS\$111 e armazenamento local secreto. Para obter mais informações, consulte [AWS IoT Greengrass princípios básicos de segurança](gg-sec.md#gg-principals), [Integração de segurança de hardware](hardware-security.md) e [Implante segredos até o AWS IoT Greengrass âmago](secrets.md). As configurações para armazenamento de chaves privadas no sistema de arquivos HSMs ou no sistema de arquivos são suportadas.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/greengrass/v1/developerguide/gg-core.html)
As seguintes propriedades de configuração também são compatíveis:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/greengrass/v1/developerguide/gg-core.html)
**GGC v1.7**
```
{
"coreThing" : {
"caPath" : "root.ca.pem",
"certPath" : "hash.cert.pem",
"keyPath" : "hash.private.key",
"thingArn" : "arn:aws:iot:region:account-id:thing/core-thing-name",
"iotHost" : "host-prefix-ats.iot.region.amazonaws.com",
"ggHost" : "greengrass-ats.iot.region.amazonaws.com",
"keepAlive" : 600
},
"runtime" : {
"cgroup" : {
"useSystemd" : "yes"
}
},
"managedRespawn" : false,
"crypto" : {
"principals" : {
"SecretsManager" : {
"privateKeyPath" : "file:///greengrass/certs/hash.private.key"
},
"IoTCertificate" : {
"privateKeyPath" : "file:///greengrass/certs/hash.private.key",
"certificatePath" : "file:///greengrass/certs/hash.cert.pem"
}
},
"caPath" : "file:///greengrass/certs/root.ca.pem"
}
}
```
O arquivo `config.json` é compatível com as seguintes propriedades:
**coreThing**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/greengrass/v1/developerguide/gg-core.html)
**runtime**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/greengrass/v1/developerguide/gg-core.html)
**crypto**
O objeto `crypto`, adicionado na v1.7.0, apresenta propriedades que oferecem suporte ao armazenamento da chave privada em um módulo de segurança de hardware (HSM) por meio de PKCS\$111 e armazenamento local secreto. Para obter mais informações, consulte [Integração de segurança de hardware](hardware-security.md) e [Implante segredos até o AWS IoT Greengrass âmago](secrets.md). As configurações para armazenamento de chaves privadas no sistema de arquivos HSMs ou no sistema de arquivos são suportadas.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/greengrass/v1/developerguide/gg-core.html)
As seguintes propriedades de configuração também são compatíveis:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/greengrass/v1/developerguide/gg-core.html)
**GGC v1.6**
```
{
"coreThing": {
"caPath": "root-ca-pem",
"certPath": "cloud-pem-crt",
"keyPath": "cloud-pem-key",
"thingArn": "arn:aws:iot:region:account-id:thing/core-thing-name",
"iotHost": "host-prefix.iot.region.amazonaws.com",
"ggHost": "greengrass.iot.region.amazonaws.com",
"keepAlive": 600,
"mqttMaxConnectionRetryInterval": 60
},
"runtime": {
"cgroup": {
"useSystemd": "yes|no"
}
},
"managedRespawn": true,
"writeDirectory": "/write-directory"
}
```
Se você usar a opção de **criação de grupo padrão** do AWS IoT Greengrass console, o `config.json` arquivo será implantado no dispositivo principal em um estado de funcionamento que especifica a configuração padrão.
O arquivo `config.json` é compatível com as seguintes propriedades:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/greengrass/v1/developerguide/gg-core.html)
**GGC v1.5**
```
{
"coreThing": {
"caPath": "root-ca-pem",
"certPath": "cloud-pem-crt",
"keyPath": "cloud-pem-key",
"thingArn": "arn:aws:iot:region:account-id:thing/core-thing-name",
"iotHost": "host-prefix.iot.region.amazonaws.com",
"ggHost": "greengrass.iot.region.amazonaws.com",
"keepAlive": 600
},
"runtime": {
"cgroup": {
"useSystemd": "yes|no"
}
},
"managedRespawn": true
}
```
O arquivo `config.json` está presente em `/greengrass-root/config` e contém os seguintes parâmetros:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/greengrass/v1/developerguide/gg-core.html)
**GGC v1.3**
```
{
"coreThing": {
"caPath": "root-ca-pem",
"certPath": "cloud-pem-crt",
"keyPath": "cloud-pem-key",
"thingArn": "arn:aws:iot:region:account-id:thing/core-thing-name",
"iotHost": "host-prefix.iot.region.amazonaws.com",
"ggHost": "greengrass.iot.region.amazonaws.com",
"keepAlive": 600
},
"runtime": {
"cgroup": {
"useSystemd": "yes|no"
}
},
"managedRespawn": true
}
```
O arquivo `config.json` está presente em `/greengrass-root/config` e contém os seguintes parâmetros:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/greengrass/v1/developerguide/gg-core.html)
**GGC v1.1**
```
{
"coreThing": {
"caPath": "root-ca-pem",
"certPath": "cloud-pem-crt",
"keyPath": "cloud-pem-key",
"thingArn": "arn:aws:iot:region:account-id:thing/core-thing-name",
"iotHost": "host-prefix.iot.region.amazonaws.com",
"ggHost": "greengrass.iot.region.amazonaws.com",
"keepAlive": 600
},
"runtime": {
"cgroup": {
"useSystemd": "yes|no"
}
}
}
```
O arquivo `config.json` está presente em `/greengrass-root/config` e contém os seguintes parâmetros:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/greengrass/v1/developerguide/gg-core.html)
**GGC v1.0**
No AWS IoT Greengrass Core v1.0, `config.json` é implantado em. `greengrass-root/configuration`
```
{
"coreThing": {
"caPath": "root-ca-pem",
"certPath": "cloud-pem-crt",
"keyPath": "cloud-pem-key",
"thingArn": "arn:aws:iot:region:account-id:thing/core-thing-name",
"iotHost": "host-prefix.iot.region.amazonaws.com",
"ggHost": "greengrass.iot.region.amazonaws.com",
"keepAlive": 600
},
"runtime": {
"cgroup": {
"useSystemd": "yes|no"
}
}
}
```
O arquivo `config.json` está presente em `/greengrass-root/configuration` e contém os seguintes parâmetros:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/greengrass/v1/developerguide/gg-core.html)
------
## Os endpoints do serviço devem corresponder ao tipo de certificado da CA raiz
Seu AWS IoT Core e AWS IoT Greengrass os endpoints devem corresponder ao tipo de certificado do certificado CA raiz em seu dispositivo. Se os endpoints e o tipo de certificado não corresponderem, as tentativas de autenticação falharão entre o dispositivo e AWS IoT Core ou AWS IoT Greengrass. Para obter mais informações, consulte [Autenticação do servidor](https://docs.aws.amazon.com/iot/latest/developerguide/server-authentication.html) no *Guia do desenvolvedor do AWS IoT *.
Se seu dispositivo usar um certificado CA raiz do Amazon Trust Services (ATS), que é o método preferencial, ele também deverá usar endpoints do ATS para gerenciamento do dispositivo e operações de plano de dados de descoberta. Os endpoints ATS incluem o `ats` segmento, conforme mostrado na sintaxe a seguir para o AWS IoT Core endpoint.
```
prefix-ats.iot.region.amazonaws.com
```
**nota**
Para compatibilidade com versões anteriores, AWS IoT Greengrass atualmente oferece suporte a certificados e endpoints de CA VeriSign raiz legados em alguns s. Região da AWS Se você estiver usando um certificado de CA VeriSign raiz legado, recomendamos criar um endpoint ATS e, em vez disso, usar um certificado de CA raiz ATS. Caso contrário, certifique-se de usar os endpoints legados correspondentes. Para obter mais informações, consulte [Endpoints legados compatíveis](https://docs.aws.amazon.com/general/latest/gr/greengrass.html#greengrass-legacy-endpoints) no *Referência geral da Amazon Web Services*.
### Endpoints no config.json
Em um dispositivo de núcleo do Greengrass, os endpoints são especificados no objeto `coreThing` no arquivo [`config.json`](#config-json). A `iotHost` propriedade representa o AWS IoT Core ponto final. A `ggHost` propriedade representa o AWS IoT Greengrass ponto final. No exemplo de trecho a seguir, essas propriedades especificam endpoints do ATS.
```
{
"coreThing" : {
...
"iotHost" : "abcde1234uwxyz-ats.iot.us-west-2.amazonaws.com",
"ggHost" : "greengrass-ats.iot.us-west-2.amazonaws.com",
...
},
```
**AWS IoT Core endpoint**
Você pode obter seu AWS IoT Core endpoint executando o comando [https://docs.aws.amazon.com/cli/latest/reference/iot/describe-endpoint.html](https://docs.aws.amazon.com/cli/latest/reference/iot/describe-endpoint.html)CLI com o `--endpoint-type` parâmetro apropriado.
+ Para retornar um endpoint assinado pelo ATS, execute:
```
aws iot describe-endpoint --endpoint-type iot:Data-ATS
```
+ Para retornar um endpoint legado VeriSign assinado, execute:
```
aws iot describe-endpoint --endpoint-type iot:Data
```
**AWS IoT Greengrass endpoint**
*Seu AWS IoT Greengrass endpoint é seu `iotHost` endpoint com o prefixo do host substituído por greengrass.* Por exemplo, o endpoint assinado pelo ATS é `greengrass-ats.iot.region.amazonaws.com`. Isso usa a mesma região do seu AWS IoT Core endpoint.
## Conectar-se à porta 443 ou por meio de um proxy de rede
Esse recurso está disponível para AWS IoT Greengrass Core v1.7 e versões posteriores.
Os núcleos do Greengrass 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 HTTP antes de se conectar à Internet.
Para habilitar a comunicação nesses cenários, AWS IoT Greengrass permite as seguintes configurações:
+ **MQTT com autenticação de cliente TLS na porta 443**. Se a rede permitir conexões com a porta 443, você poderá configurar o núcleo 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.
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 ocorre com a configuração padrão, o MQTT sobre TLS na porta 443 usa autenticação de cliente baseada em certificado.
Quando configurado para usar uma conexão direta com a porta 443, o núcleo suporta [atualizações over-the-air (OTA)](core-ota-update.md) para AWS IoT Greengrass software. Esse suporte requer o AWS IoT Greengrass Core v1.9.3 ou posterior.
+ **Comunicação HTTPS pela porta 443**. AWS IoT Greengrass envia tráfego HTTPS pela porta 8443 por padrão, mas você pode configurá-lo para usar a porta 443.
+ **Conexão por meio de um proxy de rede**. É possível configurar um servidor de proxy de rede para atuar como intermediário para se conectar ao núcleo do Greengrass. Somente a autenticação básica e os proxies HTTP e HTTPS são compatíveis.
A configuração de proxy é transmitida para funções do Lambda definidas pelo usuário por meio das variáveis de ambiente `http_proxy`, `https_proxy` e `no_proxy`. As funções do Lambda definidas pelo usuário devem usar essas configurações transmitidas para conectarem-se pelo proxy. As bibliotecas comuns usadas por funções do Lambda para fazer conexões (como boto3 ou cURL e pacotes `requests` python) normalmente usam essas variáveis de ambiente por padrão. Se uma função Lambda também especificar essas mesmas variáveis de ambiente, AWS IoT Greengrass não as substituirá.
**Importante**
Os núcleos do Greengrass que são configurados para usar um proxy de rede não oferecem suporte a [atualizações OTA (over-the-air)](core-ota-update.md).
**Para configurar o MQTT na porta 443**
Esse recurso requer o AWS IoT Greengrass Core v1.7 ou posterior.
Este procedimento permite que o núcleo do Greengrass use a porta 443 para mensagens MQTT com o AWS IoT Core.
1. Execute o comando a seguir para interromper o daemon do Greengrass:
```
cd /greengrass-root/ggc/core/
sudo ./greengrassd stop
```
1. Abra `greengrass-root/config/config.json` para editar como o usuário su.
1. No objeto `coreThing`, adicione a propriedade `iotMqttPort` e defina o valor **443**, conforme exibido no seguinte exemplo.
```
{
"coreThing" : {
"caPath" : "root.ca.pem",
"certPath" : "12345abcde.cert.pem",
"keyPath" : "12345abcde.private.key",
"thingArn" : "arn:aws:iot:us-west-2:123456789012:thing/core-thing-name",
"iotHost" : "abcd123456wxyz-ats.iot.us-west-2.amazonaws.com",
"iotMqttPort" : 443,
"ggHost" : "greengrass-ats.iot.us-west-2.amazonaws.com",
"keepAlive" : 600
},
...
}
```
1. Inicie o daemon.
```
cd /greengrass-root/ggc/core/
sudo ./greengrassd start
```
**Para configurar o HTTPS na porta 443**
Esse recurso requer o AWS IoT Greengrass Core v1.8 ou posterior.
Esse procedimento configura o núcleo para usar a porta 443 para comunicação HTTPS.
1. Execute o comando a seguir para interromper o daemon do Greengrass:
```
cd /greengrass-root/ggc/core/
sudo ./greengrassd stop
```
1. Abra `greengrass-root/config/config.json` para editar como o usuário su.
1. No objeto `coreThing`, adicione as propriedades `iotHttpPort` e `ggHttpPort`, conforme exibido no exemplo a seguir.
```
{
"coreThing" : {
"caPath" : "root.ca.pem",
"certPath" : "12345abcde.cert.pem",
"keyPath" : "12345abcde.private.key",
"thingArn" : "arn:aws:iot:us-west-2:123456789012:thing/core-thing-name",
"iotHost" : "abcd123456wxyz-ats.iot.us-west-2.amazonaws.com",
"iotHttpPort" : 443,
"ggHost" : "greengrass-ats.iot.us-west-2.amazonaws.com",
"ggHttpPort" : 443,
"keepAlive" : 600
},
...
}
```
1. Inicie o daemon.
```
cd /greengrass-root/ggc/core/
sudo ./greengrassd start
```
**Para configurar um proxy de rede**
Esse recurso requer o AWS IoT Greengrass Core v1.7 ou posterior.
Este procedimento permite AWS IoT Greengrass conectar-se à Internet por meio de um proxy de rede HTTP ou HTTPS.
1. Execute o comando a seguir para interromper o daemon do Greengrass:
```
cd /greengrass-root/ggc/core/
sudo ./greengrassd stop
```
1. Abra `greengrass-root/config/config.json` para editar como o usuário su.
1. No objeto `coreThing`, adicione o objeto [networkProxy](#networkProxy-object), conforme mostrado no exemplo a seguir.
```
{
"coreThing" : {
"caPath" : "root.ca.pem",
"certPath" : "12345abcde.cert.pem",
"keyPath" : "12345abcde.private.key",
"thingArn" : "arn:aws:iot:us-west-2:123456789012:thing/core-thing-name",
"iotHost" : "abcd123456wxyz-ats.iot.us-west-2.amazonaws.com",
"ggHost" : "greengrass-ats.iot.us-west-2.amazonaws.com",
"keepAlive" : 600,
"networkProxy": {
"noProxyAddresses" : "http://128.12.34.56,www.mywebsite.com",
"proxy" : {
"url" : "https://my-proxy-server:1100",
"username" : "Mary_Major",
"password" : "pass@word1357"
}
}
},
...
}
```
1. Inicie o daemon.
```
cd /greengrass-root/ggc/core/
sudo ./greengrassd start
```
**Objeto networkProxy **
Use o objeto `networkProxy` para especificar informações sobre o proxy de rede. Esse objeto tem as seguintes propriedades.
| Campo | Description |
| --- | --- |
| 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. Um proxy tem as seguintes propriedades. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/greengrass/v1/developerguide/gg-core.html) |
### Permitir endpoints
A comunicação entre dispositivos Greengrass AWS IoT Core e/ou AWS IoT Greengrass deve ser autenticada. Esta autenticação é baseada nos certificados e nas chaves criptográficas do dispositivo X.509 registrado. Para permitir que as solicitações autenticadas passem pelos proxies sem criptografia adicional, aprove os endpoints a seguir.
| Endpoint | Porta | Description |
| --- | --- | --- |
| greengrass.region.amazonaws.com | 443 | Usado para operações de ambiente de gerenciamento para gerenciamento de grupos. |
| `prefix-ats.iot.region.amazonaws.com` ou `prefix.iot.region.amazonaws.com` | MQTT: 8883 ou 443 HTTPS: 8443 ou 443 | Usado para operações de plano de dados para o gerenciamento de dispositivos, como sincronização de sombra. Permite o uso de um ou ambos endpoints, dependendo se os dispositivos cliente e o núcleo usam os certificados CA raiz Amazon Trust Services (preferido), certificados CA raiz legados, ou ambos. Para obter mais informações, consulte [Os endpoints do serviço devem corresponder ao tipo de certificado da CA raiz](#certificate-endpoints). |
| `greengrass-ats.iot.region.amazonaws.com` ou `greengrass.iot.region.amazonaws.com` | 8443 ou 443 | Usado para operações de descoberta de dispositivo. Permite o uso de um ou ambos endpoints, dependendo se os dispositivos cliente e o núcleo usam os certificados CA raiz Amazon Trust Services (preferido), certificados CA raiz legados, ou ambos. Para obter mais informações, consulte [Os endpoints do serviço devem corresponder ao tipo de certificado da CA raiz](#certificate-endpoints). Os clientes que se conectam na porta 443 devem implementar a extensão TLS do [Application Layer Protocol Negotiation (ALPN)](https://tools.ietf.org/html/rfc7301) e passar `x-amzn-http-ca` como o `ProtocolName` no `ProtocolNameList`. Para obter mais informações, consulte [Protocolos](https://docs.aws.amazon.com/iot/latest/developerguide/protocols.html) no *Guia do desenvolvedor do AWS IoT *. |
| \$1.s3.amazonaws.com | 443 | Usado para operações de implantação e over-the-air atualizações. Este formato inclui o caractere `*`, porque os prefixos de endpoint são controlados internamente e podem mudar a qualquer momento. |
| logs.region.amazonaws.com | 443 | Obrigatório se o grupo do Greengrass estiver configurado para gravar logs no CloudWatch. |
## Configurar um diretório de gravação para AWS IoT Greengrass
Esse recurso está disponível para AWS IoT Greengrass Core v1.6 e versões posteriores.
Por padrão, o software AWS IoT Greengrass Core é implantado em um único diretório raiz, onde AWS IoT Greengrass executa todas as operações de leitura e gravação. No entanto, você pode configurar AWS IoT Greengrass para usar um diretório separado para todas as operações de gravação, incluindo a criação de diretórios e arquivos. Nesse caso, AWS IoT Greengrass usa dois diretórios de nível superior:
+ O diretório *greengrass-root*, que você pode deixar como leitura/gravação ou, como opção, somente leitura. Ele contém o software AWS IoT Greengrass principal e outros componentes essenciais que devem permanecer imutáveis durante o tempo de execução, como certificados e. `config.json`
+ O diretório de gravação especificado. Isso contém conteúdo gravável, como logs, informações de estado e funções do Lambda definidas pelo usuário implantadas.
Essa configuração resulta na estrutura de diretórios a seguir.
**Diretório raiz do Greengrass**
```
greengrass-root/
|-- certs/
| |-- root.ca.pem
| |-- hash.cert.pem
| |-- hash.private.key
| |-- hash.public.key
|-- config/
| |-- config.json
|-- ggc/
| |-- packages/
| |-- package-version/
| |-- bin/
| |-- daemon
| |-- greengrassd
| |-- lambda/
| |-- LICENSE/
| |-- release_notes_package-version.html
| |-- runtime/
| |-- java8/
| |-- nodejs8.10/
| |-- python3.8/
| |-- core/
```
**Diretório de gravação**
```
write-directory/
|-- packages/
| |-- package-version/
| |-- ggc_root/
| |-- rootfs_nosys/
| |-- rootfs_sys/
| |-- var/
|-- deployment/
| |-- group/
| |-- group.json
| |-- lambda/
| |-- mlmodel/
|-- var/
| |-- log/
| |-- state/
```
**Para configurar um diretório de gravação**
1. Execute o comando a seguir para interromper o AWS IoT Greengrass daemon:
```
cd /greengrass-root/ggc/core/
sudo ./greengrassd stop
```
1. Abra `greengrass-root/config/config.json` para editar como o usuário su.
1. Adicione `writeDirectory` como parâmetro e especifique o caminho para o diretório de destino, conforme mostrado no exemplo a seguir.
```
{
"coreThing": {
"caPath": "root-CA.pem",
"certPath": "hash.pem.crt",
...
},
...
"writeDirectory" : "/write-directory"
}
```
**nota**
Você poderá atualizar a configuração `writeDirectory` sempre que quiser. Depois que a configuração for atualizada, AWS IoT Greengrass usa o diretório de gravação recém-especificado na próxima inicialização, mas não migra o conteúdo do diretório de gravação anterior.
1. Agora que o diretório de gravação está configurado, você pode tornar o diretório *greengrass-root* somente leitura. Para obter instruções, consulte [Para tornar o diretório raiz do Greengrass somente leitura](#configure-ro-directory).
Caso contrário, inicie o AWS IoT Greengrass daemon:
```
cd /greengrass-root/ggc/core/
sudo ./greengrassd start
```
**Para tornar o diretório raiz do Greengrass somente leitura**
Siga essas etapas somente se você quiser tornar o diretório raiz do Greengrass somente leitura. O diretório de gravação deve estar configurado antes de você começar.
1. Conceder permissões de acesso a diretórios necessários:
1. Dê permissões de leitura e gravação ao proprietário `config.json`.
```
sudo chmod 0600 /greengrass-root/config/config.json
```
1. Torne ggc\$1user o proprietário das certificações e dos diretórios Lambda do sistema.
```
sudo chown -R ggc_user:ggc_group /greengrass-root/certs/
sudo chown -R ggc_user:ggc_group /greengrass-root/ggc/packages/1.11.6/lambda/
```
**nota**
As contas ggc\$1user e ggc\$1group são usadas por padrão para executar funções do Lambda do sistema. Se você configurou a [identidade de acesso padrão](lambda-group-config.md#lambda-access-identity-groupsettings) no nível do grupo para usar contas diferentes, em vez disso, deve conceder permissões a esse usuário (UID) e grupo (GID).
1. Torne o diretório *greengrass-root* somente leitura usando seu mecanismo preferido.
**nota**
Uma maneira de tornar o diretório *greengrass-root* somente leitura é montar o diretório como somente leitura. No entanto, para aplicar atualizações over-the-air (OTA) ao software AWS IoT Greengrass Core em um diretório montado, o diretório deve primeiro ser desmontado e, em seguida, remontado após a atualização. Você pode adicionar essas operações `umount` e `mount` aos scripts `ota_pre_update` e `ota_post_update`. Para obter mais informações sobre atualizações OTA, consulte [Agente de atualizações OTA do Greengrass](core-ota-update.md#ota-agent) e [Respawn gerenciado com atualizações OTA](core-ota-update.md#ota-managed-respawn).
1. Inicie o daemon.
```
cd /greengrass-root/ggc/core/
sudo ./greengrassd start
```
Se as permissões da etapa 1 não forem definidas corretamente, o daemon não será iniciado.
## Definir configurações MQTT
No AWS IoT Greengrass ambiente, dispositivos clientes locais, funções Lambda, conectores e componentes do sistema podem se comunicar entre si e com eles. AWS IoT Core Toda a comunicação passa pelo núcleo, que gerencia as [assinaturas](gg-sec.md#gg-msg-workflow) que autorizam a comunicação MQTT entre entidades.
Para obter informações sobre as configurações de MQTT que você pode configurar AWS IoT Greengrass, consulte as seções a seguir:
+ [Enviar mensagem sobre a qualidade de serviço](#message-quality-of-service)
+ [Fila de mensagens MQTT para destinos de nuvem](#mqtt-message-queue)
+ [Sessões persistentes do MQTT com AWS IoT Core](#mqtt-persistent-sessions)
+ [Cliente IDs para conexões MQTT com AWS IoT](#connection-client-id)
+ [Porta MQTT para mensagens locais](#config-local-mqtt-port)
+ [Tempo limite para operações de publicação, assinatura e cancelamento de assinatura em conexões MQTT com o Nuvem AWS](#mqtt-operation-timeout)
**nota**
O OPC-UA é um padrão de intercâmbio de informações para a comunicação industrial. [Para implementar o suporte para OPC-UA no núcleo do Greengrass, você pode usar o conector IoT. SiteWise ](iot-sitewise-connector.md) O conector envia dados de dispositivos industriais dos servidores OPC-UA para as propriedades dos ativos em. AWS IoT SiteWise
### Enviar mensagem sobre a qualidade de serviço
AWS IoT Greengrass oferece suporte aos níveis 0 ou 1 de qualidade de serviço (QoS), dependendo da configuração e do alvo e da direção da comunicação. O núcleo do Greengrass atua como um cliente para comunicação AWS IoT Core e um agente de mensagens para comunicação na rede local.
![\[O núcleo como cliente e atendente de mensagens local.\]](http://docs.aws.amazon.com/pt_br/greengrass/v1/developerguide/images/mqtt-qos.png)
Para obter mais informações sobre o MQTT e QoS, consulte [Introdução](https://mqtt.org/getting-started/) no site do MQTT.
**Comunicação com o Nuvem AWS**
+ **Mensagens de saída usam QoS 1**
O núcleo envia mensagens destinadas a Nuvem AWS alvos usando QoS 1. AWS IoT Greengrass usa uma fila de mensagens MQTT para processar essas mensagens. Se a entrega da mensagem não for confirmada por AWS IoT, a mensagem será enviada em spool para ser repetida posteriormente. A mensagem não pode ser repetida se a fila estiver cheia. A confirmação de entrega de mensagens pode ajudar a minimizar a perda de dados devido à conectividade intermitente.
Como as mensagens de saída AWS IoT usam QoS 1, a taxa máxima na qual o núcleo do Greengrass pode enviar mensagens depende da latência entre o núcleo e. AWS IoT Cada vez que o núcleo envia uma mensagem, ele espera até AWS IoT confirmar a mensagem antes de enviar a próxima mensagem. Por exemplo, se o tempo de ida e volta entre o núcleo e o seu Região da AWS for de 50 milissegundos, o núcleo poderá enviar até 20 mensagens por segundo. Considere esse comportamento ao escolher Região da AWS onde seu núcleo se conecta. [Para ingerir dados de IoT de alto volume para o Nuvem AWS, você pode usar o gerenciador de streams.](stream-manager.md)
Para obter mais informações sobre a fila de mensagens do MQTT, incluindo como configurar um cache de armazenamento local que possa persistir mensagens destinadas Nuvem AWS aos destinos, consulte. [Fila de mensagens MQTT para destinos de nuvem](#mqtt-message-queue)
+ **As mensagens de entrada usam QoS 0 (padrão) ou QoS 1**
Por padrão, o núcleo se inscreve com QoS 0 para mensagens de fontes da Nuvem AWS . Se você habilitar sessões persistentes, o núcleo se inscreverá com QoS 1. Isso pode ajudar a minimizar a perda de dados devido à conectividade intermitente. Para gerenciar a QoS para essas assinaturas, defina as configurações de persistência no componente de sistema do spooler local.
Para obter mais informações, incluindo como permitir que o núcleo estabeleça uma sessão persistente com Nuvem AWS destinos, consulte[Sessões persistentes do MQTT com AWS IoT Core](#mqtt-persistent-sessions).
**Comunicação com os destinos locais**
Toda comunicação local usa QoS 0. O núcleo tenta enviar uma mensagem para um destino local, que pode ser uma função do Lambda do Greengrass, um conector ou um [dispositivo cliente](what-is-gg.md#greengrass-devices). O núcleo não armazena mensagens nem confirma a entrega. As mensagens podem ser descartadas em qualquer lugar entre os componentes.
Embora a comunicação direta entre funções do Lambda não use mensagens MQTT, o comportamento é o mesmo.
### Fila de mensagens MQTT para destinos de nuvem
As mensagens MQTT destinadas aos destinos são enfileiradas para Nuvem AWS aguardar o processamento. As mensagens enfileiradas são processadas na ordem First In First Out (FIFO – Primeiro a entrar, primeiro a sair). Depois que uma mensagem é processada e publicada AWS IoT Core, ela é removida da fila.
Por padrão, o núcleo do Greengrass armazena mensagens não processadas na memória para destinos da Nuvem AWS . Em vez disso, você pode configurar o núcleo para armazenar mensagens não processadas em um cache de armazenamento local. Ao contrário do armazenamento na memória, o cache de armazenamento local tem a capacidade de persistir nas reinicializações principais (por exemplo, após uma implantação em grupo ou a reinicialização de um dispositivo), para que AWS IoT Greengrass possa continuar processando as mensagens. Você também pode configurar o tamanho do armazenamento.
**Atenção**
O núcleo do Greengrass pode enfileirar mensagens MQTT duplicadas quando perde a conexão, porque ele tenta novamente uma operação de publicação antes que o cliente MQTT detecte que está off-line. Para evitar mensagens MQTT duplicadas para destinos na nuvem, configure o valor `keepAlive` do núcleo para menos da metade de seu valor `mqttOperationTimeout`. Para obter mais informações, consulte [AWS IoT Greengrass arquivo de configuração principal](#config-json).
AWS IoT Greengrass usa o componente do sistema spooler (a função `GGCloudSpooler` Lambda) para gerenciar a fila de mensagens. Você pode usar as seguintes variáveis de ambiente `GGCloudSpooler` para definir as configurações de armazenamento.
+ **GG\$1CONFIG\$1STORAGE\$1TYPE**. O local da fila de mensagens. Estes são valores válidos:
+ `FileSystem`. Armazena mensagens não processadas no cache de armazenamento local no disco do dispositivo de núcleo físico. Quando o núcleo é reiniciado, as mensagens são mantidas na fila para processamento. As mensagens serão removidas depois de serem processadas.
+ `Memory` (padrão). Armazene mensagens não processadas na memória. Quando o núcleo é reiniciado, as mensagens enfileiradas são perdidas.
Essa opção é otimizado para dispositivos com recursos de hardware restritos. Ao usar essa configuração, recomendamos que você implante grupos ou reinicie o dispositivo quando a interrupção do serviço é a mais baixa.
+ **GG\$1CONFIG\$1MAX\$1SIZE\$1BYTES**. O tamanho de armazenamento, em bytes. Esse valor pode ser qualquer número inteiro não negativo **maior ou igual a 262144** (256 KB); um tamanho menor impede que o software AWS IoT Greengrass Core seja iniciado. O tamanho padrão é 2,5 MB. Quando o limite de tamanho é atingido, as mensagens enfileiradas anteriores são substituídas por novas mensagens.
**nota**
Esse recurso está disponível para AWS IoT Greengrass Core v1.6 e versões posteriores. As versões anteriores usam o armazenamento na memória com um tamanho de fila de 2,5 MB. Você não pode definir configurações de armazenamento para versões anteriores.
#### Como armazenar mensagens em cache no armazenamento local
Você pode configurar AWS IoT Greengrass para armazenar mensagens em cache no sistema de arquivos para que elas persistam nas reinicializações principais. Para fazer isso, implante uma versão de definição de função em que a função `GGCloudSpooler` defina o tipo de armazenamento como `FileSystem`. Você deve usar a AWS IoT Greengrass API para configurar o cache de armazenamento local. Você pode fazer isso no console.
O procedimento a seguir usa o comando da CLI [https://docs.aws.amazon.com/cli/latest/reference/greengrass/create-function-definition-version.html](https://docs.aws.amazon.com/cli/latest/reference/greengrass/create-function-definition-version.html) para configurar o spooler a fim de salvar mensagens enfileiradas no sistema de arquivos. Ele também configura um tamanho de fila de 2,6 MB.
1. Obtenha o grupo alvo IDs do Greengrass e a versão do grupo. Esse procedimento pressupõe que esse seja o grupo e a versão mais recente do grupo. A consulta a seguir retorna o grupo criado mais recentemente.
```
aws greengrass list-groups --query "reverse(sort_by(Groups, &CreationTimestamp))[0]"
```
Ou é possível consultar por nome. Os nomes de grupo não precisam ser exclusivos, portanto, vários grupos podem ser retornados.
```
aws greengrass list-groups --query "Groups[?Name=='MyGroup']"
```
**nota**
Você também pode encontrar esses valores no AWS IoT console. O ID do grupo é exibido na página **Settings (Configurações)** do grupo. IDs As versões do grupo são exibidas na guia **Implantações** do grupo.
1. Copie os valores `Id` e `LatestVersion` do grupo de destino na saída.
1. Obtenha a versão do grupo mais recente.
+ Substitua *group-id* pelo `Id` que você copiou.
+ Substitua *latest-group-version-id* pelo `LatestVersion` que você copiou.
```
aws greengrass get-group-version \
--group-id group-id \
--group-version-id latest-group-version-id
```
1. Do `Definition` objeto na saída, `CoreDefinitionVersionArn` copie o e o ARNs de todos os outros componentes do grupo, exceto`FunctionDefinitionVersionArn`. Você usa esses valores ao criar uma nova versão do grupo.
1. No `FunctionDefinitionVersionArn` na saída, copie o ID da definição de função. O ID é o GUID que segue o segmento `functions` no ARN, conforme mostrado no exemplo a seguir.
```
arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/functions/bcfc6b49-beb0-4396-b703-6dEXAMPLEcu5/versions/0f7337b4-922b-45c5-856f-1aEXAMPLEsf6
```
**nota**
Ou você pode criar uma definição de função executando o comando [https://docs.aws.amazon.com/cli/latest/reference/greengrass/create-function-definition.html](https://docs.aws.amazon.com/cli/latest/reference/greengrass/create-function-definition.html) e copiar o ID da saída.
1. Adicione uma versão de definição de função à definição da função.
+ *function-definition-id*Substitua pelo `Id` que você copiou para a definição da função.
+ *arbitrary-function-id*Substitua por um nome para a função, como**spooler-function**.
+ Adicione todas as funções do Lambda que você deseja incluir nesta versão para a matriz `functions`. Você pode usar o comando [https://docs.aws.amazon.com/cli/latest/reference/greengrass/get-function-definition-version.html](https://docs.aws.amazon.com/cli/latest/reference/greengrass/get-function-definition-version.html) para obter as funções do Lambda do Greengrass de uma versão de definição da função existente.
**Atenção**
Não se esqueça de especificar um valor para `GG_CONFIG_MAX_SIZE_BYTES` que seja **maior que ou igual a 262.144**. Um tamanho menor impede que o software AWS IoT Greengrass Core seja iniciado.
```
aws greengrass create-function-definition-version \
--function-definition-id function-definition-id \
--functions '[{"FunctionArn": "arn:aws:lambda:::function:GGCloudSpooler:1","FunctionConfiguration": {"Environment": {"Variables":{"GG_CONFIG_MAX_SIZE_BYTES":"2621440","GG_CONFIG_STORAGE_TYPE":"FileSystem"}},"Executable": "spooler","MemorySize": 32768,"Pinned": true,"Timeout": 3},"Id": "arbitrary-function-id"}]'
```
**nota**
Se você definiu anteriormente a variável de `GG_CONFIG_SUBSCRIPTION_QUALITY` ambiente para [oferecer suporte a sessões persistentes AWS IoT Core](#mqtt-persistent-sessions), inclua-a nessa instância da função.
1. Copie o `Arn` da versão da definição de função da saída.
1. Crie uma versão do grupo que contém a função do Lambda definida pelo sistema.
+ *group-id*Substitua `Id` pelo para o grupo.
+ *core-definition-version-arn*Substitua pelo `CoreDefinitionVersionArn` que você copiou da versão mais recente do grupo.
+ *function-definition-version-arn*Substitua pelo `Arn` que você copiou para a nova versão de definição de função.
+ Substitua o ARNs por outros componentes do grupo (por exemplo, `SubscriptionDefinitionVersionArn` ou`DeviceDefinitionVersionArn`) que você copiou da versão mais recente do grupo.
+ Remova todos os parâmetros inutilizados. Por exemplo, remova a versão `--resource-definition-version-arn` caso a versão do grupo não contenha recursos.
```
aws greengrass create-group-version \
--group-id group-id \
--core-definition-version-arn core-definition-version-arn \
--function-definition-version-arn function-definition-version-arn \
--device-definition-version-arn device-definition-version-arn \
--logger-definition-version-arn logger-definition-version-arn \
--resource-definition-version-arn resource-definition-version-arn \
--subscription-definition-version-arn subscription-definition-version-arn
```
1. Copie a `Version` da saída. Este é o ID da nova versão do grupo.
1. Implante o grupo com a nova versão do grupo.
+ *group-id*Substitua pelo `Id` que você copiou para o grupo.
+ *group-version-id*Substitua pelo `Version` que você copiou para a nova versão do grupo.
```
aws greengrass create-deployment \
--group-id group-id \
--group-version-id group-version-id \
--deployment-type NewDeployment
```
Para atualizar as configurações de armazenamento, use a AWS IoT Greengrass API para criar uma nova versão de definição de função que contém a `GGCloudSpooler` função com a configuração atualizada. Em seguida, adicione a versão de definição da função a uma nova versão do grupo (com os outros componentes do grupo) e implantar a versão do grupo. Se quiser restaurar a configuração padrão, você poderá implantar uma versão de definição da função que não inclua a função `GGCloudSpooler`.
Essa função do Lambda do sistema não está visível no console. No entanto, depois que a função for adicionada à versão do grupo mais recente, ela será incluída em implantações que você fizer no console, a menos que você use a API para substituir ou removê-la.
### Sessões persistentes do MQTT com AWS IoT Core
Esse recurso está disponível para o AWS IoT Greengrass Core v1.10 e versões posteriores.
Um núcleo do Greengrass pode estabelecer uma sessão persistente com o agente de AWS IoT mensagens. Uma sessão persistente é uma conexão contínua que permite que o núcleo receba mensagens enviadas enquanto ele está off-line. O núcleo é o cliente na conexão.
Em uma sessão persistente, o agente de AWS IoT mensagens salva todas as assinaturas que o núcleo faz durante a conexão. [Se o núcleo se desconectar, o agente de AWS IoT mensagens armazenará mensagens novas e não confirmadas publicadas como QoS 1 e destinadas a alvos locais, como funções Lambda e dispositivos clientes.](what-is-gg.md#greengrass-devices) Quando o núcleo se reconecta, a sessão persistente é retomada e o agente de AWS IoT mensagens envia mensagens armazenadas para o núcleo a uma taxa máxima de 10 mensagens por segundo. As sessões persistentes têm um período de expiração padrão de 1 hora, que tem início quando o atendente de mensagens detecta que o núcleo se desconectou. Para obter mais informações, consulte [Sessões Persistentes do MQTT](https://docs.aws.amazon.com/iot/latest/developerguide/mqtt-persistent-sessions.html) no *Guia do desenvolvedor do AWS IoT *.
AWS IoT Greengrass usa o componente do sistema spooler (a função `GGCloudSpooler` Lambda) para criar assinaturas que têm como fonte. AWS IoT Você pode usar a seguinte variável de ambiente `GGCloudSpooler` para configurar sessões persistentes.
+ **GG\$1CONFIG\$1SUBSCRIPTION\$1QUALITY**. A qualidade das assinaturas que têm AWS IoT como fonte. Estes são valores válidos:
+ `AtMostOnce` (padrão). Desabilita sessões persistentes. As assinaturas usam QoS 0.
+ `AtLeastOncePersistent`. Habilita sessões persistentes. Define o sinalizador `cleanSession` como `0` em mensagens `CONNECT` e se inscreve com QoS 1.
As mensagens publicadas com QoS 1 recebidas pelo núcleo têm a garantia de alcançar a fila de trabalho na memória do daemon do Greengrass. O núcleo reconhece a mensagem depois que ela é adicionada à fila. A comunicação subsequente da fila para o destino local (por exemplo, função, conector ou dispositivo do Lambda do Greengrass) é enviada como QoS 0. O AWS IoT Greengrass não garante a entrega para destinos locais.
**nota**
Você pode usar a propriedade de configuração [maxWorkItemCount](#config-json-runtime) para controlar o tamanho da fila de itens de trabalho. Por exemplo, você pode aumentar o tamanho da fila se sua carga de trabalho exigir tráfego MQTT pesado.
Quando as sessões persistentes estão habilitadas, o núcleo abre pelo menos uma conexão adicional para troca de mensagens do MQTT com AWS IoT. Para obter mais informações, consulte [Cliente IDs para conexões MQTT com AWS IoT](#connection-client-id).
#### Como configurar sessões persistentes do MQTT
Você pode configurar AWS IoT Greengrass para usar sessões persistentes com AWS IoT Core. Para fazer isso, implante uma versão de definição de função em que a função `GGCloudSpooler` defina a qualidade da assinatura como `AtLeastOncePersistent`. Essa definição se aplica a todas as assinaturas que tenham o AWS IoT Core (`cloud`) como origem. Você deve usar a AWS IoT Greengrass API para configurar sessões persistentes. Você pode fazer isso no console.
O procedimento a seguir usa o comando da CLI [https://docs.aws.amazon.com/cli/latest/reference/greengrass/create-function-definition-version.html](https://docs.aws.amazon.com/cli/latest/reference/greengrass/create-function-definition-version.html) para configurar o spooler de modo a usar sessões persistentes. Nesse procedimento, estamos supondo que você esteja atualizando a configuração da versão do grupo mais recente de um grupo existente.
1. Obtenha o grupo alvo IDs do Greengrass e a versão do grupo. Esse procedimento pressupõe que esse seja o grupo e a versão mais recente do grupo. A consulta a seguir retorna o grupo criado mais recentemente.
```
aws greengrass list-groups --query "reverse(sort_by(Groups, &CreationTimestamp))[0]"
```
Ou é possível consultar por nome. Os nomes de grupo não precisam ser exclusivos, portanto, vários grupos podem ser retornados.
```
aws greengrass list-groups --query "Groups[?Name=='MyGroup']"
```
**nota**
Você também pode encontrar esses valores no AWS IoT console. O ID do grupo é exibido na página **Settings (Configurações)** do grupo. IDs As versões do grupo são exibidas na guia **Implantações** do grupo.
1. Copie os valores `Id` e `LatestVersion` do grupo de destino na saída.
1. Obtenha a versão do grupo mais recente.
+ Substitua *group-id* pelo `Id` que você copiou.
+ Substitua *latest-group-version-id* pelo `LatestVersion` que você copiou.
```
aws greengrass get-group-version \
--group-id group-id \
--group-version-id latest-group-version-id
```
1. Do `Definition` objeto na saída, `CoreDefinitionVersionArn` copie o e o ARNs de todos os outros componentes do grupo, exceto`FunctionDefinitionVersionArn`. Você usa esses valores ao criar uma nova versão do grupo.
1. No `FunctionDefinitionVersionArn` na saída, copie o ID da definição de função. O ID é o GUID que segue o segmento `functions` no ARN, conforme mostrado no exemplo a seguir.
```
arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/functions/bcfc6b49-beb0-4396-b703-6dEXAMPLEcu5/versions/0f7337b4-922b-45c5-856f-1aEXAMPLEsf6
```
**nota**
Ou você pode criar uma definição de função executando o comando [https://docs.aws.amazon.com/cli/latest/reference/greengrass/create-function-definition.html](https://docs.aws.amazon.com/cli/latest/reference/greengrass/create-function-definition.html) e copiar o ID da saída.
1. Adicione uma versão de definição de função à definição da função.
+ *function-definition-id*Substitua pelo `Id` que você copiou para a definição da função.
+ *arbitrary-function-id*Substitua por um nome para a função, como**spooler-function**.
+ Adicione todas as funções do Lambda que você deseja incluir nesta versão para a matriz `functions`. Você pode usar o comando [https://docs.aws.amazon.com/cli/latest/reference/greengrass/get-function-definition-version.html](https://docs.aws.amazon.com/cli/latest/reference/greengrass/get-function-definition-version.html) para obter as funções do Lambda do Greengrass de uma versão de definição da função existente.
```
aws greengrass create-function-definition-version \
--function-definition-id function-definition-id \
--functions '[{"FunctionArn": "arn:aws:lambda:::function:GGCloudSpooler:1","FunctionConfiguration": {"Environment": {"Variables":{"GG_CONFIG_SUBSCRIPTION_QUALITY":"AtLeastOncePersistent"}},"Executable": "spooler","MemorySize": 32768,"Pinned": true,"Timeout": 3},"Id": "arbitrary-function-id"}]'
```
**nota**
Se você definiu anteriormente as variáveis de ambiente `GG_CONFIG_STORAGE_TYPE` ou `GG_CONFIG_MAX_SIZE_BYTES` para [definir configurações de armazenamento](#mqtt-message-queue), inclua as varáveis nessa instância de função.
1. Copie o `Arn` da versão da definição de função da saída.
1. Crie uma versão do grupo que contém a função do Lambda definida pelo sistema.
+ *group-id*Substitua `Id` pelo para o grupo.
+ *core-definition-version-arn*Substitua pelo `CoreDefinitionVersionArn` que você copiou da versão mais recente do grupo.
+ *function-definition-version-arn*Substitua pelo `Arn` que você copiou para a nova versão de definição de função.
+ Substitua o ARNs por outros componentes do grupo (por exemplo, `SubscriptionDefinitionVersionArn` ou`DeviceDefinitionVersionArn`) que você copiou da versão mais recente do grupo.
+ Remova todos os parâmetros inutilizados. Por exemplo, remova a versão `--resource-definition-version-arn` caso a versão do grupo não contenha recursos.
```
aws greengrass create-group-version \
--group-id group-id \
--core-definition-version-arn core-definition-version-arn \
--function-definition-version-arn function-definition-version-arn \
--device-definition-version-arn device-definition-version-arn \
--logger-definition-version-arn logger-definition-version-arn \
--resource-definition-version-arn resource-definition-version-arn \
--subscription-definition-version-arn subscription-definition-version-arn
```
1. Copie a `Version` da saída. Este é o ID da nova versão do grupo.
1. Implante o grupo com a nova versão do grupo.
+ *group-id*Substitua pelo `Id` que você copiou para o grupo.
+ *group-version-id*Substitua pelo `Version` que você copiou para a nova versão do grupo.
```
aws greengrass create-deployment \
--group-id group-id \
--group-version-id group-version-id \
--deployment-type NewDeployment
```
1. (Opcional) Aumente a propriedade [maxWorkItemCount](#config-json-runtime) no arquivo de configuração principal. Isso pode ajudar o núcleo a lidar com o aumento do tráfego MQTT e a comunicação com destinos locais.
Para atualizar o núcleo com essas alterações de configuração, você usa a AWS IoT Greengrass API para criar uma nova versão de definição de função que contém a `GGCloudSpooler` função com a configuração atualizada. Em seguida, adicione a versão de definição da função a uma nova versão do grupo (com os outros componentes do grupo) e implantar a versão do grupo. Se quiser restaurar a configuração padrão, você poderá criar uma versão de definição da função que não inclua a função `GGCloudSpooler`.
Essa função do Lambda do sistema não está visível no console. No entanto, depois que a função for adicionada à versão do grupo mais recente, ela será incluída em implantações que você fizer no console, a menos que você use a API para substituir ou removê-la.
### Cliente IDs para conexões MQTT com AWS IoT
Esse recurso está disponível para o AWS IoT Greengrass Core v1.8 e versões posteriores.
O núcleo do Greengrass abre conexões MQTT com AWS IoT Core operações como sincronização paralela e gerenciamento de certificados. Para essas conexões, o núcleo gera um cliente previsível IDs com base no nome da coisa principal. O Predictable Client IDs pode ser usado com recursos de monitoramento, auditoria e precificação, incluindo AWS IoT Device Defender eventos de [AWS IoT ciclo](https://docs.aws.amazon.com/iot/latest/developerguide/life-cycle-events.html) de vida. Você também pode criar uma lógica em torno do cliente previsível IDs (por exemplo, [assinar modelos de política](https://docs.aws.amazon.com/iot/latest/developerguide/pub-sub-policy.html#pub-sub-policy-cert) com base nos atributos do certificado).
------
#### [ GGC v1.9 and later ]
Dois componentes do sistema Greengrass abrem conexões MQTT com. AWS IoT Core Esses componentes usam os seguintes padrões para gerar o cliente IDs para as conexões.
| Operation | Padrão de ID de cliente |
| --- | --- |
| Implantações | `core-thing-name` Exemplo: `MyCoreThing` Use esse ID de cliente para se conectar, desconectar, assinar e cancelar a assinatura de notificações de eventos de ciclo de vida. |
| Assinaturas | `core-thing-name-cn` Exemplo: `MyCoreThing-c01` `n` é um número inteiro que começa com 00 e é incrementado a cada nova conexão até um número máximo de 250. O número de conexões é determinado pelo número de dispositivos que sincronizam o estado de shadow com o AWS IoT Core (máximo de 2.500 por grupo) e o número de assinaturas com `cloud` como origem no grupo (máximo de 10.000 por grupo). O componente do sistema de spooler se conecta com o AWS IoT Core para trocar mensagens de assinaturas com uma nuvem de origem ou de destino. O spooler também atua como proxy para troca de mensagens entre o serviço paralelo local AWS IoT Core e o gerenciador de certificados de dispositivos. |
Para calcular o número de conexões MQTT por grupo, use a seguinte fórmula:
`number of MQTT connections per group = number of connections for Deployment Agent + number of connections for Subscriptions`
Onde,
+ número de conexões para o atendente de implantação = 1.
+ número de conexões para assinaturas = `(2 subscriptions for supporting certificate generation + number of MQTT topics in AWS IoT Core + number of device shadows synced) / 50`.
+ Onde, `50` = o número máximo de assinaturas por conexão que AWS IoT Core podem ser suportadas.
**nota**
Se você habilitar [sessões persistentes](#mqtt-persistent-sessions) para assinatura com AWS IoT Core, o núcleo abrirá pelo menos uma conexão adicional para uso em uma sessão persistente. Os componentes do sistema não são compatíveis com sessões persistentes, por isso não podem compartilhar essa conexão.
Para reduzir o número de conexões MQTT e ajudar a reduzir custos, você pode usar as funções locais do Lambda para agregar dados na borda. Em seguida, você envia os dados agregados para o Nuvem AWS. Como resultado, você usa menos tópicos do MQTT em AWS IoT Core. Para obter mais informações, consulte [Preços do AWS IoT Greengrass](https://aws.amazon.com/greengrass/pricing/).
------
#### [ GGC v1.8 ]
Vários componentes do sistema do Greengrass abrem conexões MQTT com o AWS IoT Core. Esses componentes usam os seguintes padrões para gerar o cliente IDs para as conexões.
| Operation | Padrão de ID de cliente |
| --- | --- |
| Implantações | `core-thing-name` Exemplo: `MyCoreThing` Use esse ID de cliente para se conectar, desconectar, assinar e cancelar a assinatura de notificações de eventos de ciclo de vida. |
| Troca de mensagens MQTT com AWS IoT Core | `core-thing-name-spr` Exemplo: `MyCoreThing-spr` |
| Sincronização de sombra | `core-thing-name-snn` Exemplo: `MyCoreThing-s01` `nn` é um número inteiro que começa em 00 e é incrementado a cada nova conexão até um máximo de 03. O número de conexões é determinado pelo número de dispositivos (máximo de 200 dispositivos por grupo) com os quais sincronizam seu estado de sombra AWS IoT Core (máximo de 50 assinaturas por conexão). |
| Gerenciamento de certificados do dispositivo | `core-thing-name-dcm` Exemplo: `MyCoreThing-dcm` |
------
**nota**
O cliente duplicado IDs usado em conexões simultâneas pode causar um loop infinito de conexão e desconexão. Isso pode acontecer se outro dispositivo for codificado para usar o nome do dispositivo de núcleo como o ID do cliente nas conexões. Para obter mais informações, consulte esta [etapa de solução de problemas](gg-troubleshooting.md#config-client-id).
Os Dispositivos Greengrass também são totalmente integrados ao serviço de indexação de frota do AWS IoT Device Management. Isso permite indexar e pesquisar dispositivos com base nos atributos do dispositivo, no estado da sombra e no estado da conexão na nuvem. Por exemplo, os Dispositivos Greengrass estabelecem pelo menos uma conexão que usa o nome da coisa como o ID do cliente. Assim, é possível usar a indexação de conectividade do dispositivo para descobrir quais Dispositivos Greengrass estão conectados ou desconectados do AWS IoT Core no momento. Para obter mais informações, consulte [Serviço de indexação de frota](https://docs.aws.amazon.com/iot/latest/developerguide/iot-indexing.html) no *Guia do desenvolvedor do AWS IoT *.
### Configurar a porta MQTT para mensagens locais
Esse recurso requer o AWS IoT Greengrass Core v1.10 ou posterior.
O núcleo do Greengrass atua como atendente de mensagens local para mensagens MQTT entre funções locais do Lambda, conectores e [dispositivos cliente](what-is-gg.md#greengrass-devices). Por padrão, o núcleo usa a porta 8883 para o tráfego MQTT na rede local. Talvez você queira alterar a porta para evitar um conflito com outro software executado na porta 8883.
**Para configurar o número da porta usada pelo núcleo para o tráfego MQTT local**
1. Execute o comando a seguir para interromper o daemon do Greengrass:
```
cd /greengrass-root/ggc/core/
sudo ./greengrassd stop
```
1. Abra `greengrass-root/config/config.json` para editar como o usuário su.
1. No objeto `coreThing`, adicione a propriedade `ggMqttPort` e defina o valor para o número da porta que você deseja usar. Os valores válidos são de 1024 a 65535. O exemplo a seguir define o número da porta como `9000`.
```
{
"coreThing" : {
"caPath" : "root.ca.pem",
"certPath" : "12345abcde.cert.pem",
"keyPath" : "12345abcde.private.key",
"thingArn" : "arn:aws:iot:us-west-2:123456789012:thing/core-thing-name",
"iotHost" : "abcd123456wxyz-ats.iot.us-west-2.amazonaws.com",
"ggHost" : "greengrass-ats.iot.us-west-2.amazonaws.com",
"ggMqttPort" : 9000,
"keepAlive" : 600
},
...
}
```
1. Inicie o daemon.
```
cd /greengrass-root/ggc/core/
sudo ./greengrassd start
```
1. Se a [detecção automática de IP](#ip-auto-detect) estiver habilitada para o núcleo, a configuração será concluída.
Se a detecção automática de IP não estiver habilitada, você deverá atualizar as informações de conectividade para o núcleo. Isso permite que os dispositivos cliente recebam o número de porta correto durante as operações de descoberta para adquirir informações de conectividade de núcleo. Você pode usar o AWS IoT console ou a AWS IoT Greengrass API para atualizar as principais informações de conectividade. Para esse procedimento, atualize apenas o número da porta. O endereço IP local do núcleo permanece o mesmo.
**Para atualizar as informações de conectividade para o núcleo (console)**
1. Na página de configuração do grupo, selecione o núcleo do Greengrass.
1. Na página de detalhes do núcleo, selecione a guia de **endpoints do atendente MQTT**.
1. Selecione **Gerenciar endpoints** e, em seguida, **Add endpoint (Adicionar endpoint)**.
1. Insira seu endereço IP local atual e o novo número da porta. O exemplo a seguir define o número da porta `9000` para o endereço IP `192.168.1.8`.
1. Remova o endpoint obsoleto e selecione **Update (Atualizar)**
**Atualizar as informações de conectividade para o núcleo (API)**
+ Use a ação [UpdateConnectivityInfo](https://docs.aws.amazon.com/greengrass/v1/apireference/updateconnectivityinfo-put.html). O exemplo a seguir usa `update-connectivity-info` na AWS CLI para definir o número da porta `9000` para o endereço IP `192.168.1.8`.
```
aws greengrass update-connectivity-info \
--thing-name "MyGroup_Core" \
--connectivity-info "[{\"Metadata\":\"\",\"PortNumber\":9000,\"HostAddress\":\"192.168.1.8\",\"Id\":\"localIP_192.168.1.8\"},{\"Metadata\":\"\",\"PortNumber\":8883,\"HostAddress\":\"127.0.0.1\",\"Id\":\"localhost_127.0.0.1_0\"}]"
```
**nota**
Você também pode configurar a porta que o núcleo usa para mensagens MQTT. AWS IoT Core Para obter mais informações, consulte [Conectar-se à porta 443 ou por meio de um proxy de rede](#alpn-network-proxy).
### Tempo limite para operações de publicação, assinatura e cancelamento de assinatura em conexões MQTT com o Nuvem AWS
Esse recurso está disponível na AWS IoT Greengrass versão v1.10.2 ou posterior.
É possível configurar a quantidade de tempo (em segundos) para permitir que o núcleo do Greengrass conclua uma operação de publicação, assinatura ou cancelamento de assinatura em conexões MQTT ao AWS IoT Core. Talvez você queira ajustar essa configuração se as operações atingirem o tempo limite devido a restrições de largura de banda ou à alta latência. Para definir essa configuração no arquivo [config.json](#config-json), adicione ou altere a propriedade `mqttOperationTimeout` no objeto `coreThing`. Por exemplo:
```
{
"coreThing": {
"mqttOperationTimeout": 10,
"caPath": "root-ca.pem",
"certPath": "hash.cert.pem",
"keyPath": "hash.private.key",
...
},
...
}
```
O tempo limite padrão é 5 segundos. O tempo limite mínimo é de 5 segundos.
## Ativar detecção automática de IP
Você pode configurar AWS IoT Greengrass para permitir que dispositivos cliente em um grupo do Greengrass descubram automaticamente o núcleo do Greengrass. Quando ativado, o núcleo observa as alterações em seus endereços IP. Se um endereço mudar, o núcleo publica uma lista atualizada de endereços. Esses endereços são disponibilizados para dispositivos cliente que estão no mesmo grupo do Greengrass que o núcleo.
**nota**
A AWS IoT política para dispositivos cliente deve conceder a `greengrass:Discover` permissão para permitir que os dispositivos recuperem informações de conectividade para o núcleo. Para obter mais informações sobre a declaração de política, consulte [Autorização de descoberta](gg-discover-api.md#gg-discover-auth).
Para ativar esse recurso no AWS IoT Greengrass console, escolha **Detecção automática** ao implantar seu grupo do Greengrass pela primeira vez. Você também pode ativar ou desativar esse atributo na página de configuração do grupo escolhendo a guia **Funções do Lambda** e selecionando o **Detector de IP**. A detecção automática de IP é habilitada se **Automatically detect and override MQTT broker endpoints (Detectar e substituir automaticamente os endpoints de atendente MQTT)** estiver selecionado.
Para gerenciar a descoberta automática com a AWS IoT Greengrass API, você deve configurar a função Lambda `IPDetector` do sistema. O procedimento a seguir mostra como usar o comando [ create-function-definition-version](https://docs.aws.amazon.com/cli/latest/reference/greengrass/create-function-definition-version.html)CLI para configurar a descoberta automática do núcleo do Greengrass.
1. Obtenha o grupo alvo IDs do Greengrass e a versão do grupo. Esse procedimento pressupõe que esse seja o grupo e a versão mais recente do grupo. A consulta a seguir retorna o grupo criado mais recentemente.
```
aws greengrass list-groups --query "reverse(sort_by(Groups, &CreationTimestamp))[0]"
```
Ou é possível consultar por nome. Os nomes de grupo não precisam ser exclusivos, portanto, vários grupos podem ser retornados.
```
aws greengrass list-groups --query "Groups[?Name=='MyGroup']"
```
**nota**
Você também pode encontrar esses valores no AWS IoT console. O ID do grupo é exibido na página **Settings (Configurações)** do grupo. IDs As versões do grupo são exibidas na guia **Implantações** do grupo.
1. Copie os valores `Id` e `LatestVersion` do grupo de destino na saída.
1. Obtenha a versão do grupo mais recente.
+ Substitua *group-id* pelo `Id` que você copiou.
+ Substitua *latest-group-version-id* pelo `LatestVersion` que você copiou.
```
aws greengrass get-group-version \
--group-id group-id \
--group-version-id latest-group-version-id
```
1. Do `Definition` objeto na saída, `CoreDefinitionVersionArn` copie o e o ARNs de todos os outros componentes do grupo, exceto`FunctionDefinitionVersionArn`. Você usa esses valores ao criar uma nova versão do grupo.
1. No `FunctionDefinitionVersionArn` na saída, copie o ID da definição de função e a versão de definição de função.
```
arn:aws:greengrass:region:account-id:/greengrass/groups/function-definition-id/versions/function-definition-version-id
```
**nota**
Você também pode criar uma definição de função executando o comando [https://docs.aws.amazon.com/cli/latest/reference/greengrass/create-function-definition.html](https://docs.aws.amazon.com/cli/latest/reference/greengrass/create-function-definition.html) e copiar o ID da saída.
1. Use o comando [https://docs.aws.amazon.com/cli/latest/reference/greengrass/get-function-definition-version.html](https://docs.aws.amazon.com/cli/latest/reference/greengrass/get-function-definition-version.html) para obter o estado da definição atual. Use o *function-definition-id* que você copiou para a definição da função. Por exemplo, .*4d941bc7-92a1-4f45-8d64-EXAMPLEf76c3*
```
aws greengrass get-function-definition-version
--function-definition-id function-definition-id
--function-definition-version-id function-definition-version-id
```
Anote os valores das configurações de função listados. Você precisará incluí-los ao criar uma nova versão de definição de função para evitar a perda de suas configurações de definição atuais.
1. Adicione uma versão de definição de função à definição da função.
+ *function-definition-id*Substitua pelo `Id` que você copiou para a definição da função. Por exemplo, .*4d941bc7-92a1-4f45-8d64-EXAMPLEf76c3*
+ *arbitrary-function-id*Substitua por um nome para a função, como**auto-detection-function**.
+ Adicione todas as funções do Lambda que você deseja incluir nesta versão à matriz `functions`, como as listadas na etapa anterior.
```
aws greengrass create-function-definition-version \
--function-definition-id function-definition-id \
--functions '[{"FunctionArn":"arn:aws:lambda:::function:GGIPDetector:1","Id":"arbitrary-function-id","FunctionConfiguration":{"Pinned":true,"MemorySize":32768,"Timeout":3}}]'\
--region us-west-2
```
1. Copie o `Arn` da versão da definição de função da saída.
1. Crie uma versão do grupo que contém a função do Lambda definida pelo sistema.
+ *group-id*Substitua `Id` pelo para o grupo.
+ *core-definition-version-arn*Substitua pelo `CoreDefinitionVersionArn` que você copiou da versão mais recente do grupo.
+ *function-definition-version-arn*Substitua pelo `Arn` que você copiou para a nova versão de definição de função.
+ Substitua o ARNs por outros componentes do grupo (por exemplo, `SubscriptionDefinitionVersionArn` ou`DeviceDefinitionVersionArn`) que você copiou da versão mais recente do grupo.
+ Remova todos os parâmetros inutilizados. Por exemplo, remova a versão `--resource-definition-version-arn` caso a versão do grupo não contenha recursos.
```
aws greengrass create-group-version \
--group-id group-id \
--core-definition-version-arn core-definition-version-arn \
--function-definition-version-arn function-definition-version-arn \
--device-definition-version-arn device-definition-version-arn \
--logger-definition-version-arn logger-definition-version-arn \
--resource-definition-version-arn resource-definition-version-arn \
--subscription-definition-version-arn subscription-definition-version-arn
```
1. Copie a `Version` da saída. Este é o ID da nova versão do grupo.
1. Implante o grupo com a nova versão do grupo.
+ *group-id*Substitua pelo `Id` que você copiou para o grupo.
+ *group-version-id*Substitua pelo `Version` que você copiou para a nova versão do grupo.
```
aws greengrass create-deployment \
--group-id group-id \
--group-version-id group-version-id \
--deployment-type NewDeployment
```
Se quiser incluir manualmente o endereço IP do núcleo do Greengrass, conclua este tutorial com uma definição de função diferente que não inclua a função `IPDetector`. Isso impedirá que a função de detecção localize e automaticamente e insira seu endereço IP do núcleo do Greengrass.
Essa função do Lambda do sistema não está visível no console do Lambda. Depois que a função for adicionada à versão do grupo mais recente, ela será incluída nas implantações que você fizer com o console (a menos que você use a API para substituí-la ou removê-la).
## Configurar o sistema init para iniciar o daemon do Greengrass
Trata-se de uma prática recomendada configurar o sistema init para iniciar o daemon do Greengrass durante a inicialização, especialmente ao gerenciar grandes frotas de dispositivos.
**nota**
Se você costumava `apt` instalar o software AWS IoT Greengrass Core, você pode usar os scripts systemd para ativar a inicialização na inicialização. Para obter mais informações, consulte [Usar scripts systemd para gerenciar o ciclo de vida do daemon do Greengrass](install-ggc.md#ggc-package-manager-systemd).
Há tipos diferentes de sistema init, como initd, systemd e SystemV, e eles usam parâmetros de configuração semelhantes. O exemplo a seguir é um arquivo de serviço systemd. O parâmetro `Type` é definido como `forking` porque greengrassd (que é usado para iniciar o Greengrass) divide o processo de daemon do Greengrass, e o parâmetro `Restart` é definido como `on-failure` para direcionar systemd a fim de reiniciar o Greengrass caso o Greengrass entre em um estado de falha.
**nota**
Para ver se o dispositivo usa systemd, execute o script `check_ggc_dependencies` conforme descrito em [Módulo 1](module1.md). Em seguida, para usar systemd, verifique se o parâmetro `useSystemd` em [`config.json`](#config-json) está definido como `yes`.
```
[Unit]
Description=Greengrass Daemon
[Service]
Type=forking
PIDFile=/var/run/greengrassd.pid
Restart=on-failure
ExecStart=/greengrass/ggc/core/greengrassd start
ExecReload=/greengrass/ggc/core/greengrassd restart
ExecStop=/greengrass/ggc/core/greengrassd stop
[Install]
WantedBy=multi-user.target
```
## Consulte também
+ [O que é AWS IoT Greengrass?](what-is-gg.md)
+ [Plataformas compatíveis e requisitos](what-is-gg.md#gg-platforms)
+ [Começando com AWS IoT Greengrass](gg-gs.md)
+ [Visão geral do modelo de objeto de AWS IoT Greengrass grupo](deployments.md#api-overview)
+ [Integração de segurança de hardware](hardware-security.md)