终止支持通知：2026 年 10 月 7 日， AWS 将停止对的支持。 AWS IoT Greengrass Version 1 2026 年 10 月 7 日之后，您将无法再访问这些 AWS IoT Greengrass V1 资源。如需了解更多信息，请访问[迁移自 AWS IoT Greengrass Version 1](https://docs.aws.amazon.com/greengrass/v2/developerguide/migrate-from-v1.html)。
本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。
# 配置内 AWS IoT Greengrass 核
AWS IoT Greengrass 核心是在边缘环境中充当集线器或网关的 AWS IoT 东西（设备）。与其他 AWS IoT 设备一样，内核存在于注册表中，具有设备影子，并使用设备证书对 AWS IoT Core 和进行身份验证 AWS IoT Greengrass。核心设备运行 AWS IoT Greengrass Core 软件，以使其可以管理 Greengrass 组的本地进程，如通信、影子同步和令牌交换。
AWS IoT Greengrass 核心软件提供以下功能：
+ 连接器和 Lambda 函数的部署和本地运行。
+ 在本地处理数据流，并自动导出到 AWS Cloud。
+ 使用托管订阅通过本地网络在设备、连接器和 Lambda 函数之间进行的 MQTT 消息传递。
+ 使用托管订阅在设备、连接器 AWS IoT 和 Lambda 函数之间进行 MQTT 消息传递。
+ 设备与 AWS Cloud 使用设备身份验证和授权之间的安全连接。
+ 设备的本地影子同步。影子可配置为与 AWS Cloud同步。
+ 对本地设备和卷资源的受控访问。
+ 用于运行本地推理的云训练机器学习模型的部署。
+ 使设备能够发现 Greengrass 核心设备的自动 IP 地址检测。
+ 全新的或更新的组配置的集中部署。下载配置数据后，核心设备将自动重启。
+ 对用户定义的 Lambda 函数进行安全 over-the-air (OTA) 软件更新。
+ 本地密钥的安全、加密的存储以及连接器和 Lambda 函数进行的受控访问。
## AWS IoT Greengrass 核心配置文件
AWS IoT Greengrass 核心软件的配置文件是`config.json`。它位于 `/greengrass-root/config` 目录中。
**注意**
*greengrass-root*表示 C AWS IoT Greengrass ore 软件在您的设备上的安装路径。通常，这是 `/greengrass` 目录。
如果您使用 AWS IoT Greengrass 控制台中的**默认组创建**选项，则`config.json`文件将以工作状态部署到核心设备。
您可以运行以下命令以查看该文件的内容：
```
cat /greengrass-root/config/config.json
```
下面是一个 `config.json` 示例文件。这是你从 AWS IoT Greengrass 控制台创建核心时生成的版本。
------
#### [ 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"
}
```
`config.json` 文件支持以下属性：
**coreThing**
| Field | 描述 | 注意 |
| --- | --- | --- |
| caPath | AWS IoT 根 CA 相对于`/greengrass-root/certs`目录的路径。 | 为了向后兼容 1.7.0 之前的版本。当 `crypto` 对象存在时，该属性将被忽略。 确保您的[终端节点与证书类型对应](#certificate-endpoints)。 |
| certPath | 核心设备证书相对于 `/greengrass-root/certs` 目录的路径。 | 为了向后兼容 1.7.0 之前的版本。当 crypto 对象存在时，该属性将被忽略。 |
| keyPath | 核心私有密钥的相对于 /greengrass-root/certs 目录的路径。 | 为了向后兼容 1.7.0 之前的版本。当 crypto 对象存在时，该属性将被忽略。 |
| thingArn | 代表 AWS IoT Greengrass 核心设备的 AWS IoT 物体的亚马逊资源名称 (ARN)。 | 在 AWS IoT Greengrass 控制台的 “内核” 下或运行 CL [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)I 命令来查找您的核心的 ARN。 |
| iotHost | 您的 AWS IoT 终端节点。 | 在 AWS IoT 控制台的 **“设置”** 下或运行 [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 命令来查找终端节点。 此命令将返回 Amazon Trust Services (ATS) 终端节点。有关更多信息，请参阅[服务器身份验证](https://docs.aws.amazon.com/iot/latest/developerguide/server-authentication.html)文档。 确保您的[终端节点与证书类型对应](#certificate-endpoints)。 确保您的 [ 端点与 AWS 区域](https://docs.aws.amazon.com/general/latest/gr/greengrass.html) 对应。 |
| ggHost | 您的 AWS IoT Greengrass 终端节点。 | 这是您的 `iotHost` 终端节点，其主机前缀将替换为 *greengrass*（例如，`greengrass-ats.iot.region.amazonaws.com`）。使用与之 AWS 区域 相同`iotHost`。 确保您的[终端节点与证书类型对应](#certificate-endpoints)。 确保您的 [ 端点与 AWS 区域](https://docs.aws.amazon.com/general/latest/gr/greengrass.html) 对应。 |
| iotMqttPort | 可选。用于与 MQTT 通信的 AWS IoT端口号。 | 有效值为 8883 或 443。默认值为 8883。有关更多信息，请参阅 [通过端口 443 或网络代理进行连接](#alpn-network-proxy)。 |
| iotHttpPort | 可选。用于创建到 AWS IoT的 HTTPS 连接的端口号。 | 有效值为 8443 或 443。默认值为 8443。有关更多信息，请参阅 [通过端口 443 或网络代理进行连接](#alpn-network-proxy)。 |
| ggMqttPort | 可选。用于通过本地网络进行 MQTT 通信的端口号。 | 有效值为 1024 到 65535。默认值为 8883。有关更多信息，请参阅 [为本地消息收发配置 MQTT 端口](#config-local-mqtt-port)。 |
| ggHttpPort | 可选。用于创建到 AWS IoT Greengrass 服务的 HTTPS 连接的端口号。 | 有效值为 8443 或 443。默认值为 8443。有关更多信息，请参阅 [通过端口 443 或网络代理进行连接](#alpn-network-proxy)。 |
| keepAlive | 可选。MQTT KeepAlive 周期 (以秒为单位)。 | 有效范围在 30 到 1200 秒之间。默认值为 600。 |
| networkProxy | 可选。一个对象，它定义要连接到的代理服务器。 | 代理服务器可以是 HTTP，也可以是 HTTPS。有关更多信息，请参阅 [通过端口 443 或网络代理进行连接](#alpn-network-proxy)。 |
| mqttOperationTimeout | 可选。允许 Greengrass 核心在与 AWS IoT Core的 MQTT 连接中完成发布、订阅或取消订阅操作的时间（以秒为单位）。 | 默认值为 5。最小值为 5。 |
| ggDaemonPort | 可选。Greengrass 核心 IPC 端口号。 | 此属性在 AWS IoT Greengrass v1.11.0 或更高版本中可用。 有效值在 1024 到 65535 之间。默认值是 8000。 |
| systemComponentAuthTimeout | 可选。允许 Greengrass core IPC 完成身份验证的时间（以毫秒为单位）。 | 此属性在 AWS IoT Greengrass v1.11.0 或更高版本中可用。 有效值在 500 到 5000 之间。默认值是 5000。 |
**runtime**
| Field | 描述 | 注意 |
| --- |--- |--- |
| maxWorkItemCount | 可选。Greengrass 守护程序一次可以处理的最大工作项数。超过此限制的请求将被忽略。 工作项队列由系统组件、用户定义的 Lambda 函数和连接器共享。 | 默认值是 1024。最大值受设备硬件限制。 增加此值会增加 AWS IoT Greengrass 使用的内存。如果您希望核心接收大量 MQTT 消息流量，则可以增加此值。 |
| maxConcurrentLimit | 可选。Greengrass 守护程序可以拥有的并发未固定 Lambda 工作线程的最大数量。您可以指定一个不同的整数来覆盖此参数。 | 默认值为 25。最小值由 `lruSize` 定义。 |
| lruSize | 可选。定义的最小值maxConcurrentLimit。 | 默认值为 25。 |
| mountAllBlockDevices | 可选。 AWS IoT Greengrass 在设置 OverlayFS 后，允许使用绑定挂载将所有块设备装载到容器中。 | 此属性在 AWS IoT Greengrass v1.11.0 或更高版本中可用。 有效值为 `yes` 和 `no`。默认值为 `no`。 如果您的 `/usr` 目录不在 `/` 层次结构之下，请将此值设置为 `yes`。 |
| postStartHealthCheckTimeout | 可选。Greengrass 守护程序在启动后等待运行状况检查完成的时间（以毫秒为单位）。 | 默认超时时间为 30 秒（30000 毫秒）。 |
| `cgroup` |
| --- |
| useSystemd | 指示您的设备是否使用 [https://en.wikipedia.org/wiki/Systemd](https://en.wikipedia.org/wiki/Systemd)。 | 有效值为 yes 或 no。运行check\$1ggc\$1dependencies模块 1[ 中的 ](module1.md) 脚本以查看您的设备是否使用 systemd。 |
**crypto**
`crypto` 包含一些属性，这些属性通过 PKCS \$1 11 和本地密钥存储支持硬件安全模块 (HSM) 上的私有密钥存储。有关更多信息，请参阅 [AWS IoT Greengrass 核心安全主体](gg-sec.md#gg-principals)、[硬件安全性集成](hardware-security.md) 和 [将机密部署到核 AWS IoT Greengrass 心](secrets.md)。支持文件系统上 HSMs 或文件系统中的私钥存储配置。
| 字段 | 描述 | 注意 |
| --- |--- |--- |
| caPath | AWS IoT 根 CA 的绝对路径。 | 必须为以下格式的文件 URI：`file:///absolute/path/to/file`。 确保您的[终端节点与证书类型对应](#certificate-endpoints)。 |
| `PKCS11` |
| --- |
| OpenSSLEngine | 可选。OpenSSL 引擎 `.so` 文件（用于在 OpenSSL 上启用 PKCS \$1 11 支持）的绝对路径。 | 必须是文件系统上的文件的路径。 如果您使用 Greengrass OTA 更新代理来实现硬件安全性，则此属性是必需的。有关更多信息，请参阅 [配置对 over-the-air更新的支持](hardware-security.md#hardware-security-ota-updates)。 |
| P11Provider | PKCS\$111 实施的 libdl-loadable 库的绝对路径。 | 必须是文件系统上的文件的路径。 |
| slotLabel | 用于标识硬件模块的槽标签。 | 必须符合 PKCS \$1 11 标签规范。 |
| slotUserPin | 用于对模块的 Greengrass 核心进行身份验证的用户 PIN。 | 必须具有足够的权限才能使用配置的私有密钥执行 C\$1Sign。 |
| `principals` |
| --- |
| IoTCertificate | 核心用于向 AWS IoT发出请求的证书和私有密钥。 |
| IoTCertificate .privateKeyPath | 核心私有密钥的路径。 | 对于文件系统存储，必须为以下格式的文件 URI：`file:///absolute/path/to/file`。 对于 HSM 存储，必须是指定对象标签的 [RFC 7512 PKCS\$111](https://tools.ietf.org/html/rfc7512) 路径。 |
| IoTCertificate .certificatePath | 核心设备证书的绝对路径。 | 必须为以下格式的文件 URI：`file:///absolute/path/to/file`。 |
| MQTTServerCertificate | 可选。核心为充当 MQTT 服务器或网关而将其证书结合使用的私有密钥。 |
| MQTTServerCertificate .privateKeyPath | 本地 MQTT 服务器私有密钥的路径。 | 使用此值为本地 MQTT 服务器指定您自己的私有密钥。 对于文件系统存储，必须为以下格式的文件 URI：`file:///absolute/path/to/file`。 对于 HSM 存储，必须是指定对象标签的 [RFC 7512 PKCS\$111](https://tools.ietf.org/html/rfc7512) 路径。 如果省略此属性，则根据您的 AWS IoT Greengrass 旋转设置旋转密钥。如果指定，客户将负责对密钥进行轮换。 |
| SecretsManager | 保护用于加密的数据密钥的私有密钥。有关更多信息，请参阅 [将机密部署到核 AWS IoT Greengrass 心](secrets.md)。 |
| SecretsManager .privateKeyPath | 本地 Secrets Manager 私有密钥的路径。 | 仅支持 RSA 密钥。 对于文件系统存储，必须为以下格式的文件 URI：`file:///absolute/path/to/file`。 对于 HSM 存储，必须是指定对象标签的 [RFC 7512 PKCS\$111](https://tools.ietf.org/html/rfc7512) 路径。必须使用 [PKCS\$11 v1.5](https://tools.ietf.org/html/rfc2313) 填充机制生成私有密钥。 |
此外，还支持以下配置属性：
****
| Field | 描述 | 注意 |
| --- | --- | --- |
| mqttMaxConnectionRetryInterval | 可选。在 MQTT 连接断开时的最大连接重试间隔（以秒为单位）。 | 将该值指定为无符号整数。默认值为 `60`。 |
| managedRespawn | 可选。指示 OTA 代理在更新之前需要运行自定义代码。 | 有效值为 `true` 或 `false`。有关更多信息，请参阅 [AWS IoT Greengrass 核心软件的 OTA 更新](core-ota-update.md)。 |
| writeDirectory | 可选。 AWS IoT Greengrass 创建所有 read/write 资源的写入目录。 | 有关更多信息，请参阅 [为配置写入目录 AWS IoT Greengrass](#write-directory)。 |
| pidFileDirectory | 可选。 AWS IoT Greengrass 将其进程 ID (PID) 存储在此目录下。 | 默认值为 `/var/run`。 |
------
#### [ Extended life versions ]
以下版本的 AWS IoT Greengrass Core 软件处于[延长使用寿命阶段](maintenance-policy.md)。此信息仅供参考。
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"
}
}
```
`config.json` 文件支持以下属性：
**coreThing**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/greengrass/v1/developerguide/gg-core.html)
**runtime**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/greengrass/v1/developerguide/gg-core.html)
**crypto**
`crypto` 包含一些属性，这些属性通过 PKCS \$1 11 和本地密钥存储支持硬件安全模块 (HSM) 上的私有密钥存储。有关更多信息，请参阅 [AWS IoT Greengrass 核心安全主体](gg-sec.md#gg-principals)、[硬件安全性集成](hardware-security.md) 和 [将机密部署到核 AWS IoT Greengrass 心](secrets.md)。支持文件系统上 HSMs 或文件系统中的私钥存储配置。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/greengrass/v1/developerguide/gg-core.html)
此外，还支持以下配置属性：
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/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"
}
}
```
`config.json` 文件支持以下属性：
**coreThing**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/greengrass/v1/developerguide/gg-core.html)
**runtime**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/greengrass/v1/developerguide/gg-core.html)
**crypto**
在 v1.7.0 中新增了 `crypto` 对象。它引入了一些属性，这些属性通过 PKCS \$1 11 和本地密钥存储支持硬件安全模块 (HSM) 上的私有密钥存储。有关更多信息，请参阅 [AWS IoT Greengrass 核心安全主体](gg-sec.md#gg-principals)、[硬件安全性集成](hardware-security.md) 和 [将机密部署到核 AWS IoT Greengrass 心](secrets.md)。支持文件系统上 HSMs 或文件系统中的私钥存储配置。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/greengrass/v1/developerguide/gg-core.html)
此外，还支持以下配置属性。
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/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"
}
}
```
`config.json` 文件支持以下属性。
**coreThing**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/greengrass/v1/developerguide/gg-core.html)
**runtime**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/greengrass/v1/developerguide/gg-core.html)
**crypto**
在 v1.7.0 中新增了 `crypto` 对象。它引入了一些属性，这些属性通过 PKCS \$1 11 和本地密钥存储支持硬件安全模块 (HSM) 上的私有密钥存储。有关更多信息，请参阅 [AWS IoT Greengrass 核心安全主体](gg-sec.md#gg-principals)、[硬件安全性集成](hardware-security.md) 和 [将机密部署到核 AWS IoT Greengrass 心](secrets.md)。支持文件系统上 HSMs 或文件系统中的私钥存储配置。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/greengrass/v1/developerguide/gg-core.html)
此外，还支持以下配置属性：
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/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"
}
}
```
`config.json` 文件支持以下属性：
**coreThing**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/greengrass/v1/developerguide/gg-core.html)
**runtime**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/greengrass/v1/developerguide/gg-core.html)
**crypto**
`crypto` 对象（在版本 1.7.0 中添加）引入了一些属性，这些属性通过 PKCS \$1 11 和本地密钥存储支持硬件安全模块 (HSM) 上的私有密钥存储。有关更多信息，请参阅[硬件安全性集成](hardware-security.md)和[将机密部署到核 AWS IoT Greengrass 心](secrets.md)。支持文件系统上 HSMs 或文件系统中的私钥存储配置。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/greengrass/v1/developerguide/gg-core.html)
此外，还支持以下配置属性：
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/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"
}
```
如果您使用 AWS IoT Greengrass 控制台中的**默认组创建**选项，则`config.json`文件将以指定默认配置的工作状态部署到核心设备。
`config.json` 文件支持以下属性：
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/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
}
```
`config.json` 文件位于 `/greengrass-root/config` 中并包含以下参数：
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/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
}
```
`config.json` 文件位于 `/greengrass-root/config` 中并包含以下参数：
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/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"
}
}
}
```
`config.json` 文件位于 `/greengrass-root/config` 中并包含以下参数：
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/greengrass/v1/developerguide/gg-core.html)
**GGC v1.0**
在 AWS IoT Greengrass 酷睿 v1.0 中，`config.json`已部署到。`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"
}
}
}
```
`config.json` 文件位于 `/greengrass-root/configuration` 中并包含以下参数：
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/greengrass/v1/developerguide/gg-core.html)
------
## 服务端点必须与根 CA 证书类型匹配
您的 AWS IoT Core 和 AWS IoT Greengrass 端点必须与设备上根 CA 证书的证书类型相对应。如果端点和证书类型不匹配，则设备和 AWS IoT Core 或之间的身份验证尝试将失败 AWS IoT Greengrass。有关更多信息，请参阅《AWS IoT 开发人员指南》**中的[服务器身份验证](https://docs.aws.amazon.com/iot/latest/developerguide/server-authentication.html)。
如果您的设备使用 Amazon Trust Services (ATS) 根 CA 证书（首选方法），则设备还必须使用 ATS 端点执行设备管理和发现数据层面操作。ATS 端点包括`ats`分段，如以下 AWS IoT Core 端点语法所示。
```
prefix-ats.iot.region.amazonaws.com
```
**注意**
为了向后兼容， AWS IoT Greengrass 目前在某些版本中支持传统的 VeriSign 根 CA 证书和端 AWS 区域点。如果您使用的是旧版 VeriSign根 CA 证书，我们建议您创建 ATS 端点并改用 ATS 根 CA 证书。否则，请确保使用相应的旧版端点。有关更多信息，请参阅《Amazon Web Services 一般参考》**中的[支持的旧版端点](https://docs.aws.amazon.com/general/latest/gr/greengrass.html#greengrass-legacy-endpoints)。
### config.json 中的终端节点
在 Greengrass 核心设备上，终端节点是在 [`config.json`](#config-json) 文件中的 `coreThing` 对象中指定的。该`iotHost`属性代表 AWS IoT Core 端点。该`ggHost`属性代表 AWS IoT Greengrass 端点。在以下示例片段中，这些属性指定了 ATS 终端节点。
```
{
"coreThing" : {
...
"iotHost" : "abcde1234uwxyz-ats.iot.us-west-2.amazonaws.com",
"ggHost" : "greengrass-ats.iot.us-west-2.amazonaws.com",
...
},
```
**AWS IoT Core 终端节点**
您可以通过运行带有相应`--endpoint-type`参数的 [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 命令来获取 AWS IoT Core 终端节点。
+ 要返回 ATS 签名的终端节点，请运行：
```
aws iot describe-endpoint --endpoint-type iot:Data-ATS
```
+ 要返回旧版 VeriSign 签名端点，请运行：
```
aws iot describe-endpoint --endpoint-type iot:Data
```
**AWS IoT Greengrass 终端节点**
您的 AWS IoT Greengrass 终端节点是您的终`iotHost`端节点，其主机前缀替换为 *greengras* s。例如，ATS 签名的终端节点是 `greengrass-ats.iot.region.amazonaws.com`。这使用与您的 AWS IoT Core 终端节点相同的区域。
## 通过端口 443 或网络代理进行连接
此功能适用于 AWS IoT Greengrass 酷睿 v1.7 及更高版本。
Greengrass 内核使用 AWS IoT Core 带有 TLS 客户端身份验证的 MQTT 消息协议进行通信。按照惯例，基于 TLS 的 MQTT 使用端口 8883。但是，作为一项安全措施，限制性环境可能会将入站和出站流量限制到一个较小的 TCP 端口范围。例如，企业防火墙可能会为 HTTPS 流量打开端口 443，但关闭不常用协议使用的其他端口，例如用于 MQTT 流量的端口 8883。其他限制性环境可能要求所有流量经由 HTTP 代理连接到 Internet。
要在这些情况下启用通信，请 AWS IoT Greengrass 允许以下配置：
+ **在端口 443 上进行 MQTT 通信及 TLS 客户端身份验证**。如果网络允许连接到端口 443，则可以将核心配置为使用端口 443（而非默认端口 8883）进行 MQTT 通信。这可以是与端口 443 的直接连接，也可以是通过网络代理服务器的连接。
AWS IoT Greengrass 使用[应用层协议网络](https://tools.ietf.org/html/rfc7301) (ALPN) TLS 扩展来启用此连接。与默认配置一样，端口 443 上的基于 TLS 的 MQTT 使用基于证书的客户端身份验证。
当配置为使用与端口 443 的直接连接时，内核支持 [over-the-air (OTA) AWS IoT Greengrass 软件更新](core-ota-update.md)。此支持需要 AWS IoT Greengrass 酷睿 v1.9.3 或更高版本。
+ **通过端口 443 进行 HTTPS 通信**。 AWS IoT Greengrass 默认情况下，通过端口 8443 发送 HTTPS 流量，但您可以将其配置为使用端口 443。
+ **通过网络代理连接**。您可以配置一个网络代理服务器来充当连接到 Greengrass 核心的媒介。仅支持基本身份验证以及 HTTP 和 HTTPS 代理。
代理配置通过 `http_proxy`、`https_proxy` 和 `no_proxy` 环境变量传递给用户定义的 Lambda 函数。用户定义的 Lambda 函数必须使用这些传入的设置才能通过代理进行连接。Lambda 函数用于建立连接的公用库（例如 boto3 或 cURL 和 python `requests` 程序包）通常默认使用这些环境变量。如果 Lambda 函数还指定了这些相同的环境变量，则 AWS IoT Greengrass 不会覆盖它们。
**重要**
配置为使用网络代理的 Greengrass 核心不支持 [OTA 更新](core-ota-update.md)。
**通过端口 443 配置 MQTT**
此功能需要 AWS IoT Greengrass 酷睿 v1.7 或更高版本。
此过程使 Greengrass 核心能够使用端口 443 与 AWS IoT Core进行 MQTT 消息传递。
1. 运行以下命令以停止 Greengrass 进程守护程序：
```
cd /greengrass-root/ggc/core/
sudo ./greengrassd stop
```
1. 打开 `greengrass-root/config/config.json` 以作为 su 用户进行编辑。
1. 在 `coreThing` 对象中，添加 `iotMqttPort` 属性，并将该属性的值设置为 **443**，如以下示例所示。
```
{
"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. 启动守护程序。
```
cd /greengrass-root/ggc/core/
sudo ./greengrassd start
```
**通过端口 443 配置 HTTPS**
此功能需要 AWS IoT Greengrass 酷睿 v1.8 或更高版本。
该过程将核心配置为使用 443 进行 HTTPS 通信。
1. 运行以下命令以停止 Greengrass 进程守护程序：
```
cd /greengrass-root/ggc/core/
sudo ./greengrassd stop
```
1. 打开 `greengrass-root/config/config.json` 以作为 su 用户进行编辑。
1. 在 `coreThing` 对象中，添加 `iotHttpPort` 和 `ggHttpPort` 属性，如以下示例所示。
```
{
"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. 启动进程守护程序。
```
cd /greengrass-root/ggc/core/
sudo ./greengrassd start
```
**配置网络代理**
此功能需要 AWS IoT Greengrass 酷睿 v1.7 或更高版本。
此过程 AWS IoT Greengrass 允许通过 HTTP 或 HTTPS 网络代理连接到互联网。
1. 运行以下命令以停止 Greengrass 进程守护程序：
```
cd /greengrass-root/ggc/core/
sudo ./greengrassd stop
```
1. 打开 `greengrass-root/config/config.json` 以作为 su 用户进行编辑。
1. 在 `coreThing` 对象中，添加 [networkProxy](#networkProxy-object) 对象，如以下示例所示。
```
{
"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. 启动进程守护程序。
```
cd /greengrass-root/ggc/core/
sudo ./greengrassd start
```
**networkProxy 对象**
使用 `networkProxy` 对象指定有关网络代理的信息。此对象具有以下属性。
| 字段 | 说明 |
| --- | --- |
| noProxyAddresses | 可选。不使用代理的 IP 地址或主机名的逗号分隔列表。 |
| proxy | 要连接的代理。代理具有以下属性。 [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/greengrass/v1/developerguide/gg-core.html) |
### 允许终端节点
Greengrass 设备 AWS IoT Core 和/或之间的通信必须经过身份验证。 AWS IoT Greengrass 此身份验证基于注册的 X.509 设备证书和加密密钥。要允许经身份验证的请求通过代理而无需其他加密，请允许以下终端节点。
| 端点 | 端口： | 说明 |
| --- | --- | --- |
| greengrass.region.amazonaws.com | 443 | 用于进行组管理的控制层面操作。 |
| `prefix-ats.iot.region.amazonaws.com` 或者 `prefix.iot.region.amazonaws.com` | MQTT：8883 或 443 HTTPS：8443 或 443 | 用于设备管理的数据平面操作，例如影子同步。 允许仅使用其中一个端点或同时使用这两个端点，具体取决于您的核心设备和客户端设备是使用 Amazon Trust Services（首选）根 CA 证书，还是使用旧式根 CA 证书，或者是同时使用两者。有关更多信息，请参阅 [服务端点必须与根 CA 证书类型匹配](#certificate-endpoints)。 |
| `greengrass-ats.iot.region.amazonaws.com` 或者 `greengrass.iot.region.amazonaws.com` | 8443 或 443 | 用于设备发现操作。 允许仅使用其中一个端点或同时使用这两个端点，具体取决于您的核心设备和客户端设备是使用 Amazon Trust Services（首选）根 CA 证书，还是使用旧式根 CA 证书，或者是同时使用两者。有关更多信息，请参阅 [服务端点必须与根 CA 证书类型匹配](#certificate-endpoints)。 在端口 443 上连接的客户端必须实现[应用层协议协商 (ALPN)](https://tools.ietf.org/html/rfc7301) TLS 扩展，并且必须在 `ProtocolNameList` 中作为 `ProtocolName` 传递 `x-amzn-http-ca`。更多信息，请参阅 *AWS IoT 开发人员指南*中的[协议](https://docs.aws.amazon.com/iot/latest/developerguide/protocols.html)。 |
| \$1.s3.amazonaws.com | 443 | 用于部署操作和 over-the-air更新。该格式包括 `*` 字符，因为终端节点前缀由内部控制，并且可能随时更改。 |
| logs.region.amazonaws.com | 443 | 如果 Greengrass 组配置为写入日志，则为必填项。 CloudWatch |
## 为配置写入目录 AWS IoT Greengrass
此功能适用于 AWS IoT Greengrass 酷睿 v1.6 及更高版本。
默认情况下， AWS IoT Greengrass Core 软件部署在单个根目录下， AWS IoT Greengrass 用于执行所有读取和写入操作。但是，您可以配置 AWS IoT Greengrass 为使用单独的目录进行所有写入操作，包括创建目录和文件。在本例中， AWS IoT Greengrass 使用两个顶级目录：
+ 该*greengrass-root*目录，您可以将其保留为读写状态，也可以选择将其设为只读。它包含 AWS IoT Greengrass 核心软件和其他在运行时应保持不可变的关键组件，例如证书和。`config.json`
+ 指定的写入目录。它包含可写内容，如日志、状态信息以及部署的用户定义的 Lambda 函数。
该配置将生成以下目录结构。
**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/
```
**写入目录**
```
write-directory/
|-- packages/
| |-- package-version/
| |-- ggc_root/
| |-- rootfs_nosys/
| |-- rootfs_sys/
| |-- var/
|-- deployment/
| |-- group/
| |-- group.json
| |-- lambda/
| |-- mlmodel/
|-- var/
| |-- log/
| |-- state/
```
**配置写入目录**
1. 运行以下命令以停止 AWS IoT Greengrass 守护程序：
```
cd /greengrass-root/ggc/core/
sudo ./greengrassd stop
```
1. 打开 `greengrass-root/config/config.json` 以作为 su 用户进行编辑。
1. 添加 `writeDirectory` 以作为参数并指定目标目录路径，如以下示例所示。
```
{
"coreThing": {
"caPath": "root-CA.pem",
"certPath": "hash.pem.crt",
...
},
...
"writeDirectory" : "/write-directory"
}
```
**注意**
您可以按照所需的频率更新 `writeDirectory` 设置。更新设置后，在下次启动时 AWS IoT Greengrass 使用新指定的写入目录，但不会迁移先前写入目录中的内容。
1. 现在，您的写入目录已配置完毕，您可以选择将该*greengrass-root*目录设为只读。有关说明，请参阅[将 Greengrass 根目录指定为只读目录](#configure-ro-directory)。
否则，启动 AWS IoT Greengrass 守护程序：
```
cd /greengrass-root/ggc/core/
sudo ./greengrassd start
```
**将 Greengrass 根目录指定为只读目录**
只有在要将 Greengrass 根目录指定为只读目录时，才需要使用这些步骤。在开始之前，必须配置写入目录。
1. 授予对所需目录的访问权限：
1. 为 `config.json` 所有者授予读写权限。
```
sudo chmod 0600 /greengrass-root/config/config.json
```
1. 将 ggc\$1user 指定为 certs 和 system Lambda 目录的所有者。
```
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/
```
**注意**
默认情况下，ggc\$1user 和 ggc\$1group 账户用于运行系统 Lambda 函数。如果您已配置组级别的[默认访问身份](lambda-group-config.md#lambda-access-identity-groupsettings)来使用不同的账户，则应改为向该用户 (UID) 和组 (GID) 授予权限。
1. 使用您的首选机制将该*greengrass-root*目录设为只读。
**注意**
将该*greengrass-root*目录设为只读的一种方法是将该目录挂载为只读。但是，要将 over-the-air (OTA) 更新应用于已装载目录中的 AWS IoT Greengrass 核心软件，必须先卸载该目录，然后在更新后重新挂载。您可以将这些 `umount` 和 `mount` 操作添加到 `ota_pre_update` 和 `ota_post_update` 脚本中。有关 OTA 更新的更多信息，请参阅[Greengrass OTA 更新代理](core-ota-update.md#ota-agent)和[使用 OTA 更新的托管 Respawn](core-ota-update.md#ota-managed-respawn)。
1. 启动守护程序。
```
cd /greengrass-root/ggc/core/
sudo ./greengrassd start
```
如果未正确设置步骤 1 中的权限，则不会启动守护程序。
## 配置 MQTT 设置
在 AWS IoT Greengrass 环境中，本地客户端设备、Lambda 函数、连接器和系统组件可以相互通信，也可以与之通信。 AWS IoT Core所有通信都经过核心，核心可管理负责授权实体之间的 MQTT 通信的[订阅](gg-sec.md#gg-msg-workflow)。
有关您可以为其配置的 MQTT 设置的信息 AWS IoT Greengrass，请参阅以下各节：
+ [消息服务质量](#message-quality-of-service)
+ [云目标的 MQTT 消息队列](#mqtt-message-queue)
+ [使用 MQTT 持续会话 AWS IoT Core](#mqtt-persistent-sessions)
+ [IDs 用于 MQTT 连接的客户端 AWS IoT](#connection-client-id)
+ [用于本地消息收发的 MQTT 端口](#config-local-mqtt-port)
+ [在 MQTT 连接中发布、订阅、取消订阅操作的超时时间 AWS Cloud](#mqtt-operation-timeout)
**注意**
OPC-UA 是一种用于工业通信的信息交换标准。[要在 Greengrass 内核上实现对 OPC-UA 的支持，你可以使用物联网连接器。 SiteWise ](iot-sitewise-connector.md)该连接器将工业设备数据从 OPC-UA 服务器发送到中的资产属性。 AWS IoT SiteWise
### 消息服务质量
AWS IoT Greengrass 支持服务质量 (QoS) 级别 0 或 1，具体取决于您的配置以及通信目标和方向。Greengrass 核心充当 AWS IoT Core 与本地网络通信的客户端和用于在本地网络上通信的消息代理。
![\[核心是客户端和本地消息代理。\]](http://docs.aws.amazon.com/zh_cn/greengrass/v1/developerguide/images/mqtt-qos.png)
有关 MQTT 和 QoS 的更多信息，请参阅 MQTT 网站上的[入门](https://mqtt.org/getting-started/)。
**与... 沟通 AWS Cloud**
+ **出站消息使用 QoS 1**
内核使用 QoS 1 发送发往 AWS Cloud 目标的消息。 AWS IoT Greengrass 使用 MQTT 消息队列来处理这些消息。如果消息传送未得到确认 AWS IoT，则会对消息进行后台处理，以便稍后重试。如果队列已满，则消息无法重试。消息传输确认可以帮助最大限度减少间歇性连接造成的数据丢失。
由于 AWS IoT 使用 QoS 1 的出站消息，因此 Greengrass 内核发送消息的最大速率取决于内核与之间的延迟。 AWS IoT每次核心发送消息时，它都会等到 AWS IoT 确认消息后再发送下一条消息。例如，如果内核与其之间的往返时间 AWS 区域 为 50 毫秒，则内核每秒最多可以发送 20 条消息。在选择核心连接 AWS 区域 位置时，请考虑这种行为。要将大容量 IoT 数据摄取到 AWS Cloud，您可以使用[流](stream-manager.md)管理器。
有关 MQTT 消息队列的更多信息，包括如何配置可以保存发往 AWS Cloud 目标的消息的本地存储缓存，请参阅[云目标的 MQTT 消息队列](#mqtt-message-queue)。
+ **入站消息使用 QoS 0（默认）或 QoS 1**
默认情况下，核心以 QoS 0 订阅来自 AWS Cloud 源的消息。如果您启用持久会话，则核心将以 QoS 1 进行订阅。这有助于最大限度地减少间歇性连接造成的数据丢失。要管理这些订阅的 QoS，请在本地后台处理程序系统组件上配置持久性设置。
有关更多信息，包括如何使核心能够与 AWS Cloud 目标建立持久会话，请参阅[使用 MQTT 持续会话 AWS IoT Core](#mqtt-persistent-sessions)。
**与本地目标通信**
所有本地通信都使用 QoS 0。核心尝试向本地目标发送消息，该目标可以是 Greengrass Lambda 函数、连接器或[客户端设备](what-is-gg.md#greengrass-devices)。核心不会存储消息，也不会确认交付。消息可置于组件之间的任何位置。
虽然 Lambda 函数之间的直接通信不使用 MQTT 消息收发，但行为是相同的。
### 云目标的 MQTT 消息队列
发往 AWS Cloud 目标的 MQTT 消息将排队等待处理。排队的消息按照先进先出 (FIFO) 顺序进行处理。处理消息并将其发布到后 AWS IoT Core，该消息将从队列中删除。
默认情况下，Greengrass 核心将发送到 AWS Cloud 目标的未处理消息存储在内存中。您可以配置核心以改为在本地存储缓存中存储未处理的消息。与内存存储不同，本地存储缓存能够在核心重启后保持不变（例如，在群组部署或设备重启之后），因此 AWS IoT Greengrass 可以继续处理消息。您也可以配置存储大小。
**警告**
Greengrass 核心在失去连接时可能会将重复的 MQTT 消息加入队列中，这是因为 Greengrass 核心会在 MQTT 客户机检测到其脱机之前重试一次发布操作。要避免云目标的 MQTT 消息重复，请将核心的 `keepAlive` 值配置为小于其 `mqttOperationTimeout` 值的一半。有关更多信息，请参阅 [AWS IoT Greengrass 核心配置文件](#config-json)。
AWS IoT Greengrass 使用后台处理程序系统组件（Lambd `GGCloudSpooler` a 函数）来管理消息队列。您可以使用以下 `GGCloudSpooler` 环境变量来配置存储设置。
+ **GG\$1CONFIG\$1STORAGE\$1TYPE**。消息队列位置。有效值有：
+ `FileSystem`。将未处理的消息存储在物理核心设备磁盘上的本地存储缓存中。在核心重新启动时，将保留排队的消息以进行处理。在处理后，将删除消息。
+ `Memory` (默认值)。在内存中存储未处理的消息。在核心重新启动时，排队的消息将丢失。
该选项是针对具有受限硬件功能的设备优化的。在使用该配置时，我们建议您部署组或在服务中断最少的情况下重新启动设备。
+ **GG\$1CONFIG\$1MAX\$1SIZE\$1BYTES**。存储大小（以字节为单位）。该值可以是任何**大于或等于 262144** (256 KB) 的非负整数；较小的大小会阻止 AWS IoT Greengrass Core 软件启动。默认大小为 2.5 MB。在达到大小限制时，最早的排队消息将替换为新消息。
**注意**
此功能适用于 AWS IoT Greengrass 酷睿 v1.6 及更高版本。更低版本使用内存中存储，并且队列大小为 2.5 MB。您无法为早期版本配置存储设置。
#### 在本地存储中缓存消息
您可以配置为 AWS IoT Greengrass 将消息缓存到文件系统，这样它们就会在核心重启后持续存在。为此，您需要部署一个函数定义版本，其中 `GGCloudSpooler` 函数将存储类型设置为 `FileSystem`。您必须使用 AWS IoT Greengrass API 来配置本地存储缓存。您无法在控制台中执行该操作。
以下过程使用 [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) CLI 命令配置后台处理程序，以便将排队的消息保存到文件系统中。它还配置 2.6 MB 队列大小。
1. 获取目标 Greengrass 群 IDs 组和群组版本。此过程假定这是最新的组和组版本。以下查询将返回最近创建的组。
```
aws greengrass list-groups --query "reverse(sort_by(Groups, &CreationTimestamp))[0]"
```
或者，您也可以按名称查询。系统不要求组名称是唯一的，所以可能会返回多个组。
```
aws greengrass list-groups --query "Groups[?Name=='MyGroup']"
```
**注意**
您也可以在 AWS IoT 控制台中找到这些值。组 ID 显示在组的**设置**页面上。群组版本显示 IDs 在群组的 “**部署**” 选项卡上。
1. 从输出中的目标组复制 `Id` 和 `LatestVersion` 值。
1. 获取最新的组版本。
+ 将 *group-id* 替换为复制的 `Id`。
+ 将 *latest-group-version-id* 替换为复制的 `LatestVersion`。
```
aws greengrass get-group-version \
--group-id group-id \
--group-version-id latest-group-version-id
```
1. 从输出中的`Definition`对象中，复制除 ARNs 之外的所有其他组组件的`CoreDefinitionVersionArn`和`FunctionDefinitionVersionArn`。在创建新的组版本时，将使用这些值。
1. 在输出的 `FunctionDefinitionVersionArn` 中，复制函数定义的 ID。该 ID 是 ARN 中的 `functions` 段后面的 GUID，如以下示例所示。
```
arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/functions/bcfc6b49-beb0-4396-b703-6dEXAMPLEcu5/versions/0f7337b4-922b-45c5-856f-1aEXAMPLEsf6
```
**注意**
或者，您可以通过运行 [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) 命令以创建一个函数定义，然后从输出中复制该 ID。
1. 在函数定义中添加一个函数定义版本。
+ *function-definition-id*用您`Id`为函数定义复制的替换。
+ *arbitrary-function-id*替换为函数的名称，例如**spooler-function**。
+ 将要在该版本中包含的任何 Lambda 函数添加到 `functions` 数组中。您可以使用 [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) 命令从现有的函数定义版本中获取 Greengrass Lambda 函数。
**警告**
确保为 `GG_CONFIG_MAX_SIZE_BYTES` 指定**大于或等于 262144** 的值。较小的尺寸会阻止 AWS IoT Greengrass Core 软件启动。
```
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"}]'
```
**注意**
如果您之前将`GG_CONFIG_SUBSCRIPTION_QUALITY`环境变量设置为[支持持久会话 AWS IoT Core，](#mqtt-persistent-sessions)请将其包含在此函数实例中。
1. 从输出中复制函数定义版本的 `Arn`。
1. 创建一个包含系统 Lambda 函数的组版本。
+ *group-id*替换`Id`为该群组的。
+ *core-definition-version-arn*替换为您从最新群组版本中复制的版本。`CoreDefinitionVersionArn`
+ *function-definition-version-arn*替换`Arn`为你为新函数定义版本复制的。
+ 替换您从最新组版本中复制的其他组组件（例如`SubscriptionDefinitionVersionArn`或`DeviceDefinitionVersionArn`）。 ARNs
+ 删除任何未使用的参数。例如，如果组版本不包含任何资源，请删除 `--resource-definition-version-arn`。
```
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. 从输出中复制 `Version`。这是新组版本的 ID。
1. 用新组版本替换组。
+ *group-id*替换为你为`Id`该群组复制的。
+ *group-version-id*替换为你`Version`为新群组版本复制的版本。
```
aws greengrass create-deployment \
--group-id group-id \
--group-version-id group-version-id \
--deployment-type NewDeployment
```
要更新存储设置，您可以使用 AWS IoT Greengrass API 创建新的函数定义版本，其中包含具有更新配置的`GGCloudSpooler`函数。接下来，将函数定义版本添加到新的组版本（以及其他组组件）中，然后部署该组版本。如果要还原默认配置，您可以部署不包含 `GGCloudSpooler` 函数的函数定义版本。
控制台中不显示这个系统 Lambda 函数。不过，在将函数添加到最新组版本后，它将包含在从控制台指定的部署中（除非您使用 API 替换或删除该函数）。
### 使用 MQTT 持续会话 AWS IoT Core
此功能适用于 AWS IoT Greengrass 酷睿 v1.10 及更高版本。
Greengrass 核心可以与消息代理建立持久会话。 AWS IoT 持久会话是一种持续连接，允许核心接收在核心离线时发送的消息。核心是连接中的客户端。
在持久会话中， AWS IoT 消息代理会保存核心在连接期间进行的所有订阅。[如果核心断开连接，则 AWS IoT 消息代理会存储未确认的消息和作为 QoS 1 发布并发往本地目标（例如 Lambda 函数和客户端设备）的新消息。](what-is-gg.md#greengrass-devices)当核心重新连接时，持久会话将恢复， AWS IoT 消息代理以每秒 10 条消息的最大速率向核心发送存储的消息。永久会话的默认到期时间为 1 小时，从消息代理检测到核心断开连接时开始算起。有关更多信息，请参阅AWS IoT 开发人员指南**中的 [MQTT 持久性会话](https://docs.aws.amazon.com/iot/latest/developerguide/mqtt-persistent-sessions.html)。
AWS IoT Greengrass 使用后台处理程序系统组件（Lamb `GGCloudSpooler` da 函数）创建以作为源的订阅。 AWS IoT 您可以使用以下 `GGCloudSpooler` 环境变量来配置持久性会话。
+ **GG\$1CONFIG\$1SUBSCRIPTION\$1QUALITY**。以此为来源的 AWS IoT 订阅质量。有效值有：
+ `AtMostOnce` (默认值)。禁用持久性会话。订阅使用 QoS 0。
+ `AtLeastOncePersistent`。启用持久性会话。将 `CONNECT` 消息中的 `cleanSession` 标志设置为 `0`，并以 QoS 1 进行订阅。
如果核心收到的消息是以 QoS 1 发布，则会保证消息送达 Greengrass 守护进程的内存中工作队列。在将消息添加到队列后，核心会确认消息。从队列到本地目标（例如 Greengrass Lambda 函数、连接器或设备）的后续通信将以 QoS 0 发送。 AWS IoT Greengrass 不能保证一定交付给本地目标。
**注意**
您可以使用 C [maxWorkItemount](#config-json-runtime) 配置属性来控制工作项队列的大小。例如，如果您的工作负载需要大量的 MQTT 流量，则可以增加队列大小。
启用持久会话后，内核至少会打开一个额外的连接，用于与 MQTT 消息交换。 AWS IoT有关更多信息，请参阅 [IDs 用于 MQTT 连接的客户端 AWS IoT](#connection-client-id)。
#### 配置 MQTT 持久性会话
您可以配置 AWS IoT Greengrass 为使用持久会话 AWS IoT Core。为此，您需要部署一个函数定义版本，其中 `GGCloudSpooler` 函数将订阅质量设置为 `AtLeastOncePersistent`。此设置适用于具有 AWS IoT Core (`cloud`) 作为源的所有订阅。您必须使用 AWS IoT Greengrass API 来配置持久会话。您无法在控制台中执行该操作。
以下过程使用 [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) CLI 命令将后台处理程序配置为使用持久会话。在该过程中，我们假定您要更新现有组的最新组版本的配置。
1. 获取目标 Greengrass 群 IDs 组和群组版本。此过程假定这是最新的组和组版本。以下查询将返回最近创建的组。
```
aws greengrass list-groups --query "reverse(sort_by(Groups, &CreationTimestamp))[0]"
```
或者，您也可以按名称查询。系统不要求组名称是唯一的，所以可能会返回多个组。
```
aws greengrass list-groups --query "Groups[?Name=='MyGroup']"
```
**注意**
您也可以在 AWS IoT 控制台中找到这些值。组 ID 显示在组的**设置**页面上。群组版本显示 IDs 在群组的 “**部署**” 选项卡上。
1. 从输出中的目标组复制 `Id` 和 `LatestVersion` 值。
1. 获取最新的组版本。
+ 将 *group-id* 替换为复制的 `Id`。
+ 将 *latest-group-version-id* 替换为复制的 `LatestVersion`。
```
aws greengrass get-group-version \
--group-id group-id \
--group-version-id latest-group-version-id
```
1. 从输出中的`Definition`对象中，复制除 ARNs 之外的所有其他组组件的`CoreDefinitionVersionArn`和`FunctionDefinitionVersionArn`。在创建新的组版本时，将使用这些值。
1. 在输出的 `FunctionDefinitionVersionArn` 中，复制函数定义的 ID。该 ID 是 ARN 中的 `functions` 段后面的 GUID，如以下示例所示。
```
arn:aws:greengrass:us-west-2:123456789012:/greengrass/definition/functions/bcfc6b49-beb0-4396-b703-6dEXAMPLEcu5/versions/0f7337b4-922b-45c5-856f-1aEXAMPLEsf6
```
**注意**
或者，您可以通过运行 [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) 命令以创建一个函数定义，然后从输出中复制该 ID。
1. 在函数定义中添加一个函数定义版本。
+ *function-definition-id*用您`Id`为函数定义复制的替换。
+ *arbitrary-function-id*替换为函数的名称，例如**spooler-function**。
+ 将要在该版本中包含的任何 Lambda 函数添加到 `functions` 数组中。您可以使用 [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) 命令从现有的函数定义版本中获取 Greengrass Lambda 函数。
```
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"}]'
```
**注意**
如果您之前设置了 `GG_CONFIG_STORAGE_TYPE` 或 `GG_CONFIG_MAX_SIZE_BYTES` 环境变量来[定义存储设置](#mqtt-message-queue)，请将其包含在该函数实例中。
1. 从输出中复制函数定义版本的 `Arn`。
1. 创建一个包含系统 Lambda 函数的组版本。
+ *group-id*替换`Id`为该群组的。
+ *core-definition-version-arn*替换为您从最新群组版本中复制的版本。`CoreDefinitionVersionArn`
+ *function-definition-version-arn*替换`Arn`为你为新函数定义版本复制的。
+ 替换您从最新组版本中复制的其他组组件（例如`SubscriptionDefinitionVersionArn`或`DeviceDefinitionVersionArn`）。 ARNs
+ 删除任何未使用的参数。例如，如果组版本不包含任何资源，请删除 `--resource-definition-version-arn`。
```
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. 从输出中复制 `Version`。这是新组版本的 ID。
1. 用新组版本替换组。
+ *group-id*替换为你为`Id`该群组复制的。
+ *group-version-id*替换为你`Version`为新群组版本复制的版本。
```
aws greengrass create-deployment \
--group-id group-id \
--group-version-id group-version-id \
--deployment-type NewDeployment
```
1. （可选）增加核心配置文件中的 C [maxWorkItemount](#config-json-runtime) 属性。这可以帮助核心处理增加的 MQTT 流量以及与本地目标的通信。
要使用这些配置更改更新内核，您可以使用 AWS IoT Greengrass API 创建新的函数定义版本，其中包含具有更新配置的`GGCloudSpooler`函数。接下来，将函数定义版本添加到新的组版本（以及其他组组件）中，然后部署该组版本。如果要还原默认配置，您可以创建不包含 `GGCloudSpooler` 函数的函数定义版本。
控制台中不显示这个系统 Lambda 函数。不过，在将函数添加到最新组版本后，它将包含在从控制台指定的部署中（除非您使用 API 替换或删除该函数）。
### IDs 用于 MQTT 连接的客户端 AWS IoT
此功能适用于 AWS IoT Greengrass 酷睿 v1.8 及更高版本。
Greengrass 内核为影子同步和证书管理等操作打开 MQTT 连接 AWS IoT Core 。对于这些连接，内核会 IDs 根据核心事物名称生成可预测的客户端。可预测的客户端 IDs 可以与监控、审计和定价功能一起使用，包括 AWS IoT Device Defender [AWS IoT 生命周期事件](https://docs.aws.amazon.com/iot/latest/developerguide/life-cycle-events.html)。您还可以围绕可预测的客户端 IDs （例如，基于证书属性的[订阅策略](https://docs.aws.amazon.com/iot/latest/developerguide/pub-sub-policy.html#pub-sub-policy-cert)模板）创建逻辑。
------
#### [ GGC v1.9 and later ]
两个 Greengrass 系统组件打开了 MQTT 连接。 AWS IoT Core这些组件使用以下模式 IDs为连接生成客户端。
| 操作 | 客户端 ID 模式 |
| --- | --- |
| 部署 | `core-thing-name` 示例：`MyCoreThing` 将该客户端 ID 用于连接、断开连接、订阅和取消订阅生命周期事件通知。 |
| 订阅 | `core-thing-name-cn` 示例：`MyCoreThing-c01` `n` 是一个从 00 开始的整数，每出现一个新连接，这个整数就会递增，最大值为 250。连接的数量由组中与 AWS IoT Core 同步其影子状态的设备的数量（每组最大数量为 2,500）以及组中使用 `cloud` 作为其源的订阅的数量（每组最大数量为 10,000）来决定。 后台处理程序系统组件与 AWS IoT Core 连接以便与云源或目标交换订阅消息。后台处理程序还充当本地影子服务和设备证书 AWS IoT Core 管理器之间交换消息的代理。 |
要计算每组的 MQTT 连接数，请使用以下公式：
`number of MQTT connections per group = number of connections for Deployment Agent + number of connections for Subscriptions`
其中，
+ 部署代理的连接数 = 1。
+ 订阅的连接数 = `(2 subscriptions for supporting certificate generation + number of MQTT topics in AWS IoT Core + number of device shadows synced) / 50`。
+ 其中，`50`= 每个连接 AWS IoT Core 可以支持的最大订阅数。
**注意**
如果您启用[持续会话](#mqtt-persistent-sessions)进行订阅 AWS IoT Core，则内核至少会打开一个额外的连接以在持久会话中使用。系统组件不支持持久会话，因此它们无法共享该连接。
为了减少 MQTT 连接的数量并帮助降低成本，您可以使用本地 Lambda 函数在边缘聚合数据。然后，您将聚合数据发送到 AWS Cloud。因此，您在中使用的 MQTT 主题更少。 AWS IoT Core有关更多信息，请参阅[AWS IoT Greengrass 定价](https://aws.amazon.com/greengrass/pricing/)。
------
#### [ GGC v1.8 ]
几个 Greengrass 系统组件可以与 AWS IoT Core建立 MQTT 连接。这些组件使用以下模式 IDs 为连接生成客户端。
| 操作 | 客户端 ID 模式 |
| --- | --- |
| 部署 | `core-thing-name` 示例：`MyCoreThing` 将该客户端 ID 用于连接、断开连接、订阅和取消订阅生命周期事件通知。 |
| 与 MQTT 消息交换 AWS IoT Core | `core-thing-name-spr` 示例：`MyCoreThing-spr` |
| 影子同步 | `core-thing-name-snn` 示例：`MyCoreThing-s01` `nn` 是一个整数，从 00 开始，随着每个新连接的增量递增，最大值为 03。连接数由与其影子状态同步的设备数量（每组最多 200 个设备）决定 AWS IoT Core （每个连接最多 50 个订阅）。 |
| 设备证书管理 | `core-thing-name-dcm` 示例：`MyCoreThing-dcm` |
------
**注意**
同时连接中 IDs 使用的重复客户端可能会导致连接断开连接的无限循环。如果另一个设备硬编码为使用核心设备名称作为连接中的客户端 ID，则可能发生这种情况。有关更多信息，请参阅此[问题排查步骤](gg-troubleshooting.md#config-client-id)。
Greengrass 设备还与 AWS IoT Device Management的实例集索引服务完全集成。这样您便可以根据云中的设备属性、影子状态和连接状态对设备进行索引和搜索。例如，Greengrass 设备至少建立一个使用事物名称作为客户端 ID 的连接，因此，您可以使用设备连接索引来发现哪些 Greengrass 设备当前已与 AWS IoT Core连接或断开连接。有关更多信息，请参阅AWS IoT FleetWise 开发人员指南**中的[队列](https://docs.aws.amazon.com/iot/latest/developerguide/iot-indexing.html)。
### 为本地消息收发配置 MQTT 端口
此功能需要 AWS IoT Greengrass 酷睿 v1.10 或更高版本。
Greengrass 核心充当本地 Lambda 函数、连接器和[客户端设备](what-is-gg.md#greengrass-devices)之间的 MQTT 消息传递的本地消息代理。默认情况下，核心使用端口 8883 来传输本地网络上的 MQTT 流量。您可能需要更改端口，以避免与在端口 8883 上运行的其他软件发生冲突。
**配置核心用于传输本地 MQTT 流量的端口号**
1. 运行以下命令以停止 Greengrass 进程守护程序：
```
cd /greengrass-root/ggc/core/
sudo ./greengrassd stop
```
1. 打开 `greengrass-root/config/config.json` 以作为 su 用户进行编辑。
1. 在 `coreThing` 对象中，添加 `ggMqttPort` 属性并将值设置为要使用的端口号。有效值为 1024 到 65535。以下示例将端口号设置为 `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. 启动进程守护程序。
```
cd /greengrass-root/ggc/core/
sudo ./greengrassd start
```
1. 如果为核心启用了[自动 IP 检测](#ip-auto-detect)，则配置已完成。
如果未启用自动 IP 检测，则必须更新核心的连接信息。这允许客户端设备在发现操作期间接收正确的端口号，以获取核心连接信息。您可以使用 AWS IoT 控制台或 AWS IoT Greengrass API 来更新核心连接信息。在此过程中，您只需要更新端口号。核心的本地 IP 地址保持不变。
**更新核心的连接信息（控制台）**
1. 在组配置页面上，选择 Greengrass 核心。
1. 在核心详细信息页面上，选择 **MQTT 代理端点**选项卡。
1. 选择**管理端点**选项卡，然后选择**添加端点**。
1. 输入您当前的本地 IP 地址和新的端口号。以下示例设置 IP 地址 `192.168.1.8` 的端口号 `9000`。
1. 移除过时的端点，然后选择**更新**
**更新核心的连接信息 (API)**
+ 使用 [UpdateConnectivityInfo](https://docs.aws.amazon.com/greengrass/v1/apireference/updateconnectivityinfo-put.html) 操作。以下示例使用 AWS CLI 中的 `update-connectivity-info` 为 IP 地址 `192.168.1.8` 设置端口号 `9000`。
```
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\"}]"
```
**注意**
您还可以配置内核用于 MQTT 消息的 AWS IoT Core端口。有关更多信息，请参阅 [通过端口 443 或网络代理进行连接](#alpn-network-proxy)。
### 在 MQTT 连接中发布、订阅、取消订阅操作的超时时间 AWS Cloud
此功能在 AWS IoT Greengrass v1.10.2 或更高版本中可用。
您可以配置允许 Greengrass 核心在与 AWS IoT Core的 MQTT 连接中完成发布、订阅或取消订阅操作的时间（以秒为单位）。如果因带宽限制或高延迟导致操作超时，您可能需要调整此设置。要在 [config.json](#config-json) 文件中配置此设置，请在 `coreThing` 对象中添加或更改 `mqttOperationTimeout` 属性。例如：
```
{
"coreThing": {
"mqttOperationTimeout": 10,
"caPath": "root-ca.pem",
"certPath": "hash.cert.pem",
"keyPath": "hash.private.key",
...
},
...
}
```
默认超时时间为 5 秒。最小超时值为 5 秒。
## 激活自动 IP 检测
您可以配置 AWS IoT Greengrass 为允许 Greengrass 组中的客户端设备自动发现 Greengrass 内核。启用后，内核将监视其 IP 地址的变化。如果地址发生变化，核心将发布更新的地址列表。与核心位于同一 Greengrass 组中的客户端设备可以使用这些地址。
**注意**
客户端设备的 AWS IoT 策略必须授予`greengrass:Discover`允许设备检索核心连接信息的权限。有关策略语句的更多信息，请参阅[发现授权](gg-discover-api.md#gg-discover-auth)。
要从 AWS IoT Greengrass 控制台启用此功能，请在首次部署 Greengrass 群组时选择 “**自动检测**”。您也可以在组配置页面上启用或禁用此功能，方法是选择 **Lambda 函数**选项卡，然后选择 **IP 检测器**。如果选择**自动检测和覆盖 MQTT 代理端点**，则会启用自动 IP 检测。
要使用 AWS IoT Greengrass API 管理自动发现，您必须配置`IPDetector`系统 Lambda 函数。以下过程说明如何使用 [ create-function-definition-version](https://docs.aws.amazon.com/cli/latest/reference/greengrass/create-function-definition-version.html)CLI 命令配置 Greengrass 内核的自动发现。
1. 获取目标 Greengrass 群 IDs 组和群组版本。此过程假定这是最新的组和组版本。以下查询将返回最近创建的组。
```
aws greengrass list-groups --query "reverse(sort_by(Groups, &CreationTimestamp))[0]"
```
或者，您也可以按名称查询。系统不要求组名称是唯一的，所以可能会返回多个组。
```
aws greengrass list-groups --query "Groups[?Name=='MyGroup']"
```
**注意**
您也可以在 AWS IoT 控制台中找到这些值。组 ID 显示在组的**设置**页面上。群组版本显示 IDs 在群组的 “**部署**” 选项卡上。
1. 从输出中的目标组复制 `Id` 和 `LatestVersion` 值。
1. 获取最新的组版本。
+ 将 *group-id* 替换为复制的 `Id`。
+ 将 *latest-group-version-id* 替换为复制的 `LatestVersion`。
```
aws greengrass get-group-version \
--group-id group-id \
--group-version-id latest-group-version-id
```
1. 从输出中的`Definition`对象中，复制除 ARNs 之外的所有其他组组件的`CoreDefinitionVersionArn`和`FunctionDefinitionVersionArn`。在创建新的组版本时，将使用这些值。
1. 从输出中的 `FunctionDefinitionVersionArn`，复制函数定义的 ID 和函数定义版本：
```
arn:aws:greengrass:region:account-id:/greengrass/groups/function-definition-id/versions/function-definition-version-id
```
**注意**
您可以选择运行 [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) 命令以创建一个函数定义，然后从输出中复制该 ID。
1. 使用 [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) 命令可获取当前定义状态。使用*function-definition-id*您复制的作为函数定义。例如 *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
```
记录下列出的函数配置。在创建新的函数定义版本时，您需要包括这些函数配置，以防止丢失当前的定义设置。
1. 在函数定义中添加一个函数定义版本。
+ *function-definition-id*用您`Id`为函数定义复制的替换。例如 *4d941bc7-92a1-4f45-8d64-EXAMPLEf76c3*。
+ *arbitrary-function-id*替换为函数的名称，例如**auto-detection-function**。
+ 将要包含在此版本中的所有 Lambda 函数都添加到 `functions` 数组中，例如上一步中列出的任何函数。
```
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. 从输出中复制函数定义版本的 `Arn`。
1. 创建一个包含系统 Lambda 函数的组版本。
+ *group-id*替换`Id`为该群组的。
+ *core-definition-version-arn*替换为您从最新群组版本中复制的版本。`CoreDefinitionVersionArn`
+ *function-definition-version-arn*替换`Arn`为你为新函数定义版本复制的。
+ 替换您从最新组版本中复制的其他组组件（例如`SubscriptionDefinitionVersionArn`或`DeviceDefinitionVersionArn`）。 ARNs
+ 删除任何未使用的参数。例如，如果组版本不包含任何资源，请删除 `--resource-definition-version-arn`。
```
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. 从输出中复制 `Version`。这是新组版本的 ID。
1. 用新组版本替换组。
+ *group-id*替换为你为`Id`该群组复制的。
+ *group-version-id*替换为你`Version`为新群组版本复制的版本。
```
aws greengrass create-deployment \
--group-id group-id \
--group-version-id group-version-id \
--deployment-type NewDeployment
```
如果要手动输入 Greengrass 核心的 IP 地址，您可以使用其他不包含 `IPDetector` 函数的函数定义来完成此教程。这将阻止检测函数定位并自动输入您的 Greengrass 核心 IP 地址。
Lambda 控制台中不显示这个系统 Lambda 函数。在将函数添加到最新组版本后，除非您使用 API 替换或删除该函数，否则它将包含在从控制台指定的部署中。
## 配置初始化系统以启动 Greengrass 守护程序
最佳做法是，将初始化系统设置为在引导期间启动 Greengrass 守护程序，尤其是在管理大量设备时。
**注意**
如果您曾经`apt`安装过 AWS IoT Greengrass Core 软件，则可以使用 systemd 脚本启用启动时启动。有关更多信息，请参阅 [使用 systemd 脚本管理 Greengrass 守护程序生命周期](install-ggc.md#ggc-package-manager-systemd)。
具有不同类型的初始化系统（如 initd、systemd 和 SystemV），并且它们使用类似的配置参数。以下示例是用于 systemd 的服务文件。`Type` 参数设置为 `forking`，因为 greengrassd（用于启动 Greengrass）为 Greengrass 守护程序进程创建分支，而 `Restart` 参数设置为 `on-failure` 以指示 systemd 在 Greengrass 进入故障状态时重新启动 Greengrass。
**注意**
要查看您的设备是否使用 systemd，请按照[模块 1](module1.md) 中所述运行 `check_ggc_dependencies` 脚本。然后，要使用 systemd，请确保将 `useSystemd`[`config.json` 中的 ](#config-json) 参数设置为 `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
```
## 另请参阅
+ [什么是 AWS IoT Greengrass？](what-is-gg.md)
+ [支持的平台和要求](what-is-gg.md#gg-platforms)
+ [入门 AWS IoT Greengrass](gg-gs.md)
+ [AWS IoT Greengrass 群组对象模型概述](deployments.md#api-overview)
+ [硬件安全性集成](hardware-security.md)