本文為英文版的機器翻譯版本，如內容有任何歧義或不一致之處，概以英文版為準。
# 設定 AWS IoT Greengrass 核心裝置
完成本節中的任務，以安裝、設定和執行 AWS IoT Greengrass 核心軟體。
**注意**
本節說明 AWS IoT Greengrass Core 軟體的進階安裝和組態。這些步驟不適用於 nucleus lite。如果您是第一次使用 AWS IoT Greengrass V2，我們建議您先完成[入門教學](getting-started.md)課程，以設定核心裝置並探索 的功能 AWS IoT Greengrass。
**Topics**
+ [支援平台](#supported-platforms)
+ [裝置要求](#device-requirements)
+ [Lambda 函數需求](#greengrass-v2-lambda-requirements)
+ [設定 AWS 帳戶](#set-up-aws-account)
+ [安裝 AWS IoT Greengrass Core 軟體](install-greengrass-core-v2.md)
+ [執行 AWS IoT Greengrass 核心軟體](run-greengrass-core-v2.md)
+ [在 Docker 容器中執行 AWS IoT Greengrass 核心軟體](run-greengrass-docker.md)
+ [設定 AWS IoT Greengrass 核心軟體](configure-greengrass-core-v2.md)
+ [更新 AWS IoT Greengrass 核心軟體 (OTA)](update-greengrass-core-v2.md)
+ [解除安裝 AWS IoT Greengrass Core 軟體](uninstall-greengrass-core-v2.md)
## 支援平台
+ [Greengrass 核支援的平台](https://docs.aws.amazon.com/greengrass/v2/developerguide/greengrass-nucleus-component.html)
+ [Greengrass nucleus lite 支援的平台](https://docs.aws.amazon.com/greengrass/v2/developerguide/greengrass-nucleus-lite-component.html)
## 裝置要求
+ [Greengrass 核設備需求](https://docs.aws.amazon.com/greengrass/v2/developerguide/greengrass-nucleus-component.html)
+ [Greengrass nucleus lite 裝置需求](https://docs.aws.amazon.com/greengrass/v2/developerguide/greengrass-nucleus-lite-component.html)
## Lambda 函數需求
**重要**
Greengrass Lambda 函數目前不支援 Greengrass nucleus lite。
您的裝置必須符合下列要求，才能執行 Lambda 函數：
+ 以 Linux 為基礎的作業系統。
+ 您的裝置必須具有 `mkfifo` shell 命令。
+ 您的裝置必須執行 Lambda 函數所需的程式設計語言程式庫。您必須在裝置上安裝所需的程式庫，並將其新增至`PATH`環境變數。Greengrass 支援所有 Lambda 支援的 Python、Node.js 和 Java 執行時間版本。Greengrass 不會對已取代的 Lambda 執行時間版本套用任何其他限制。如需 Lambda 執行時間 AWS IoT Greengrass 支援的詳細資訊，請參閱 [執行 AWS Lambda 函數](run-lambda-functions.md)。
+ 若要執行容器化 Lambda 函數，您的裝置必須符合下列要求：
+ Linux 核心版本 4.4 或更新版本。
+ 核心必須支援 [cgroups](https://en.wikipedia.org/wiki/Cgroups) v1，而且您必須啟用並掛載下列 cgroups：
+ 的*記憶體* cgroup AWS IoT Greengrass ，用於設定容器化 Lambda 函數的記憶體限制。
+ 容器化 Lambda 函數*的裝置* cgroup 可存取系統裝置或磁碟區。
AWS IoT Greengrass 核心軟體不支援 cgroups v2。
若要符合此需求，請使用下列 Linux 核心參數啟動裝置。
```
cgroup_enable=memory cgroup_memory=1 systemd.unified_cgroup_hierarchy=0
```
**提示**
在 Raspberry Pi 上，編輯 `/boot/cmdline.txt` 檔案以設定裝置的核心參數。
+ 您必須在裝置上啟用下列 Linux 核心組態：
+ 命名空間：
+ `CONFIG_IPC_NS`
+ `CONFIG_UTS_NS`
+ `CONFIG_USER_NS`
+ `CONFIG_PID_NS`
+ Cgroups：
+ `CONFIG_CGROUP_DEVICE`
+ `CONFIG_CGROUPS`
+ `CONFIG_MEMCG`
+ 其他：
+ `CONFIG_POSIX_MQUEUE`
+ `CONFIG_OVERLAY_FS`
+ `CONFIG_HAVE_ARCH_SECCOMP_FILTER`
+ `CONFIG_SECCOMP_FILTER`
+ `CONFIG_KEYS`
+ `CONFIG_SECCOMP`
+ `CONFIG_SHMEM`
**提示**
檢查 Linux 發行版本的文件，以了解如何驗證和設定 Linux 核心參數。您也可以使用 AWS IoT Device Tester 的 AWS IoT Greengrass 來驗證您的裝置是否符合這些要求。如需詳細資訊，請參閱[使用 AWS IoT Device Tester for AWS IoT Greengrass V2](device-tester-for-greengrass-ug.md)。
## 設定 AWS 帳戶
如果您沒有 AWS 帳戶，請完成下列步驟來建立一個。
**註冊 AWS 帳戶**
1. 開啟 [https://portal.aws.amazon.com/billing/signup](https://portal.aws.amazon.com/billing/signup)。
1. 請遵循線上指示進行。
部分註冊程序需接收來電或簡訊，並在電話鍵盤輸入驗證碼。
當您註冊 時 AWS 帳戶，*AWS 帳戶根使用者*會建立 。根使用者有權存取該帳戶中的所有 AWS 服務 和資源。作為安全最佳實務，請將管理存取權指派給使用者，並且僅使用根使用者來執行[需要根使用者存取權的任務](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks)。
若要建立管理員使用者，請選擇下列其中一個選項。
****
| 選擇一種管理管理員的方式 | 到 | 根據 | 您也可以 |
| --- | --- | --- | --- |
| 在 IAM Identity Center (建議) | 使用短期憑證存取 AWS。這與安全性最佳實務一致。有關最佳實務的資訊，請參閱 *IAM 使用者指南*中的 [IAM 安全最佳實務](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#bp-users-federation-idp)。 | 請遵循 AWS IAM Identity Center 使用者指南的[入門](https://docs.aws.amazon.com//singlesignon/latest/userguide/getting-started.html)中的說明。 | 透過在 AWS Command Line Interface 使用者指南中設定 [AWS CLI 以使用 來設定 AWS IAM Identity Center](https://docs.aws.amazon.com//cli/latest/userguide/cli-configure-sso.html)程式設計存取。 |
| 在 IAM 中 (不建議使用) | 使用長期憑證存取 AWS。 | 請遵循《IAM 使用者指南》中[建立 IAM 使用者以進行緊急存取](https://docs.aws.amazon.com/IAM/latest/UserGuide/getting-started-emergency-iam-user.html) 的指示。 | 請依照《IAM 使用者指南》中的[管理 IAM 使用者的存取金鑰](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_credentials_access-keys.html)設定以程式設計方式存取。 |
# 安裝 AWS IoT Greengrass Core 軟體
AWS IoT Greengrass 延伸 AWS 到邊緣裝置，讓他們可以對產生的資料採取行動，同時使用 AWS 雲端 進行管理、分析和耐用儲存。在邊緣裝置上安裝 AWS IoT Greengrass 核心軟體，以與 AWS IoT Greengrass 和 整合 AWS 雲端。
**重要**
在您下載並安裝 AWS IoT Greengrass Core 軟體之前，請檢查您的核心裝置是否符合安裝和執行 AWS IoT Greengrass Core 軟體 2.0 版[的要求](greengrass-nucleus-component.md#greengrass-v2-requirements)。
Core AWS IoT Greengrass 軟體包含安裝程式，可將您的裝置設定為 Greengrass 核心裝置。當您執行安裝程式時，您可以設定選項，例如根資料夾和 AWS 區域 要使用的 。您可以選擇讓安裝程式為您建立必要的 AWS IoT 和 IAM 資源。您也可以選擇部署本機開發工具，以設定您用於自訂元件開發的裝置。
AWS IoT Greengrass 核心軟體需要下列 AWS IoT 和 IAM 資源才能連線至 AWS 雲端 並操作：
+ 實 AWS IoT 物。當您將裝置註冊為 AWS IoT 物件時，該裝置可以使用數位憑證進行身分驗證 AWS。此憑證可讓裝置與 AWS IoT 和 通訊 AWS IoT Greengrass。如需詳細資訊，請參閱[的裝置身分驗證和授權 AWS IoT Greengrass](device-auth.md)。
+ （選用） AWS IoT 物件群組。您可以使用物件群組來管理 Greengrass 核心裝置的機群。當您將軟體元件部署到裝置時，您可以選擇部署到個別裝置或裝置群組。您可以將裝置新增至物件群組，將該物件群組的軟體元件部署到裝置。如需詳細資訊，請參閱[將 AWS IoT Greengrass 元件部署至裝置](manage-deployments.md)。
+ IAM 角色。Greengrass 核心裝置使用 AWS IoT Core 登入資料提供者來授權呼叫具有 IAM 角色 AWS 的服務。此角色可讓您的裝置與 互動 AWS IoT、將日誌傳送至 Amazon CloudWatch Logs，以及從 Amazon Simple Storage Service (Amazon S3) 下載自訂元件成品。如需詳細資訊，請參閱[授權核心裝置與 AWS 服務互動](device-service-role.md)。
+ AWS IoT 角色別名。Greengrass 核心裝置使用角色別名來識別要使用的 IAM 角色。角色別名可讓您變更 IAM 角色，但保持裝置組態相同。如需詳細資訊，請參閱《 *AWS IoT Core 開發人員指南*》中的[授權直接呼叫 AWS 服務](https://docs.aws.amazon.com/iot/latest/developerguide/authorizing-direct-aws.html)。
選擇下列其中一個選項，在您的核心裝置上安裝 AWS IoT Greengrass Core 軟體。
+ **快速安裝**
選擇此選項，以盡可能少的步驟設定 Greengrass 核心裝置。安裝程式會為您建立所需的 AWS IoT 和 IAM 資源。此選項需要您提供 AWS 登入資料給安裝程式，以在 中建立資源 AWS 帳戶。
您無法使用此選項在防火牆或網路代理後方安裝 。如果您的裝置位於防火牆或網路代理之後，請考慮[手動安裝](manual-installation.md)。
如需詳細資訊，請參閱[使用自動資源佈建安裝 AWS IoT Greengrass 核心軟體](quick-installation.md)。
+ **手動安裝**
選擇此選項可手動建立所需的 AWS 資源，或安裝在防火牆或網路代理後方。透過使用手動安裝，您不需要授予安裝程式在 中建立資源的許可 AWS 帳戶，因為您建立必要的 AWS IoT 和 IAM 資源。您也可以將裝置設定為在連接埠 443 上或透過網路代理進行連線。您也可以將 AWS IoT Greengrass Core 軟體設定為使用存放在硬體安全模組 (HSM)、信任平台模組 (TPM) 或其他密碼編譯元素中的私有金鑰和憑證。
如需詳細資訊，請參閱[使用手動資源佈建安裝 AWS IoT Greengrass 核心軟體](manual-installation.md)。
+ **使用 AWS IoT 機群佈建進行安裝**
選擇此選項，從 AWS IoT 機群佈建範本建立所需的 AWS 資源。您可以選擇此選項在機群中建立類似的裝置，或者如果您製造客戶稍後啟用的裝置，例如車輛或智慧型家用裝置。裝置使用宣告憑證來驗證和佈建 AWS 資源，包括裝置用來連線至 以進行正常操作 AWS 雲端 的 X.509 用戶端憑證。您可以在製造期間將宣告憑證嵌入或刷新到裝置的硬體，而且您可以使用相同的宣告憑證和金鑰來佈建多個裝置。您也可以設定裝置在連接埠 443 上或透過網路代理進行連線。
如需詳細資訊，請參閱[使用 AWS IoT 機群佈建安裝 AWS IoT Greengrass 核心軟體](fleet-provisioning.md)。
+ **使用自訂佈建安裝**
選擇此選項可開發自訂 Java 應用程式，以佈建所需的 AWS 資源。如果您[建立自己的 X.509 用戶端憑證](https://docs.aws.amazon.com/iot/latest/developerguide/device-certs-your-own.html)，或想要對佈建程序有更多控制權，您可以選擇此選項。 AWS IoT Greengrass 提供可實作的界面，以便在自訂佈建應用程式與 AWS IoT Greengrass Core 軟體安裝程式之間交換資訊。
如需詳細資訊，請參閱[使用自訂資源佈建安裝 AWS IoT Greengrass 核心軟體](custom-provisioning.md)。
AWS IoT Greengrass 也提供執行 AWS IoT Greengrass Core 軟體的容器化環境。您可以使用 Dockerfile 在 [Docker AWS IoT Greengrass 容器中執行](run-greengrass-docker.md)。
**Topics**
+ [使用自動佈建安裝](quick-installation.md)
+ [使用手動佈建安裝](manual-installation.md)
+ [使用機群佈建安裝](fleet-provisioning.md)
+ [使用自訂佈建安裝](custom-provisioning.md)
+ [安裝程式引數](configure-installer.md)
# 使用自動資源佈建安裝 AWS IoT Greengrass 核心軟體
Core AWS IoT Greengrass 軟體包含安裝程式，可將您的裝置設定為 Greengrass 核心裝置。若要快速設定裝置，安裝程式可以佈建核心裝置操作所需的 AWS IoT 物件、 AWS IoT 物件群組、IAM 角色和 AWS IoT 角色別名。安裝程式也可以將本機開發工具部署到核心裝置，因此您可以使用裝置來開發和測試自訂軟體元件。安裝程式需要 AWS 登入資料才能佈建這些資源並建立部署。
如果您無法提供 AWS 登入資料給裝置，您可以佈建核心裝置操作所需的 AWS 資源。您也可以將開發工具部署到核心裝置，以用作開發裝置。這可讓您在執行安裝程式時為裝置提供較少的許可。如需詳細資訊，請參閱[使用手動資源佈建安裝 AWS IoT Greengrass 核心軟體](manual-installation.md)。
**重要**
下載 AWS IoT Greengrass Core 軟體之前，請檢查您的核心裝置是否符合安裝和執行 AWS IoT Greengrass Core 軟體 v2.0 [的需求](greengrass-nucleus-component.md#greengrass-v2-requirements)。
**Topics**
+ [設定裝置環境](#set-up-device-environment)
+ [提供 AWS 登入資料給裝置](#provide-installer-aws-credentials)
+ [下載 AWS IoT Greengrass 核心軟體](#download-greengrass-core-v2)
+ [安裝 AWS IoT Greengrass 核心軟體](#run-greengrass-core-v2-installer)
## 設定裝置環境
請依照本節中的步驟設定 Linux 或 Windows 裝置，以用作您的 AWS IoT Greengrass 核心裝置。
### 設定 Linux 裝置
**設定 的 Linux 裝置 AWS IoT Greengrass V2**
1. 安裝執行 AWS IoT Greengrass 核心軟體所需的 Java 執行時間。我們建議您使用 [Amazon Corretto](https://aws.amazon.com/corretto/) 或 [OpenJDK](https://openjdk.java.net/) 長期支援版本。第 8 版或更新版本為必要項目。下列命令說明如何在裝置上安裝 OpenJDK。
+ 針對 Debian 為基礎或 Ubuntu 為基礎的發行版本：
```
sudo apt install default-jdk
```
+ 針對 Red Hat 為基礎的發行版本：
```
sudo yum install java-11-openjdk-devel
```
+ 針對 Amazon Linux 2：
```
sudo amazon-linux-extras install java-openjdk11
```
+ 針對 Amazon Linux 2023：
```
sudo dnf install java-11-amazon-corretto -y
```
安裝完成時，請執行下列命令來驗證 Java 是否在您的 Linux 裝置上執行。
```
java -version
```
命令會列印在裝置上執行的 Java 版本。例如，在 Debian 型分佈上，輸出看起來可能會類似下列範例。
```
openjdk version "11.0.9.1" 2020-11-04
OpenJDK Runtime Environment (build 11.0.9.1+1-post-Debian-1deb10u2)
OpenJDK 64-Bit Server VM (build 11.0.9.1+1-post-Debian-1deb10u2, mixed mode)
```
1. （選用） 建立在裝置上執行元件的預設系統使用者和群組。您也可以選擇讓 AWS IoT Greengrass Core 軟體安裝程式在安裝期間使用`--component-default-user`安裝程式引數建立此使用者和群組。如需詳細資訊，請參閱[安裝程式引數](configure-installer.md)。
```
sudo useradd --system --create-home ggc_user
sudo groupadd --system ggc_group
```
1. 確認執行 AWS IoT Greengrass 核心軟體的使用者 （通常為 `root`) 具有使用任何使用者和任何群組執行 `sudo` 的許可。
1. 執行下列命令以開啟 `/etc/sudoers` 檔案。
```
sudo visudo
```
1. 確認使用者的許可如下範例所示。
```
root ALL=(ALL:ALL) ALL
```
1. （選用） 若要[執行容器化 Lambda 函數](run-lambda-functions.md)，您必須啟用 [cgroups](https://en.wikipedia.org/wiki/Cgroups) v1，而且必須啟用和掛載*記憶體*和*裝置* cgroups。如果您不打算執行容器化 Lambda 函數，您可以略過此步驟。
若要啟用這些 cgroups 選項，請使用下列 Linux 核心參數啟動裝置。
```
cgroup_enable=memory cgroup_memory=1 systemd.unified_cgroup_hierarchy=0
```
如需有關檢視和設定裝置核心參數的資訊，請參閱作業系統和開機載入器的文件。依照指示永久設定核心參數。
1. 在裝置上安裝所有其他必要的相依性，如 中的需求清單所示[裝置要求](greengrass-nucleus-component.md#greengrass-v2-requirements)。
### 設定 Windows 裝置
**注意**
此功能適用於 [Greengrass 核元件](greengrass-nucleus-component.md)的 v2.5.0 和更新版本。
**為 設定 Windows 裝置 AWS IoT Greengrass V2**
1. 安裝執行 AWS IoT Greengrass 核心軟體所需的 Java 執行時間。我們建議您使用 [Amazon Corretto](https://aws.amazon.com/corretto/) 或 [OpenJDK](https://openjdk.java.net/) 長期支援版本。第 8 版或更新版本為必要項目。
1. 檢查 [PATH](https://en.wikipedia.org/wiki/PATH_(variable)) 系統變數上是否提供 Java，如果沒有，請新增它。LocalSystem 帳戶會執行 AWS IoT Greengrass Core 軟體，因此您必須將 Java 新增至 PATH 系統變數，而不是使用者的 PATH 使用者變數。請執行下列操作：
1. 按 Windows 鍵開啟開始選單。
1. 輸入 **environment variables** 以從開始功能表搜尋系統選項。
1. 在開始功能表搜尋結果中，選擇**編輯系統環境變數**以開啟**系統屬性**視窗。
1. 選擇**環境變數...**以開啟**環境變數**視窗。
1. 在**系統變數**下，選取**路徑**，然後選擇**編輯**。在**編輯環境變數**視窗中，您可以檢視個別行上的每個路徑。
1. 檢查 Java 安裝`bin`資料夾的路徑是否存在。路徑看起來可能會類似下列範例。
```
C:\\Program Files\\Amazon Corretto\\jdk11.0.13_8\\bin
```
1. 如果**路徑**中缺少 Java 安裝的`bin`資料夾，請選擇**新增**以新增，然後選擇**確定**。
1. 以管理員身分開啟 Windows 命令提示字元 (`cmd.exe`)。
1. 在 Windows 裝置上的 LocalSystem 帳戶中建立預設使用者。將*密碼*取代為安全密碼。
```
net user /add ggc_user password
```
**提示**
根據您的 Windows 組態，使用者的密碼可能會設定為在未來的日期過期。為了確保您的 Greengrass 應用程式持續運作，請追蹤密碼過期的時間，並在過期之前更新它。您也可以將使用者的密碼設定為永不過期。
若要檢查使用者及其密碼何時過期，請執行下列命令。
```
net user ggc_user | findstr /C:expires
```
若要將使用者的密碼設定為永不過期，請執行下列命令。
```
wmic UserAccount where "Name='ggc_user'" set PasswordExpires=False
```
如果您使用的是[`wmic`已棄用命令](https://learn.microsoft.com/en-us/windows/win32/wmisdk/wmic)的 Windows 10 或更新版本，請執行下列 PowerShell 命令。
```
Get-CimInstance -Query "SELECT * from Win32_UserAccount WHERE name = 'ggc_user'" | Set-CimInstance -Property @{PasswordExpires="False"}
```
1. 從 Microsoft 在裝置上下載並安裝 [PsExec 公用程式](https://docs.microsoft.com/en-us/sysinternals/downloads/psexec)。
1. 使用 PsExec 公用程式，將預設使用者的使用者名稱和密碼存放在 LocalSystem 帳戶的 Credential Manager 執行個體中。將*密碼*取代為您先前設定的使用者密碼。
```
psexec -s cmd /c cmdkey /generic:ggc_user /user:ggc_user /pass:password
```
如果 **PsExec License Agreement** 開啟，請選擇 以**Accept**同意授權並執行 命令。
**注意**
在 Windows 裝置上，LocalSystem 帳戶會執行 Greengrass 核，而且您必須使用 PsExec 公用程式將預設使用者資訊存放在 LocalSystem 帳戶中。使用 Credential Manager 應用程式會將此資訊存放在目前登入使用者的 Windows 帳戶中，而不是 LocalSystem 帳戶。
## 提供 AWS 登入資料給裝置
將 AWS 登入資料提供給您的裝置，讓安裝程式可以佈建所需的 AWS 資源。如需所需許可的詳細資訊，請參閱[安裝程式佈建資源的最低 IAM 政策](provision-minimal-iam-policy.md)。
**提供 AWS 登入資料給裝置**
+ 將 AWS 登入資料提供給裝置，讓安裝程式可以為您的核心裝置佈建 AWS IoT 和 IAM 資源。為了提高安全性，我們建議您取得 IAM 角色的臨時登入資料，只允許佈建所需的最低許可。如需詳細資訊，請參閱[安裝程式佈建資源的最低 IAM 政策](provision-minimal-iam-policy.md)。
**注意**
安裝程式不會儲存或存放您的登入資料。
在您的裝置上，執行下列其中一項操作來擷取登入資料，並將其提供給 AWS IoT Greengrass Core 軟體安裝程式：
+ （建議） 使用來自 的臨時登入資料 AWS IAM Identity Center
1. 從 IAM Identity Center 提供存取金鑰 ID、私密存取金鑰和工作階段字符。如需詳細資訊，請參閱《*IAM Identity Center 使用者指南*》中的[取得和重新整理暫時憑證](https://docs.aws.amazon.com/singlesignon/latest/userguide/howtogetcredentials.html#how-to-get-temp-credentials)中的**手動憑證重新整理**。
1. 執行下列命令，將登入資料提供給 AWS IoT Greengrass 核心軟體。
------
#### [ Linux or Unix ]
```
export AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
export AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
export AWS_SESSION_TOKEN=AQoDYXdzEJr1K...o5OytwEXAMPLE=
```
------
#### [ Windows Command Prompt (CMD) ]
```
set AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
set AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
set AWS_SESSION_TOKEN=AQoDYXdzEJr1K...o5OytwEXAMPLE=
```
------
#### [ PowerShell ]
```
$env:AWS_ACCESS_KEY_ID="AKIAIOSFODNN7EXAMPLE"
$env:AWS_SECRET_ACCESS_KEY="wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
$env:AWS_SESSION_TOKEN="AQoDYXdzEJr1K...o5OytwEXAMPLE="
```
------
+ 使用來自 IAM 角色的臨時安全登入資料：
1. 提供您擔任之 IAM 角色的存取金鑰 ID、私密存取金鑰和工作階段字符。如需如何擷取這些登入資料的詳細資訊，請參閱《*IAM 使用者指南*》中的[請求臨時安全登入](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html)資料。
1. 執行下列命令，將登入資料提供給 AWS IoT Greengrass 核心軟體。
------
#### [ Linux or Unix ]
```
export AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
export AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
export AWS_SESSION_TOKEN=AQoDYXdzEJr1K...o5OytwEXAMPLE=
```
------
#### [ Windows Command Prompt (CMD) ]
```
set AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
set AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
set AWS_SESSION_TOKEN=AQoDYXdzEJr1K...o5OytwEXAMPLE=
```
------
#### [ PowerShell ]
```
$env:AWS_ACCESS_KEY_ID="AKIAIOSFODNN7EXAMPLE"
$env:AWS_SECRET_ACCESS_KEY="wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
$env:AWS_SESSION_TOKEN="AQoDYXdzEJr1K...o5OytwEXAMPLE="
```
------
+ 使用來自 IAM 使用者的長期登入資料：
1. 為您的 IAM 使用者提供存取金鑰 ID 和私密存取金鑰。您可以建立 IAM 使用者來佈建您稍後刪除的項目。如需提供使用者的 IAM 政策，請參閱 [安裝程式佈建資源的最低 IAM 政策](provision-minimal-iam-policy.md)。如需如何擷取長期憑證的詳細資訊，請參閱《[IAM 使用者指南》中的管理 IAM 使用者的存取金鑰](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html)。 **
1. 執行下列命令，將登入資料提供給 AWS IoT Greengrass 核心軟體。
------
#### [ Linux or Unix ]
```
export AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
export AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
```
------
#### [ Windows Command Prompt (CMD) ]
```
set AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
set AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
```
------
#### [ PowerShell ]
```
$env:AWS_ACCESS_KEY_ID="AKIAIOSFODNN7EXAMPLE"
$env:AWS_SECRET_ACCESS_KEY="wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
```
------
1. （選用） 如果您建立了 IAM 使用者來佈建 Greengrass 裝置，請刪除該使用者。
1. （選用） 如果您使用現有 IAM 使用者的存取金鑰 ID 和私密存取金鑰，請更新使用者的金鑰，使其不再有效。如需詳細資訊，請參閱《 *AWS Identity and Access Management 使用者指南*》中的[更新存取金鑰](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html#Using_RotateAccessKey)。
## 下載 AWS IoT Greengrass 核心軟體
您可以從下列位置下載最新版本的 AWS IoT Greengrass Core 軟體：
+ [https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip](https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip)
**注意**
您可以從下列位置下載特定版本的 AWS IoT Greengrass 核心軟體。將*版本*取代為要下載的版本。
```
https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-version.zip
```
**下載 AWS IoT Greengrass 核心軟體**
1. 在您的核心裝置上，將 AWS IoT Greengrass Core 軟體下載至名為 的檔案`greengrass-nucleus-latest.zip`。
------
#### [ Linux or Unix ]
```
curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip > greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
```
curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip > greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
```
iwr -Uri https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip -OutFile greengrass-nucleus-latest.zip
```
------
下載此軟體，即表示您同意 [Greengrass 核心軟體授權合約](https://greengrass-release-license.s3.us-west-2.amazonaws.com/greengrass-license-v1.pdf)之規定。
1. （選用） 驗證 Greengrass 核軟體簽章
**注意**
此功能適用於 Greengrass 核版本 2.9.5 和更新版本。
1. 使用下列命令來驗證 Greengrass 核子成品的簽章：
------
#### [ Linux or Unix ]
```
jarsigner -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
檔案名稱看起來可能會有所不同，視您安裝的 JDK 版本而定。*`jdk17.0.6_10`* 將 取代為您安裝的 JDK 版本。
```
"C:\\Program Files\\Amazon Corretto\\jdk17.0.6_10\\bin\\jarsigner.exe" -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
檔案名稱看起來可能會有所不同，視您安裝的 JDK 版本而定。*`jdk17.0.6_10`* 將 取代為您安裝的 JDK 版本。
```
'C:\\Program Files\\Amazon Corretto\\jdk17.0.6_10\\bin\\jarsigner.exe' -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
1. `jarsigner` 調用會產生輸出，指出驗證的結果。
1. 如果已簽署 Greengrass 核 zip 檔案，輸出會包含下列陳述式：
```
jar verified.
```
1. 如果 Greengrass 核 zip 檔案未簽署，輸出會包含下列陳述式：
```
jar is unsigned.
```
1. 如果您提供 Jarsigner `-certs`選項以及 `-verify`和 `-verbose`選項，輸出也會包含詳細的簽署者憑證資訊。
1. 將 AWS IoT Greengrass Core 軟體解壓縮至裝置上的資料夾。將 *GreengrassInstaller* 取代為您要使用的資料夾。
------
#### [ Linux or Unix ]
```
unzip greengrass-nucleus-latest.zip -d GreengrassInstaller && rm greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
```
mkdir GreengrassInstaller && tar -xf greengrass-nucleus-latest.zip -C GreengrassInstaller && del greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
```
Expand-Archive -Path greengrass-nucleus-latest.zip -DestinationPath .\\GreengrassInstaller
rm greengrass-nucleus-latest.zip
```
------
1. （選用） 執行下列命令以查看 AWS IoT Greengrass 核心軟體版本。
```
java -jar ./GreengrassInstaller/lib/Greengrass.jar --version
```
**重要**
如果您安裝的 Greengrass 核版本早於 2.4.0 版，請勿在安裝 AWS IoT Greengrass 核心軟體之後移除此資料夾。Core AWS IoT Greengrass 軟體會使用此資料夾中的檔案來執行。
如果您下載最新版本的軟體，請安裝 v2.4.0 或更新版本，並在安裝 AWS IoT Greengrass Core 軟體後移除此資料夾。
## 安裝 AWS IoT Greengrass 核心軟體
使用指定 執行下列動作的引數執行安裝程式：
+ 建立核心裝置操作所需的 AWS 資源。
+ 指定 以使用`ggc_user`系統使用者在核心裝置上執行軟體元件。在 Linux 裝置上，此命令也會指定 使用`ggc_group`系統群組，安裝程式會為您建立系統使用者和群組。
+ 將 AWS IoT Greengrass Core 軟體設定為開機時執行的系統服務。在 Linux 裝置上，這需要 [Systemd](https://en.wikipedia.org/wiki/Systemd) init 系統。
**重要**
在 Windows 核心裝置上，您必須將 AWS IoT Greengrass Core 軟體設定為系統服務。
若要使用本機開發工具設定開發裝置，請指定 `--deploy-dev-tools true`引數。安裝完成後，本機開發工具最多可能需要一分鐘的時間才能部署。
如需可指定引數的詳細資訊，請參閱 [安裝程式引數](configure-installer.md)。
**注意**
如果您在記憶體有限的 AWS IoT Greengrass 裝置上執行 ，您可以控制 AWS IoT Greengrass Core 軟體使用的記憶體量。若要控制記憶體配置，您可以在核心元件的`jvmOptions`組態參數中設定 JVM 堆積大小選項。如需詳細資訊，請參閱[使用 JVM 選項控制記憶體配置](configure-greengrass-core-v2.md#jvm-tuning)。
**安裝 AWS IoT Greengrass 核心軟體**
1. 執行 AWS IoT Greengrass Core 安裝程式。取代命令中的引數值，如下所示。
**注意**
Windows 的路徑長度限制為 260 個字元。如果您使用的是 Windows，請使用根資料夾，例如 `C:\greengrass\v2`或 `D:\greengrass\v2` ，將 Greengrass 元件路徑保持在 260 個字元的限制以下。
1. `/greengrass/v2` 或 *C：\$1greengrass\$1v2*：用來安裝 AWS IoT Greengrass Core 軟體的根資料夾路徑。
1. *GreengrassInstaller*。解壓縮 AWS IoT Greengrass Core 軟體安裝程式的資料夾路徑。
1. *區域*。尋找或建立資源 AWS 區域 的 。
1. *MyGreengrassCore*。Greengrass 核心裝置的 AWS IoT 物件名稱。如果物件不存在，安裝程式會建立它。安裝程式會下載憑證以驗證為 AWS IoT 實物。如需詳細資訊，請參閱[的裝置身分驗證和授權 AWS IoT Greengrass](device-auth.md)。
**注意**
物件名稱不能包含冒號 (`:`) 字元。
1. *MyGreengrassCoreGroup*。Greengrass 核心裝置的 AWS IoT 物件群組名稱。如果物件群組不存在，安裝程式會建立它，並將該物件新增至其中。如果物件群組存在且具有作用中部署，核心裝置會下載並執行部署指定的軟體。
**注意**
物件群組名稱不能包含冒號 (`:`) 字元。
1. *GreengrassV2IoTThingPolicy*。允許 Greengrass 核心裝置與 AWS IoT 和 通訊 AWS IoT 的政策名稱 AWS IoT Greengrass。如果 AWS IoT 政策不存在，安裝程式會使用此名稱建立寬鬆 AWS IoT 政策。您可以限制此政策的許可給您的使用案例。如需詳細資訊，請參閱[AWS IoT Greengrass V2 核心裝置的最低 AWS IoT 政策](device-auth.md#greengrass-core-minimal-iot-policy)。
1. *GreengrassV2TokenExchangeRole*。允許 Greengrass 核心裝置取得臨時 AWS 登入資料的 IAM 角色名稱。如果角色不存在，安裝程式會建立該角色，並建立和連接名為 的政策`GreengrassV2TokenExchangeRoleAccess`。如需詳細資訊，請參閱[授權核心裝置與 AWS 服務互動](device-service-role.md)。
1. *GreengrassCoreTokenExchangeRoleAlias*。IAM 角色的別名，允許 Greengrass 核心裝置稍後取得臨時登入資料。如果角色別名不存在，安裝程式會建立它，並將其指向您指定的 IAM 角色。如需詳細資訊，請參閱[授權核心裝置與 AWS 服務互動](device-service-role.md)。
------
#### [ Linux or Unix ]
```
sudo -E java -Droot="/greengrass/v2" -Dlog.store=FILE \
-jar ./GreengrassInstaller/lib/Greengrass.jar \
--aws-region region \
--thing-name MyGreengrassCore \
--thing-group-name MyGreengrassCoreGroup \
--thing-policy-name GreengrassV2IoTThingPolicy \
--tes-role-name GreengrassV2TokenExchangeRole \
--tes-role-alias-name GreengrassCoreTokenExchangeRoleAlias \
--component-default-user ggc_user:ggc_group \
--provision true \
--setup-system-service true
```
------
#### [ Windows Command Prompt (CMD) ]
```
java -Droot="C:\greengrass\v2" "-Dlog.store=FILE" ^
-jar ./GreengrassInstaller/lib/Greengrass.jar ^
--aws-region region ^
--thing-name MyGreengrassCore ^
--thing-group-name MyGreengrassCoreGroup ^
--thing-policy-name GreengrassV2IoTThingPolicy ^
--tes-role-name GreengrassV2TokenExchangeRole ^
--tes-role-alias-name GreengrassCoreTokenExchangeRoleAlias ^
--component-default-user ggc_user ^
--provision true ^
--setup-system-service true
```
------
#### [ PowerShell ]
```
java -Droot="C:\greengrass\v2" "-Dlog.store=FILE" `
-jar ./GreengrassInstaller/lib/Greengrass.jar `
--aws-region region `
--thing-name MyGreengrassCore `
--thing-group-name MyGreengrassCoreGroup `
--thing-policy-name GreengrassV2IoTThingPolicy `
--tes-role-name GreengrassV2TokenExchangeRole `
--tes-role-alias-name GreengrassCoreTokenExchangeRoleAlias `
--component-default-user ggc_user `
--provision true `
--setup-system-service true
```
------
**重要**
在 Windows 核心裝置上，您必須指定 `--setup-system-service true`將 AWS IoT Greengrass Core 軟體設定為系統服務。
如果成功，安裝程式會列印下列訊息：
+ 如果您指定 `--provision`，安裝程式會在成功設定資源`Successfully configured Nucleus with provisioned resource details`時列印。
+ 如果您指定 `--deploy-dev-tools`，`Configured Nucleus to deploy aws.greengrass.Cli component`安裝程式會在成功建立部署時列印。
+ 如果您指定 `--setup-system-service true`，安裝程式會在設定並執行軟體做為服務`Successfully set up Nucleus as a system service`時列印。
+ 如果您未指定 `--setup-system-service true`，安裝程式`Launched Nucleus successfully`會在成功時列印並執行軟體。
1. 如果您安裝 v2[Greengrass 核](greengrass-nucleus-component.md).0.4 或更新版本，請略過此步驟。如果您下載了最新版本的軟體，則已安裝 v2.0.4 或更新版本。
執行下列命令，為您的 AWS IoT Greengrass Core 軟體根資料夾設定所需的檔案許可。`/greengrass/v2` 以您在安裝命令中指定的根資料夾取代 ，並以根資料夾的父資料夾取代 */greengrass*。
```
sudo chmod 755 /greengrass/v2 && sudo chmod 755 /greengrass
```
如果您將 AWS IoT Greengrass Core 軟體安裝為系統服務，安裝程式會為您執行軟體。否則，您必須手動執行軟體。如需詳細資訊，請參閱[執行 AWS IoT Greengrass 核心軟體](run-greengrass-core-v2.md)。
**注意**
根據預設，安裝程式建立的 IAM 角色不允許存取 S3 儲存貯體中的元件成品。若要在 Amazon S3 中部署定義成品的自訂元件，您必須將許可新增至角色，以允許核心裝置擷取元件成品。如需詳細資訊，請參閱[允許存取元件成品的 S3 儲存貯體](device-service-role.md#device-service-role-access-s3-bucket)。
如果您還沒有元件成品的 S3 儲存貯體，您可以在建立儲存貯體之後新增這些許可。
**注意**
當 AWS IoT Greengrass Core 軟體連線至雲端時，您的裝置將被識別為 Core 裝置。
如需如何設定和使用軟體和 的詳細資訊 AWS IoT Greengrass，請參閱以下內容：
+ [設定 AWS IoT Greengrass 核心軟體](configure-greengrass-core-v2.md)
+ [開發 AWS IoT Greengrass 元件](develop-greengrass-components.md)
+ [將 AWS IoT Greengrass 元件部署至裝置](manage-deployments.md)
+ [Greengrass 命令列界面](gg-cli.md)
# 使用手動資源佈建安裝 AWS IoT Greengrass 核心軟體
Core AWS IoT Greengrass 軟體包含安裝程式，可將您的裝置設定為 Greengrass 核心裝置。若要手動設定裝置，您可以建立裝置要使用的必要 AWS IoT 和 IAM 資源。如果您手動建立這些資源，則不需要提供 AWS 登入資料給安裝程式。
當您手動安裝 AWS IoT Greengrass Core 軟體時，您也可以將裝置設定為使用網路代理或在連接埠 443 AWS 上連線至 。例如，如果您的裝置在防火牆或網路代理之後執行，您可能需要指定這些組態選項。如需詳細資訊，請參閱[連線至連接埠 443 或透過網路代理](configure-greengrass-core-v2.md#configure-alpn-network-proxy)。
您也可以設定 AWS IoT Greengrass Core 軟體，透過 [PKCS\$111 介面](https://en.wikipedia.org/wiki/PKCS_11)使用硬體安全模組 (HSM)。此功能可讓您安全地存放私有金鑰和憑證檔案，使其不會在軟體中公開或複製。您可以在硬體模組上存放私有金鑰和憑證，例如 HSM、信任平台模組 (TPM) 或其他密碼編譯元素。此功能僅適用於 Linux 裝置。如需硬體安全性和使用需求的詳細資訊，請參閱 [硬體安全整合](hardware-security.md)。
**重要**
下載 AWS IoT Greengrass Core 軟體之前，請檢查您的核心裝置是否符合安裝和執行 AWS IoT Greengrass Core 軟體 v2.0 [的需求](greengrass-nucleus-component.md#greengrass-v2-requirements)。
**Topics**
+ [擷取 AWS IoT 端點](#retrieve-iot-endpoints)
+ [建立 AWS IoT 物件](#create-iot-thing)
+ [建立物件憑證](#create-thing-certificate)
+ [設定物件憑證](#configure-thing-certificate)
+ [建立權杖交換角色](#create-token-exchange-role)
+ [下載憑證至裝置](#download-thing-certificates)
+ [設定裝置環境](#set-up-device-environment)
+ [下載 AWS IoT Greengrass 核心軟體](#download-greengrass-core-v2)
+ [安裝 AWS IoT Greengrass 核心軟體](#run-greengrass-core-v2-installer-manual)
## 擷取 AWS IoT 端點
取得 的 AWS IoT 端點 AWS 帳戶，並儲存它們以供稍後使用。您的裝置會使用這些端點來連線 AWS IoT。請執行下列操作：
1. 取得 AWS IoT 的資料端點 AWS 帳戶。
```
aws iot describe-endpoint --endpoint-type iot:Data-ATS
```
如果請求成功，回應看起來與下列範例類似。
```
{
"endpointAddress": "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
}
```
1. 取得 的 AWS IoT 登入資料端點 AWS 帳戶。
```
aws iot describe-endpoint --endpoint-type iot:CredentialProvider
```
如果請求成功，回應看起來與下列範例類似。
```
{
"endpointAddress": "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
}
```
## 建立 AWS IoT 物件
AWS IoT *物件*代表連線至 的裝置和邏輯實體 AWS IoT。Greengrass 核心裝置是 AWS IoT 實物。當您將裝置註冊為 AWS IoT 物件時，該裝置可以使用數位憑證進行身分驗證 AWS。
在本節中，您會建立代表裝置的 AWS IoT 物件。
**建立 AWS IoT 物件**
1. 為您的裝置建立 AWS IoT 物件。在您的開發電腦上，執行下列命令。
+ 將 *MyGreengrassCore* 取代為要使用的物件名稱。此名稱也是 Greengrass 核心裝置的名稱。
**注意**
物件名稱不能包含冒號 (`:`) 字元。
```
aws iot create-thing --thing-name MyGreengrassCore
```
如果請求成功，回應看起來與下列範例類似。
```
{
"thingName": "MyGreengrassCore",
"thingArn": "arn:aws:iot:us-west-2:123456789012:thing/MyGreengrassCore",
"thingId": "8cb4b6cd-268e-495d-b5b9-1713d71dbf42"
}
```
1. （選用） 將 AWS IoT 物件新增至新的或現有的物件群組。您可以使用物件群組來管理 Greengrass 核心裝置的機群。將軟體元件部署至裝置時，您可以將個別裝置或裝置群組設為目標。您可以將裝置新增至具有作用中 Greengrass 部署的物件群組，以將該物件群組的軟體元件部署到裝置。請執行下列操作：
1. （選用） 建立 AWS IoT 物件群組。
+ 將 *MyGreengrassCoreGroup* 取代為要建立的物件群組名稱。
**注意**
物件群組名稱不能包含冒號 (`:`) 字元。
```
aws iot create-thing-group --thing-group-name MyGreengrassCoreGroup
```
如果請求成功，回應看起來與下列範例類似。
```
{
"thingGroupName": "MyGreengrassCoreGroup",
"thingGroupArn": "arn:aws:iot:us-west-2:123456789012:thinggroup/MyGreengrassCoreGroup",
"thingGroupId": "4df721e1-ff9f-4f97-92dd-02db4e3f03aa"
}
```
1. 將 AWS IoT 物件新增至物件群組。
+ 將 *MyGreengrassCore* 取代為您 AWS IoT 物件的名稱。
+ 將 *MyGreengrassCoreGroup* 取代為物件群組的名稱。
```
aws iot add-thing-to-thing-group --thing-name MyGreengrassCore --thing-group-name MyGreengrassCoreGroup
```
如果請求成功，命令不會有任何輸出。
## 建立物件憑證
當您將裝置註冊為 AWS IoT 物件時，該裝置可以使用數位憑證進行身分驗證 AWS。此憑證可讓裝置與 AWS IoT 和 通訊 AWS IoT Greengrass。
在本節中，您可以建立和下載裝置可用來連線的憑證 AWS。
如果您想要將 AWS IoT Greengrass Core 軟體設定為使用硬體安全模組 (HSM) 來安全地存放私有金鑰和憑證，請依照步驟從 HSM 中的私有金鑰建立憑證。否則，請依照步驟在 AWS IoT 服務中建立憑證和私有金鑰。硬體安全功能僅適用於 Linux 裝置。如需硬體安全性和使用需求的詳細資訊，請參閱 [硬體安全整合](hardware-security.md)。
### 在 AWS IoT 服務中建立憑證和私有金鑰
**建立物件憑證**
1. 建立資料夾以下載 AWS IoT 物件的憑證。
```
mkdir greengrass-v2-certs
```
1. 建立並下載 AWS IoT 物件的憑證。
```
aws iot create-keys-and-certificate --set-as-active --certificate-pem-outfile greengrass-v2-certs/device.pem.crt --public-key-outfile greengrass-v2-certs/public.pem.key --private-key-outfile greengrass-v2-certs/private.pem.key
```
如果請求成功，回應看起來與下列範例類似。
```
{
"certificateArn": "arn:aws:iot:us-west-2:123456789012:cert/aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4",
"certificateId": "aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4",
"certificatePem": "-----BEGIN CERTIFICATE-----
MIICiTCCAfICCQD6m7oRw0uXOjANBgkqhkiG9w
0BAQUFADCBiDELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAldBMRAwDgYDVQQHEwdTZ
WF0dGxlMQ8wDQYDVQQKEwZBbWF6b24xFDASBgNVBAsTC0lBTSBDb25zb2xlMRIw
EAYDVQQDEwlUZXN0Q2lsYWMxHzAdBgkqhkiG9w0BCQEWEG5vb25lQGFtYXpvbi5
jb20wHhcNMTEwNDI1MjA0NTIxWhcNMTIwNDI0MjA0NTIxWjCBiDELMAkGA1UEBh
MCVVMxCzAJBgNVBAgTAldBMRAwDgYDVQQHEwdTZWF0dGxlMQ8wDQYDVQQKEwZBb
WF6b24xFDASBgNVBAsTC0lBTSBDb25zb2xlMRIwEAYDVQQDEwlUZXN0Q2lsYWMx
HzAdBgkqhkiG9w0BCQEWEG5vb25lQGFtYXpvbi5jb20wgZ8wDQYJKoZIhvcNAQE
BBQADgY0AMIGJAoGBAMaK0dn+a4GmWIWJ21uUSfwfEvySWtC2XADZ4nB+BLYgVI
k60CpiwsZ3G93vUEIO3IyNoH/f0wYK8m9TrDHudUZg3qX4waLG5M43q7Wgc/MbQ
ITxOUSQv7c7ugFFDzQGBzZswY6786m86gpEIbb3OhjZnzcvQAaRHhdlQWIMm2nr
AgMBAAEwDQYJKoZIhvcNAQEFBQADgYEAtCu4nUhVVxYUntneD9+h8Mg9q6q+auN
KyExzyLwaxlAoo7TJHidbtS4J5iNmZgXL0FkbFFBjvSfpJIlJ00zbhNYS5f6Guo
EDmFJl0ZxBHjJnyp378OD8uTs7fLvjx79LjSTbNYiytVbZPQUQ5Yaxu2jXnimvw
3rrszlaEXAMPLE=
-----END CERTIFICATE-----",
"keyPair": {
"PublicKey": "-----BEGIN PUBLIC KEY-----\
MIIBIjANBgkqhkEXAMPLEQEFAAOCAQ8AMIIBCgKCAQEAEXAMPLE1nnyJwKSMHw4h\
MMEXAMPLEuuN/dMAS3fyce8DW/4+EXAMPLEyjmoF/YVF/gHr99VEEXAMPLE5VF13\
59VK7cEXAMPLE67GK+y+jikqXOgHh/xJTwo+sGpWEXAMPLEDz18xOd2ka4tCzuWEXAMPLEahJbYkCPUBSU8opVkR7qkEXAMPLE1DR6sx2HocliOOLtu6Fkw91swQWEXAMPLE\\GB3ZPrNh0PzQYvjUStZeccyNCx2EXAMPLEvp9mQOUXP6plfgxwKRX2fEXAMPLEDa\
hJLXkX3rHU2xbxJSq7D+XEXAMPLEcw+LyFhI5mgFRl88eGdsAEXAMPLElnI9EesG\
FQIDAQAB\
-----END PUBLIC KEY-----\
",
"PrivateKey": "-----BEGIN RSA PRIVATE KEY-----\
key omitted for security reasons\
-----END RSA PRIVATE KEY-----\
"
}
}
```
儲存憑證的 Amazon Resource Name (ARN)，以供稍後用於設定憑證。
### 從 HSM 中的私有金鑰建立憑證
**注意**
此功能適用於 [Greengrass 核元件](greengrass-nucleus-component.md)的 v2.5.3 和更新版本。目前 AWS IoT Greengrass 不支援 Windows 核心裝置上的此功能。
**建立物件憑證**
1. 在核心裝置上，初始化 HSM 中的 PKCS\$111 字符，並產生私有金鑰。私有金鑰必須是 RSA-2048 金鑰大小 （或更大） 或 ECC 金鑰的 RSA 金鑰。
**注意**
若要搭配 ECC 金鑰使用硬體安全模組，您必須使用 [Greengrass nucleus](greengrass-nucleus-component.md) v2.5.6 或更新版本。
若要使用硬體安全模組和[秘密管理員](secret-manager-component.md)，您必須搭配 RSA 金鑰使用硬體安全模組。
檢查您的 HSM 文件，了解如何初始化字符並產生私有金鑰。如果您的 HSM 支援物件 IDs，請在產生私有金鑰時指定物件 ID。儲存您在初始化字符和產生私有金鑰時指定的槽 ID、使用者 PIN、物件標籤、物件 ID （如果您的 HSM 使用）。您稍後將物件憑證匯入 HSM 並設定 AWS IoT Greengrass 核心軟體時，會使用這些值。
1. 從私有金鑰建立憑證簽署請求 (CSR)。 AWS IoT 使用此 CSR 為您在 HSM 中產生的私有金鑰建立物件憑證。如需有關如何從私有金鑰建立 CSR 的資訊，請參閱 HSM 的文件。CSR 是 檔案，例如 `iotdevicekey.csr`。
1. 將 CSR 從裝置複製到您的開發電腦。如果在開發電腦和裝置上啟用 SSH 和 SCP，您可以使用開發電腦上的 `scp`命令來傳輸 CSR。將 *device-ip-address* 取代為您裝置的 IP 地址，並將 *\$1/iotdevicekey.csr* 取代為裝置上的 CSR 檔案路徑。
```
scp device-ip-address:~/iotdevicekey.csr iotdevicekey.csr
```
1. 在開發電腦上，建立資料夾以下載 AWS IoT 物件的憑證。
```
mkdir greengrass-v2-certs
```
1. 使用 CSR 檔案來建立 AWS IoT 物件的憑證，並將其下載到您的開發電腦。
```
aws iot create-certificate-from-csr --set-as-active --certificate-signing-request=file://iotdevicekey.csr --certificate-pem-outfile greengrass-v2-certs/device.pem.crt
```
如果請求成功，回應看起來與下列範例類似。
```
{
"certificateArn": "arn:aws:iot:us-west-2:123456789012:cert/aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4",
"certificateId": "aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4",
"certificatePem": "-----BEGIN CERTIFICATE-----
MIICiTCCAfICCQD6m7oRw0uXOjANBgkqhkiG9w
0BAQUFADCBiDELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAldBMRAwDgYDVQQHEwdTZ
WF0dGxlMQ8wDQYDVQQKEwZBbWF6b24xFDASBgNVBAsTC0lBTSBDb25zb2xlMRIw
EAYDVQQDEwlUZXN0Q2lsYWMxHzAdBgkqhkiG9w0BCQEWEG5vb25lQGFtYXpvbi5
jb20wHhcNMTEwNDI1MjA0NTIxWhcNMTIwNDI0MjA0NTIxWjCBiDELMAkGA1UEBh
MCVVMxCzAJBgNVBAgTAldBMRAwDgYDVQQHEwdTZWF0dGxlMQ8wDQYDVQQKEwZBb
WF6b24xFDASBgNVBAsTC0lBTSBDb25zb2xlMRIwEAYDVQQDEwlUZXN0Q2lsYWMx
HzAdBgkqhkiG9w0BCQEWEG5vb25lQGFtYXpvbi5jb20wgZ8wDQYJKoZIhvcNAQE
BBQADgY0AMIGJAoGBAMaK0dn+a4GmWIWJ21uUSfwfEvySWtC2XADZ4nB+BLYgVI
k60CpiwsZ3G93vUEIO3IyNoH/f0wYK8m9TrDHudUZg3qX4waLG5M43q7Wgc/MbQ
ITxOUSQv7c7ugFFDzQGBzZswY6786m86gpEIbb3OhjZnzcvQAaRHhdlQWIMm2nr
AgMBAAEwDQYJKoZIhvcNAQEFBQADgYEAtCu4nUhVVxYUntneD9+h8Mg9q6q+auN
KyExzyLwaxlAoo7TJHidbtS4J5iNmZgXL0FkbFFBjvSfpJIlJ00zbhNYS5f6Guo
EDmFJl0ZxBHjJnyp378OD8uTs7fLvjx79LjSTbNYiytVbZPQUQ5Yaxu2jXnimvw
3rrszlaEXAMPLE=
-----END CERTIFICATE-----"
}
```
儲存憑證的 ARN，以供稍後用於設定憑證。
## 設定物件憑證
將物件憑證連接至您先前建立的 AWS IoT 物件，並將 AWS IoT 政策新增至憑證，以定義核心裝置的 AWS IoT 許可。
**設定物件的憑證**
1. 將憑證連接至 AWS IoT 物件。
+ 將 *MyGreengrassCore* 取代為您 AWS IoT 物件的名稱。
+ 將憑證 Amazon Resource Name (ARN) 取代為您在上一個步驟中建立之憑證的 ARN。
```
aws iot attach-thing-principal --thing-name MyGreengrassCore --principal arn:aws:iot:us-west-2:123456789012:cert/aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4
```
如果請求成功，命令不會有任何輸出。
1. 建立並連接 AWS IoT 政策，以定義 Greengrass 核心裝置的 AWS IoT 許可。下列政策允許存取所有 MQTT 主題和 Greengrass 操作，因此您的裝置可以使用需要新 Greengrass 操作的自訂應用程式和未來變更。您可以根據使用案例來限制此政策關閉。如需詳細資訊，請參閱[AWS IoT Greengrass V2 核心裝置的最低 AWS IoT 政策](device-auth.md#greengrass-core-minimal-iot-policy)。
如果您之前已設定 Greengrass 核心裝置，您可以連接其 AWS IoT 政策，而不是建立新的政策。
請執行下列操作：
1. 建立檔案，其中包含 Greengrass 核心裝置所需的 AWS IoT 政策文件。
例如，在以 Linux 為基礎的系統上，您可以執行下列命令來使用 GNU nano 來建立 檔案。
```
nano greengrass-v2-iot-policy.json
```
將下列 JSON 複製到 檔案。
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Publish",
"iot:Subscribe",
"iot:Receive",
"iot:Connect",
"greengrass:*"
],
"Resource": [
"*"
]
}
]
}
```
1. 從 AWS IoT 政策文件建立政策。
+ 將 *GreengrassV2IoTThingPolicy* 取代為要建立的政策名稱。
```
aws iot create-policy --policy-name GreengrassV2IoTThingPolicy --policy-document file://greengrass-v2-iot-policy.json
```
如果請求成功，回應看起來與下列範例類似。
```
{
"policyName": "GreengrassV2IoTThingPolicy",
"policyArn": "arn:aws:iot:us-west-2:123456789012:policy/GreengrassV2IoTThingPolicy",
"policyDocument": "{
\\"Version\\": \\"2012-10-17 \\",
\\"Statement\\": [
{
\\"Effect\\": \\"Allow\\",
\\"Action\\": [
\\"iot:Publish\\",
\\"iot:Subscribe\\",
\\"iot:Receive\\",
\\"iot:Connect\\",
\\"greengrass:*\\"
],
\\"Resource\\": [
\\"*\\"
]
}
]
}",
"policyVersionId": "1"
}
```
1. 將 AWS IoT 政策連接至 AWS IoT 物件的憑證。
+ 將 *GreengrassV2IoTThingPolicy* 取代為要連接的政策名稱。
+ 將目標 ARN 取代為您 AWS IoT 物件的憑證 ARN。
```
aws iot attach-policy --policy-name GreengrassV2IoTThingPolicy --target arn:aws:iot:us-west-2:123456789012:cert/aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4
```
如果請求成功，命令不會有任何輸出。
## 建立權杖交換角色
Greengrass 核心裝置使用稱為*字符交換角色的 IAM 服務角色*來授權呼叫 AWS 服務。裝置使用 AWS IoT 登入資料提供者取得此角色的臨時 AWS 登入資料，允許裝置與 互動 AWS IoT、將日誌傳送至 Amazon CloudWatch Logs，以及從 Amazon S3 下載自訂元件成品。如需詳細資訊，請參閱[授權核心裝置與 AWS 服務互動](device-service-role.md)。
您可以使用 AWS IoT *角色別名*來設定 Greengrass 核心裝置的字符交換角色。角色別名可讓您變更裝置的字符交換角色，但保持裝置的組態相同。如需詳細資訊，請參閱《 *AWS IoT Core 開發人員指南*》中的[授權對 AWS 服務的直接呼叫](https://docs.aws.amazon.com/iot/latest/developerguide/authorizing-direct-aws.html)。
在本節中，您會建立權杖交換 IAM 角色和指向角色 AWS IoT 的角色別名。如果您已經設定 Greengrass 核心裝置，您可以使用其權杖交換角色和角色別名，而不是建立新的權杖交換角色和角色別名。然後，您將裝置的 AWS IoT 物件設定為使用該角色和別名。
**建立權杖交換 IAM 角色**
1. 建立您的裝置可用作字符交換角色的 IAM 角色。請執行下列操作：
1. 建立檔案，其中包含權杖交換角色所需的信任政策文件。
例如，在以 Linux 為基礎的系統上，您可以執行下列命令來使用 GNU nano 來建立 檔案。
```
nano device-role-trust-policy.json
```
將下列 JSON 複製到 檔案。
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "credentials.iot.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
1. 使用信任政策文件建立權杖交換角色。
+ 將 *GreengrassV2TokenExchangeRole* 取代為要建立的 IAM 角色名稱。
```
aws iam create-role --role-name GreengrassV2TokenExchangeRole --assume-role-policy-document file://device-role-trust-policy.json
```
如果請求成功，回應看起來與下列範例類似。
```
{
"Role": {
"Path": "/",
"RoleName": "GreengrassV2TokenExchangeRole",
"RoleId": "AROAZ2YMUHYHK5OKM77FB",
"Arn": "arn:aws:iam::123456789012:role/GreengrassV2TokenExchangeRole",
"CreateDate": "2021-02-06T00:13:29+00:00",
"AssumeRolePolicyDocument": {
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "credentials.iot.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
}
```
1. 建立檔案，其中包含權杖交換角色所需的存取政策文件。
例如，在以 Linux 為基礎的系統上，您可以執行下列命令來使用 GNU nano 來建立 檔案。
```
nano device-role-access-policy.json
```
將下列 JSON 複製到 檔案。
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents",
"logs:DescribeLogStreams",
"s3:GetBucketLocation"
],
"Resource": "*"
}
]
}
```
**注意**
此存取政策不允許存取 S3 儲存貯體中的元件成品。若要部署在 Amazon S3 中定義成品的自訂元件，您必須將許可新增至角色，以允許核心裝置擷取元件成品。如需詳細資訊，請參閱[允許存取元件成品的 S3 儲存貯體](device-service-role.md#device-service-role-access-s3-bucket)。
如果您還沒有元件成品的 S3 儲存貯體，您可以在建立儲存貯體之後新增這些許可。
1. 從政策文件中建立 IAM 政策。
+ 以要建立的 IAM 政策名稱取代 *GreengrassV2TokenExchangeRoleAccess*。
```
aws iam create-policy --policy-name GreengrassV2TokenExchangeRoleAccess --policy-document file://device-role-access-policy.json
```
如果請求成功，回應看起來與下列範例類似。
```
{
"Policy": {
"PolicyName": "GreengrassV2TokenExchangeRoleAccess",
"PolicyId": "ANPAZ2YMUHYHACI7C5Z66",
"Arn": "arn:aws:iam::123456789012:policy/GreengrassV2TokenExchangeRoleAccess",
"Path": "/",
"DefaultVersionId": "v1",
"AttachmentCount": 0,
"PermissionsBoundaryUsageCount": 0,
"IsAttachable": true,
"CreateDate": "2021-02-06T00:37:17+00:00",
"UpdateDate": "2021-02-06T00:37:17+00:00"
}
}
```
1. 將 IAM 政策連接至字符交換角色。
+ 將 *GreengrassV2TokenExchangeRole* 取代為 IAM 角色的名稱。
+ 將政策 ARN 取代為您在上一個步驟中建立的 IAM 政策 ARN。
```
aws iam attach-role-policy --role-name GreengrassV2TokenExchangeRole --policy-arn arn:aws:iam::123456789012:policy/GreengrassV2TokenExchangeRoleAccess
```
如果請求成功，命令不會有任何輸出。
1. 建立指向字符交換 AWS IoT 角色的角色別名。
+ 以要建立的角色別名名稱取代 *GreengrassCoreTokenExchangeRoleAlias*。
+ 將角色 ARN 取代為您在上一個步驟中建立之 IAM 角色的 ARN。
```
aws iot create-role-alias --role-alias GreengrassCoreTokenExchangeRoleAlias --role-arn arn:aws:iam::123456789012:role/GreengrassV2TokenExchangeRole
```
如果請求成功，回應看起來與下列範例類似。
```
{
"roleAlias": "GreengrassCoreTokenExchangeRoleAlias",
"roleAliasArn": "arn:aws:iot:us-west-2:123456789012:rolealias/GreengrassCoreTokenExchangeRoleAlias"
}
```
**注意**
若要建立角色別名，您必須具有傳遞字符交換 IAM 角色的許可 AWS IoT。如果您在嘗試建立角色別名時收到錯誤訊息，請檢查您的 AWS 使用者是否具有此許可。如需詳細資訊，請參閱*AWS Identity and Access Management 《 使用者指南*》中的[授予使用者將角色傳遞至 AWS 服務的許可](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_passrole.html)。
1. 建立並連接允許 Greengrass 核心裝置使用角色別名來擔任字符交換角色 AWS IoT 的政策。如果您之前已設定 Greengrass 核心裝置，您可以連接其角色別名 AWS IoT 政策，而不是建立新的。請執行下列操作：
1. （選用） 建立檔案，其中包含角色別名所需的 AWS IoT 政策文件。
例如，在以 Linux 為基礎的系統上，您可以執行下列命令來使用 GNU nano 來建立 檔案。
```
nano greengrass-v2-iot-role-alias-policy.json
```
將下列 JSON 複製到 檔案。
+ 使用角色別名的 ARN 取代資源 ARN。
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "iot:AssumeRoleWithCertificate",
"Resource": "arn:aws:iot:us-west-2:123456789012:rolealias/GreengrassCoreTokenExchangeRoleAlias"
}
]
}
```
1. 從 AWS IoT 政策文件建立政策。
+ 將 *GreengrassCoreTokenExchangeRoleAliasPolicy* 取代為要建立 AWS IoT 的政策名稱。
```
aws iot create-policy --policy-name GreengrassCoreTokenExchangeRoleAliasPolicy --policy-document file://greengrass-v2-iot-role-alias-policy.json
```
如果請求成功，回應看起來與下列範例類似。
```
{
"policyName": "GreengrassCoreTokenExchangeRoleAliasPolicy",
"policyArn": "arn:aws:iot:us-west-2:123456789012:policy/GreengrassCoreTokenExchangeRoleAliasPolicy",
"policyDocument": "{
\\"Version\\":\\"2012-10-17 \\",
\\"Statement\\": [
{
\\"Effect\\": \\"Allow\\",
\\"Action\\": \\"iot:AssumeRoleWithCertificate\\",
\\"Resource\\": \\"arn:aws:iot:us-west-2:123456789012:rolealias/GreengrassCoreTokenExchangeRoleAlias\\"
}
]
}",
"policyVersionId": "1"
}
```
1. 將 AWS IoT 政策連接至 AWS IoT 物件的憑證。
+ 以角色別名 AWS IoT 政策的名稱取代 *GreengrassCoreTokenExchangeRoleAliasPolicy*。
+ 將目標 ARN 取代為您 AWS IoT 物件的憑證 ARN。
```
aws iot attach-policy --policy-name GreengrassCoreTokenExchangeRoleAliasPolicy --target arn:aws:iot:us-west-2:123456789012:cert/aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4
```
如果請求成功，命令不會有任何輸出。
## 下載憑證至裝置
先前，您已將裝置的憑證下載到開發電腦。在本節中，您將憑證複製到核心裝置，以使用裝置用來連線的憑證來設定裝置 AWS IoT。您也可以下載 Amazon 根憑證授權機構 (CA) 憑證。如果您使用 HSM，您也可以將憑證檔案匯入本節的 HSM。
+ 如果您先前已在 AWS IoT 服務中建立物件憑證和私有金鑰，請依照步驟下載具有私有金鑰和憑證檔案的憑證。
+ 如果您先前從硬體安全模組 (HSM) 中的私有金鑰建立物件憑證，請依照步驟下載 HSM 中具有私有金鑰和憑證的憑證。
### 下載具有私有金鑰和憑證檔案的憑證
**將憑證下載至裝置**
1. 將 AWS IoT 物件憑證從開發電腦複製到裝置。如果在開發電腦和裝置上啟用 SSH 和 SCP，您可以使用開發電腦上的 `scp`命令來傳輸憑證。將 *device-ip-address* 取代為您裝置的 IP 地址。
```
scp -r greengrass-v2-certs/ device-ip-address:~
```
1. 在裝置上建立 Greengrass 根資料夾。您稍後會將 AWS IoT Greengrass 核心軟體安裝到此資料夾。
**注意**
Windows 的路徑長度限制為 260 個字元。如果您使用的是 Windows，請使用根資料夾，例如 `C:\greengrass\v2`或 `D:\greengrass\v2` ，將 Greengrass 元件路徑保持在 260 個字元限制以下。
------
#### [ Linux or Unix ]
+ `/greengrass/v2` 將 取代為要使用的資料夾。
```
sudo mkdir -p /greengrass/v2
```
------
#### [ Windows Command Prompt ]
+ 將 *C：\$1greengrass\$1v2* 取代為要使用的資料夾。
```
mkdir C:\greengrass\v2
```
------
#### [ PowerShell ]
+ 將 *C：\$1greengrass\$1v2* 取代為要使用的資料夾。
```
mkdir C:\greengrass\v2
```
------
1. （僅限 Linux) 設定 Greengrass 根資料夾父項的許可。
+ 將 */greengrass* 取代為根資料夾的父系。
```
sudo chmod 755 /greengrass
```
1. 將 AWS IoT 物件憑證複製到 Greengrass 根資料夾。
------
#### [ Linux or Unix ]
+ `/greengrass/v2` 將 取代為 Greengrass 根資料夾。
```
sudo cp -R ~/greengrass-v2-certs/* /greengrass/v2
```
------
#### [ Windows Command Prompt ]
+ 將 *C：\$1greengrass\$1v2* 取代為要使用的資料夾。
```
robocopy %USERPROFILE%\greengrass-v2-certs C:\greengrass\v2 /E
```
------
#### [ PowerShell ]
+ 將 *C：\$1greengrass\$1v2* 取代為要使用的資料夾。
```
cp -Path ~\greengrass-v2-certs\* -Destination C:\greengrass\v2
```
------
1. 根據預設，下載 Amazon 根憑證授權機構 (CA) certificate. AWS IoT certificates 會與 Amazon 根憑證授權機構憑證相關聯。
------
#### [ Linux or Unix ]
```
sudo curl -o /greengrass/v2/AmazonRootCA1.pem https://www.amazontrust.com/repository/AmazonRootCA1.pem
```
------
#### [ Windows Command Prompt (CMD) ]
```
curl -o C:\greengrass\v2\\AmazonRootCA1.pem https://www.amazontrust.com/repository/AmazonRootCA1.pem
```
------
#### [ PowerShell ]
```
iwr -Uri https://www.amazontrust.com/repository/AmazonRootCA1.pem -OutFile C:\greengrass\v2\\AmazonRootCA1.pem
```
------
### 在 HSM 中使用私有金鑰和憑證下載憑證
**注意**
此功能適用於 [Greengrass 核元件](greengrass-nucleus-component.md)的 v2.5.3 和更新版本。目前 AWS IoT Greengrass 不支援 Windows 核心裝置上的此功能。
**將憑證下載至裝置**
1. 將 AWS IoT 物件憑證從開發電腦複製到裝置。如果在開發電腦和裝置上啟用 SSH 和 SCP，您可以使用開發電腦上的 `scp`命令來傳輸憑證。將 *device-ip-address* 取代為您裝置的 IP 地址。
```
scp -r greengrass-v2-certs/ device-ip-address:~
```
1. 在裝置上建立 Greengrass 根資料夾。您稍後會將 AWS IoT Greengrass 核心軟體安裝到此資料夾。
**注意**
Windows 的路徑長度限制為 260 個字元。如果您使用的是 Windows，請使用根資料夾，例如 `C:\greengrass\v2`或 `D:\greengrass\v2` ，將 Greengrass 元件路徑保持在 260 個字元限制以下。
------
#### [ Linux or Unix ]
+ `/greengrass/v2` 將 取代為要使用的資料夾。
```
sudo mkdir -p /greengrass/v2
```
------
#### [ Windows Command Prompt ]
+ 將 *C：\$1greengrass\$1v2* 取代為要使用的資料夾。
```
mkdir C:\greengrass\v2
```
------
#### [ PowerShell ]
+ 將 *C：\$1greengrass\$1v2* 取代為要使用的資料夾。
```
mkdir C:\greengrass\v2
```
------
1. （僅限 Linux) 設定 Greengrass 根資料夾父項的許可。
+ 將 */greengrass* 取代為根資料夾的父系。
```
sudo chmod 755 /greengrass
```
1. 將物件憑證檔案 匯入 `~/greengrass-v2-certs/device.pem.crt`HSM。檢查 HSM 的文件，了解如何將憑證匯入其中。使用您先前在 HSM 中產生私有金鑰的相同字符、槽 ID、使用者 PIN、物件標籤和物件 ID （如果您的 HSM 使用） 匯入憑證。
**注意**
如果您先前在沒有物件 ID 的情況下產生私有金鑰，且憑證具有物件 ID，請將私有金鑰的物件 ID 設定為與憑證相同的值。檢查您的 HSM 文件，了解如何設定私有金鑰物件的物件 ID。
1. （選用） 刪除物件憑證檔案，使其僅存在於 HSM 中。
```
rm ~/greengrass-v2-certs/device.pem.crt
```
1. 根據預設，下載 Amazon 根憑證授權機構 (CA) certificate. AWS IoT certificates 會與 Amazon 根憑證授權機構憑證相關聯。
------
#### [ Linux or Unix ]
```
sudo curl -o /greengrass/v2/AmazonRootCA1.pem https://www.amazontrust.com/repository/AmazonRootCA1.pem
```
------
#### [ Windows Command Prompt (CMD) ]
```
curl -o C:\greengrass\v2\\AmazonRootCA1.pem https://www.amazontrust.com/repository/AmazonRootCA1.pem
```
------
#### [ PowerShell ]
```
iwr -Uri https://www.amazontrust.com/repository/AmazonRootCA1.pem -OutFile C:\greengrass\v2\\AmazonRootCA1.pem
```
------
## 設定裝置環境
請依照本節中的步驟設定 Linux 或 Windows 裝置，以用作您的 AWS IoT Greengrass 核心裝置。
### 設定 Linux 裝置
**設定 的 Linux 裝置 AWS IoT Greengrass V2**
1. 安裝執行 AWS IoT Greengrass 核心軟體所需的 Java 執行時間。我們建議您使用 [Amazon Corretto](https://aws.amazon.com/corretto/) 或 [OpenJDK](https://openjdk.java.net/) 長期支援版本。第 8 版或更新版本為必要項目。下列命令說明如何在裝置上安裝 OpenJDK。
+ 針對 Debian 為基礎或 Ubuntu 為基礎的發行版本：
```
sudo apt install default-jdk
```
+ 針對 Red Hat 為基礎的發行版本：
```
sudo yum install java-11-openjdk-devel
```
+ 針對 Amazon Linux 2：
```
sudo amazon-linux-extras install java-openjdk11
```
+ 針對 Amazon Linux 2023：
```
sudo dnf install java-11-amazon-corretto -y
```
安裝完成後，請執行下列命令來驗證 Java 是否在您的 Linux 裝置上執行。
```
java -version
```
命令會列印在裝置上執行的 Java 版本。例如，在 Debian 型分佈上，輸出看起來可能會類似下列範例。
```
openjdk version "11.0.9.1" 2020-11-04
OpenJDK Runtime Environment (build 11.0.9.1+1-post-Debian-1deb10u2)
OpenJDK 64-Bit Server VM (build 11.0.9.1+1-post-Debian-1deb10u2, mixed mode)
```
1. （選用） 建立在裝置上執行元件的預設系統使用者和群組。您也可以選擇讓 AWS IoT Greengrass Core 軟體安裝程式在安裝期間使用`--component-default-user`安裝程式引數建立此使用者和群組。如需詳細資訊，請參閱[安裝程式引數](configure-installer.md)。
```
sudo useradd --system --create-home ggc_user
sudo groupadd --system ggc_group
```
1. 確認執行 AWS IoT Greengrass 核心軟體的使用者 （通常為 `root`) 具有使用任何使用者和任何群組執行 `sudo` 的許可。
1. 執行下列命令以開啟 `/etc/sudoers` 檔案。
```
sudo visudo
```
1. 確認使用者的許可如下範例所示。
```
root ALL=(ALL:ALL) ALL
```
1. （選用） 若要[執行容器化 Lambda 函數](run-lambda-functions.md)，您必須啟用 [cgroups](https://en.wikipedia.org/wiki/Cgroups) v1，而且必須啟用和掛載*記憶體*和*裝置* cgroups。如果您不打算執行容器化 Lambda 函數，您可以略過此步驟。
若要啟用這些 cgroups 選項，請使用下列 Linux 核心參數啟動裝置。
```
cgroup_enable=memory cgroup_memory=1 systemd.unified_cgroup_hierarchy=0
```
如需有關檢視和設定裝置核心參數的資訊，請參閱您作業系統和開機載入器的文件。依照指示永久設定核心參數。
1. 在裝置上安裝所有其他必要的相依性，如 中的需求清單所示[裝置要求](greengrass-nucleus-component.md#greengrass-v2-requirements)。
### 設定 Windows 裝置
**注意**
此功能適用於 [Greengrass 核元件](greengrass-nucleus-component.md)的 v2.5.0 和更新版本。
**為 設定 Windows 裝置 AWS IoT Greengrass V2**
1. 安裝執行 AWS IoT Greengrass 核心軟體所需的 Java 執行時間。我們建議您使用 [Amazon Corretto](https://aws.amazon.com/corretto/) 或 [OpenJDK](https://openjdk.java.net/) 長期支援版本。第 8 版或更新版本為必要項目。
1. 檢查 [PATH](https://en.wikipedia.org/wiki/PATH_(variable)) 系統變數上是否提供 Java，如果沒有，請新增它。LocalSystem 帳戶會執行 AWS IoT Greengrass Core 軟體，因此您必須將 Java 新增至 PATH 系統變數，而不是使用者的 PATH 使用者變數。請執行下列操作：
1. 按 Windows 鍵開啟開始選單。
1. 輸入 **environment variables** 以從開始功能表搜尋系統選項。
1. 在開始功能表搜尋結果中，選擇**編輯系統環境變數**以開啟**系統屬性**視窗。
1. 選擇**環境變數...**以開啟**環境變數**視窗。
1. 在**系統變數**下，選取**路徑**，然後選擇**編輯**。在**編輯環境變數**視窗中，您可以檢視個別行上的每個路徑。
1. 檢查 Java 安裝`bin`資料夾的路徑是否存在。路徑看起來可能會類似下列範例。
```
C:\\Program Files\\Amazon Corretto\\jdk11.0.13_8\\bin
```
1. 如果**路徑**中缺少 Java 安裝的`bin`資料夾，請選擇**新增**以新增，然後選擇**確定**。
1. 以管理員身分開啟 Windows 命令提示字元 (`cmd.exe`)。
1. 在 Windows 裝置的 LocalSystem 帳戶中建立預設使用者。將*密碼*取代為安全密碼。
```
net user /add ggc_user password
```
**提示**
根據您的 Windows 組態，使用者的密碼可能會設定為在未來的日期過期。為了確保您的 Greengrass 應用程式持續運作，請追蹤密碼過期的時間，並在過期之前更新它。您也可以將使用者的密碼設定為永不過期。
若要檢查使用者及其密碼何時過期，請執行下列命令。
```
net user ggc_user | findstr /C:expires
```
若要將使用者的密碼設定為永不過期，請執行下列命令。
```
wmic UserAccount where "Name='ggc_user'" set PasswordExpires=False
```
如果您使用的是[`wmic`已棄用命令](https://learn.microsoft.com/en-us/windows/win32/wmisdk/wmic)的 Windows 10 或更新版本，請執行下列 PowerShell 命令。
```
Get-CimInstance -Query "SELECT * from Win32_UserAccount WHERE name = 'ggc_user'" | Set-CimInstance -Property @{PasswordExpires="False"}
```
1. 從 Microsoft 在裝置上下載並安裝 [PsExec 公用程式](https://docs.microsoft.com/en-us/sysinternals/downloads/psexec)。
1. 使用 PsExec 公用程式，將預設使用者的使用者名稱和密碼存放在 LocalSystem 帳戶的 Credential Manager 執行個體中。將*密碼*取代為您先前設定的使用者密碼。
```
psexec -s cmd /c cmdkey /generic:ggc_user /user:ggc_user /pass:password
```
如果 **PsExec License Agreement** 開啟，請選擇 以**Accept**同意授權並執行 命令。
**注意**
在 Windows 裝置上，LocalSystem 帳戶會執行 Greengrass 核，而且您必須使用 PsExec 公用程式將預設使用者資訊存放在 LocalSystem 帳戶中。使用 Credential Manager 應用程式會將此資訊存放在目前登入使用者的 Windows 帳戶中，而不是 LocalSystem 帳戶。
## 下載 AWS IoT Greengrass 核心軟體
您可以從下列位置下載最新版本的 AWS IoT Greengrass Core 軟體：
+ [https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip](https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip)
**注意**
您可以從下列位置下載特定版本的 AWS IoT Greengrass Core 軟體。將*版本*取代為要下載的版本。
```
https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-version.zip
```
**下載 AWS IoT Greengrass 核心軟體**
1. 在您的核心裝置上，將 AWS IoT Greengrass Core 軟體下載至名為 的檔案`greengrass-nucleus-latest.zip`。
------
#### [ Linux or Unix ]
```
curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip > greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
```
curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip > greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
```
iwr -Uri https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip -OutFile greengrass-nucleus-latest.zip
```
------
下載此軟體，即表示您同意 [Greengrass 核心軟體授權合約](https://greengrass-release-license.s3.us-west-2.amazonaws.com/greengrass-license-v1.pdf)之規定。
1. （選用） 驗證 Greengrass 核軟體簽章
**注意**
此功能適用於 Greengrass 核版本 2.9.5 及更新版本。
1. 使用下列命令來驗證 Greengrass 核子成品的簽章：
------
#### [ Linux or Unix ]
```
jarsigner -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
檔案名稱看起來可能會有所不同，視您安裝的 JDK 版本而定。*`jdk17.0.6_10`* 將 取代為您安裝的 JDK 版本。
```
"C:\\Program Files\\Amazon Corretto\\jdk17.0.6_10\\bin\\jarsigner.exe" -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
檔案名稱看起來可能會有所不同，視您安裝的 JDK 版本而定。*`jdk17.0.6_10`* 將 取代為您安裝的 JDK 版本。
```
'C:\\Program Files\\Amazon Corretto\\jdk17.0.6_10\\bin\\jarsigner.exe' -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
1. `jarsigner` 調用會產生輸出，指出驗證的結果。
1. 如果已簽署 Greengrass 核 zip 檔案，輸出會包含下列陳述式：
```
jar verified.
```
1. 如果 Greengrass 核 zip 檔案未簽署，輸出會包含下列陳述式：
```
jar is unsigned.
```
1. 如果您提供 Jarsigner `-certs`選項以及 `-verify`和 `-verbose`選項，輸出也會包含詳細的簽署者憑證資訊。
1. 將 AWS IoT Greengrass Core 軟體解壓縮至裝置上的資料夾。將 *GreengrassInstaller* 取代為您要使用的資料夾。
------
#### [ Linux or Unix ]
```
unzip greengrass-nucleus-latest.zip -d GreengrassInstaller && rm greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
```
mkdir GreengrassInstaller && tar -xf greengrass-nucleus-latest.zip -C GreengrassInstaller && del greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
```
Expand-Archive -Path greengrass-nucleus-latest.zip -DestinationPath .\\GreengrassInstaller
rm greengrass-nucleus-latest.zip
```
------
1. （選用） 執行下列命令以查看 AWS IoT Greengrass 核心軟體版本。
```
java -jar ./GreengrassInstaller/lib/Greengrass.jar --version
```
**重要**
如果您安裝的 Greengrass 核版本早於 2.4.0 版，安裝 AWS IoT Greengrass 核心軟體後請勿移除此資料夾。Core AWS IoT Greengrass 軟體會使用此資料夾中的檔案來執行。
如果您下載最新版本的軟體，請安裝 v2.4.0 或更新版本，並在安裝 AWS IoT Greengrass Core 軟體後移除此資料夾。
## 安裝 AWS IoT Greengrass 核心軟體
使用指定下列動作的引數執行安裝程式：
+ 從部分組態檔案安裝 ，指定 使用您先前建立 AWS 的資源和憑證。Core AWS IoT Greengrass 軟體使用組態檔案，指定裝置上每個 Greengrass 元件的組態。安裝程式會從您提供的部分組態檔案建立完整的組態檔案。
+ 指定 以使用`ggc_user`系統使用者在核心裝置上執行軟體元件。在 Linux 裝置上，此命令也會指定 使用`ggc_group`系統群組，安裝程式會為您建立系統使用者和群組。
+ 將 AWS IoT Greengrass Core 軟體設定為開機時執行的系統服務。在 Linux 裝置上，這需要 [Systemd](https://en.wikipedia.org/wiki/Systemd) init 系統。
**重要**
在 Windows 核心裝置上，您必須將 AWS IoT Greengrass Core 軟體設定為系統服務。
如需可指定引數的詳細資訊，請參閱 [安裝程式引數](configure-installer.md)。
**注意**
如果您在記憶體有限的 AWS IoT Greengrass 裝置上執行 ，您可以控制 AWS IoT Greengrass Core 軟體使用的記憶體數量。若要控制記憶體配置，您可以在核心元件的`jvmOptions`組態參數中設定 JVM 堆積大小選項。如需詳細資訊，請參閱[使用 JVM 選項控制記憶體配置](configure-greengrass-core-v2.md#jvm-tuning)。
+ 如果您先前已在 AWS IoT 服務中建立物件憑證和私有金鑰，請依照步驟安裝具有私有金鑰和憑證檔案的 AWS IoT Greengrass 核心軟體。
+ 如果您先前從硬體安全模組 (HSM) 中的私有金鑰建立物件憑證，請依照步驟在 HSM 中安裝具有私有金鑰和憑證 AWS IoT Greengrass 的 Core 軟體。
### 使用私有金鑰和憑證檔案安裝 AWS IoT Greengrass 核心軟體
**安裝 AWS IoT Greengrass 核心軟體**
1. 檢查 AWS IoT Greengrass Core 軟體的版本。
+ 將 *GreengrassInstaller* 取代為包含軟體之資料夾的路徑。
```
java -jar ./GreengrassInstaller/lib/Greengrass.jar --version
```
1. 使用文字編輯器來建立名為 的組態檔案`config.yaml`，以提供給安裝程式。
例如，在以 Linux 為基礎的系統上，您可以執行下列命令來使用 GNU nano 來建立 檔案。
```
nano GreengrassInstaller/config.yaml
```
將下列 YAML 內容複製到 檔案。此部分組態檔案會指定系統參數和 Greengrass 核參數。
```
---
system:
certificateFilePath: "/greengrass/v2/device.pem.crt"
privateKeyPath: "/greengrass/v2/private.pem.key"
rootCaPath: "/greengrass/v2/AmazonRootCA1.pem"
rootpath: "/greengrass/v2"
thingName: "MyGreengrassCore"
services:
aws.greengrass.Nucleus:
componentType: "NUCLEUS"
version: "2.16.1"
configuration:
awsRegion: "us-west-2"
iotRoleAlias: "GreengrassCoreTokenExchangeRoleAlias"
iotDataEndpoint: "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
iotCredEndpoint: "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
```
然後，執行下列動作：
+ 將 的每個執行個體取代`/greengrass/v2`為 Greengrass 根資料夾。
+ 將 *MyGreengrassCore* 取代為物件的名稱 AWS IoT 。
+ 將 *2.16.1* 取代為 AWS IoT Greengrass 核心軟體版本。
+ 將 *us-west-2* 取代 AWS 區域 為您建立資源的 。
+ 以字符交換角色別名的名稱取代 *GreengrassCoreTokenExchangeRoleAlias*。
+ 將 取代`iotDataEndpoint`為 AWS IoT 您的資料端點。
+ 將 取代`iotCredEndpoint`為您的 AWS IoT 登入資料端點。
**注意**
在此組態檔案中，您可以自訂其他核組態選項，例如要使用的連接埠和網路代理，如下列範例所示。如需詳細資訊，請參閱 [Greengrass 核組態](greengrass-nucleus-component.md#greengrass-nucleus-component-configuration)。
```
---
system:
certificateFilePath: "/greengrass/v2/device.pem.crt"
privateKeyPath: "/greengrass/v2/private.pem.key"
rootCaPath: "/greengrass/v2/AmazonRootCA1.pem"
rootpath: "/greengrass/v2"
thingName: "MyGreengrassCore"
services:
aws.greengrass.Nucleus:
componentType: "NUCLEUS"
version: "2.16.1"
configuration:
awsRegion: "us-west-2"
iotRoleAlias: "GreengrassCoreTokenExchangeRoleAlias"
iotCredEndpoint: "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
iotDataEndpoint: "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
mqtt:
port: 443
greengrassDataPlanePort: 443
networkProxy:
noProxyAddresses: "http://192.168.0.1,www.example.com"
proxy:
url: "https://my-proxy-server:1100"
username: "Mary_Major"
password: "pass@word1357"
```
1. 執行安裝程式，並指定 `--init-config`以提供組態檔案。
+ 將 `/greengrass/v2`或 *C：\$1greengrass\$1v2* 取代為 Greengrass 根資料夾。
+ 將 *GreengrassInstaller* 的每個執行個體取代為您解壓縮安裝程式的資料夾。
------
#### [ Linux or Unix ]
```
sudo -E java -Droot="/greengrass/v2" -Dlog.store=FILE \
-jar ./GreengrassInstaller/lib/Greengrass.jar \
--init-config ./GreengrassInstaller/config.yaml \
--component-default-user ggc_user:ggc_group \
--setup-system-service true
```
------
#### [ Windows Command Prompt (CMD) ]
```
java -Droot="C:\greengrass\v2" "-Dlog.store=FILE" ^
-jar ./GreengrassInstaller/lib/Greengrass.jar ^
--init-config ./GreengrassInstaller/config.yaml ^
--component-default-user ggc_user ^
--setup-system-service true
```
------
#### [ PowerShell ]
```
java -Droot="C:\greengrass\v2" "-Dlog.store=FILE" `
-jar ./GreengrassInstaller/lib/Greengrass.jar `
--init-config ./GreengrassInstaller/config.yaml `
--component-default-user ggc_user `
--setup-system-service true
```
------
**重要**
在 Windows 核心裝置上，您必須指定 `--setup-system-service true`將 AWS IoT Greengrass Core 軟體設定為系統服務。
如果您指定 `--setup-system-service true`，安裝程式會在設定並執行軟體做為系統服務`Successfully set up Nucleus as a system service`時列印。否則，如果安裝程式成功安裝軟體，就不會輸出任何訊息。
**注意**
當您在沒有 `deploy-dev-tools`引數的情況下執行安裝程式時，無法使用 `--provision true`引數來部署本機開發工具。如需有關直接在您的裝置上部署 Greengrass CLI 的資訊，請參閱 [Greengrass 命令列界面](gg-cli.md)。
1. 透過檢視根資料夾中的檔案來驗證安裝。
------
#### [ Linux or Unix ]
```
ls /greengrass/v2
```
------
#### [ Windows Command Prompt (CMD) ]
```
dir C:\greengrass\v2
```
------
#### [ PowerShell ]
```
ls C:\greengrass\v2
```
------
如果安裝成功，根資料夾會包含數個資料夾，例如 `config`、 `packages`和 `logs`。
### 在 HSM 中使用私有金鑰和憑證安裝 AWS IoT Greengrass 核心軟體
**注意**
此功能適用於 [Greengrass 核元件](greengrass-nucleus-component.md)的 v2.5.3 和更新版本。目前 AWS IoT Greengrass 不支援 Windows 核心裝置上的此功能。
**安裝 AWS IoT Greengrass 核心軟體**
1. 檢查 AWS IoT Greengrass Core 軟體的版本。
+ 將 *GreengrassInstaller* 取代為包含軟體之資料夾的路徑。
```
java -jar ./GreengrassInstaller/lib/Greengrass.jar --version
```
1. 若要讓 AWS IoT Greengrass Core 軟體使用 HSM 中的私有金鑰和憑證，請在安裝 AWS IoT Greengrass Core 軟體時安裝 [PKCS\$111 提供者元件](pkcs11-provider-component.md)。PKCS\$111 供應商元件是您可以在安裝期間設定的外掛程式。您可以從下列位置下載最新版本的 PKCS\$111 提供者元件：
+ [https://d2s8p88vqu9w66.cloudfront.net/releases/Pkcs11Provider/aws.greengrass.crypto.Pkcs11Provider-latest.jar](https://d2s8p88vqu9w66.cloudfront.net/releases/Pkcs11Provider/aws.greengrass.crypto.Pkcs11Provider-latest.jar)
將 PKCS\$111 供應商外掛程式下載至名為 的檔案`aws.greengrass.crypto.Pkcs11Provider.jar`。將 *GreengrassInstaller* 取代為您要使用的資料夾。
```
curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/Pkcs11Provider/aws.greengrass.crypto.Pkcs11Provider-latest.jar > GreengrassInstaller/aws.greengrass.crypto.Pkcs11Provider.jar
```
下載此軟體，即表示您同意 [Greengrass 核心軟體授權合約](https://greengrass-release-license.s3.us-west-2.amazonaws.com/greengrass-license-v1.pdf)之規定。
1. 使用文字編輯器來建立名為 的組態檔案`config.yaml`，以提供給安裝程式。
例如，在以 Linux 為基礎的系統上，您可以執行下列命令來使用 GNU nano 來建立 檔案。
```
nano GreengrassInstaller/config.yaml
```
將下列 YAML 內容複製到 檔案。此部分組態檔案會指定系統參數、Greengrass 核參數和 PKCS\$111 提供者參數。
```
---
system:
certificateFilePath: "pkcs11:object=iotdevicekey;type=cert"
privateKeyPath: "pkcs11:object=iotdevicekey;type=private"
rootCaPath: "/greengrass/v2/AmazonRootCA1.pem"
rootpath: "/greengrass/v2"
thingName: "MyGreengrassCore"
services:
aws.greengrass.Nucleus:
componentType: "NUCLEUS"
version: "2.16.1"
configuration:
awsRegion: "us-west-2"
iotRoleAlias: "GreengrassCoreTokenExchangeRoleAlias"
iotDataEndpoint: "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
iotCredEndpoint: "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
aws.greengrass.crypto.Pkcs11Provider:
configuration:
name: "softhsm_pkcs11"
library: "/usr/local/Cellar/softhsm/2.6.1/lib/softhsm/libsofthsm2.so"
slot: 1
userPin: "1234"
```
然後，執行下列動作：
+ 將 PKCS\$111 URIs 中的每個 *iotdevicekey* 執行個體取代為您建立私有金鑰並匯入憑證的物件標籤。
+ 將 的每個執行個體取代`/greengrass/v2`為 Greengrass 根資料夾。
+ 將 *MyGreengrassCore* 取代為物件的名稱 AWS IoT 。
+ 將 *2.16.1* 取代為 AWS IoT Greengrass 核心軟體版本。
+ 將 *us-west-2* 取代 AWS 區域 為您建立資源的 。
+ 以字符交換角色別名的名稱取代 *GreengrassCoreTokenExchangeRoleAlias*。
+ 將 取代`iotDataEndpoint`為 AWS IoT 您的資料端點。
+ 將 取代`iotCredEndpoint`為您的 AWS IoT 登入資料端點。
+ 將`aws.greengrass.crypto.Pkcs11Provider`元件的組態參數取代為核心裝置上的 HSM 組態值。
**注意**
在此組態檔案中，您可以自訂其他核組態選項，例如要使用的連接埠和網路代理，如下列範例所示。如需詳細資訊，請參閱 [Greengrass 核組態](greengrass-nucleus-component.md#greengrass-nucleus-component-configuration)。
```
---
system:
certificateFilePath: "pkcs11:object=iotdevicekey;type=cert"
privateKeyPath: "pkcs11:object=iotdevicekey;type=private"
rootCaPath: "/greengrass/v2/AmazonRootCA1.pem"
rootpath: "/greengrass/v2"
thingName: "MyGreengrassCore"
services:
aws.greengrass.Nucleus:
componentType: "NUCLEUS"
version: "2.16.1"
configuration:
awsRegion: "us-west-2"
iotRoleAlias: "GreengrassCoreTokenExchangeRoleAlias"
iotDataEndpoint: "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
iotCredEndpoint: "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
mqtt:
port: 443
greengrassDataPlanePort: 443
networkProxy:
noProxyAddresses: "http://192.168.0.1,www.example.com"
proxy:
url: "https://my-proxy-server:1100"
username: "Mary_Major"
password: "pass@word1357"
aws.greengrass.crypto.Pkcs11Provider:
configuration:
name: "softhsm_pkcs11"
library: "/usr/local/Cellar/softhsm/2.6.1/lib/softhsm/libsofthsm2.so"
slot: 1
userPin: "1234"
```
1. 執行安裝程式，並指定 `--init-config`以提供組態檔案。
+ `/greengrass/v2` 將 取代為 Greengrass 根資料夾。
+ 將 *GreengrassInstaller* 的每個執行個體取代為您解壓縮安裝程式的資料夾。
```
sudo -E java -Droot="/greengrass/v2" -Dlog.store=FILE \
-jar ./GreengrassInstaller/lib/Greengrass.jar \
--trusted-plugin ./GreengrassInstaller/aws.greengrass.crypto.Pkcs11Provider.jar \
--init-config ./GreengrassInstaller/config.yaml \
--component-default-user ggc_user:ggc_group \
--setup-system-service true
```
**重要**
在 Windows 核心裝置上，您必須指定 `--setup-system-service true`將 AWS IoT Greengrass Core 軟體設定為系統服務。
如果您指定 `--setup-system-service true`，安裝程式會在設定並執行軟體做為系統服務`Successfully set up Nucleus as a system service`時列印。否則，如果安裝程式成功安裝軟體，就不會輸出任何訊息。
**注意**
當您在沒有 `deploy-dev-tools`引數的情況下執行安裝程式時，無法使用 `--provision true`引數來部署本機開發工具。如需有關直接在您的裝置上部署 Greengrass CLI 的資訊，請參閱 [Greengrass 命令列界面](gg-cli.md)。
1. 透過檢視根資料夾中的檔案來驗證安裝。
------
#### [ Linux or Unix ]
```
ls /greengrass/v2
```
------
#### [ Windows Command Prompt (CMD) ]
```
dir C:\greengrass\v2
```
------
#### [ PowerShell ]
```
ls C:\greengrass\v2
```
------
如果安裝成功，根資料夾會包含數個資料夾，例如 `config`、 `packages`和 `logs`。
如果您將 AWS IoT Greengrass Core 軟體安裝為系統服務，安裝程式會為您執行軟體。否則，您必須手動執行軟體。如需詳細資訊，請參閱[執行 AWS IoT Greengrass 核心軟體](run-greengrass-core-v2.md)。
**注意**
當 AWS IoT Greengrass Core 軟體連線至雲端時，您的裝置將被識別為 Core 裝置。
如需如何設定和使用軟體的詳細資訊 AWS IoT Greengrass，請參閱以下內容：
+ [設定 AWS IoT Greengrass 核心軟體](configure-greengrass-core-v2.md)
+ [開發 AWS IoT Greengrass 元件](develop-greengrass-components.md)
+ [將 AWS IoT Greengrass 元件部署至裝置](manage-deployments.md)
+ [Greengrass 命令列界面](gg-cli.md)
# 使用 AWS IoT 機群佈建安裝 AWS IoT Greengrass 核心軟體
此功能適用於 [Greengrass 核元件](greengrass-nucleus-component.md)的 v2.4.0 和更新版本。
透過機 AWS IoT 群佈建，您可以設定 AWS IoT AWS IoT ，在裝置第一次連線到 時，產生並安全地將 X.509 裝置憑證和私有金鑰交付至您的裝置。 AWS IoT 提供由 Amazon 根憑證授權單位 (CA) 簽署的用戶端憑證。您也可以設定 AWS IoT 來指定您使用機群佈建佈建的 Greengrass 核心裝置的物件群組、物件類型和許可。您可以定義*佈建範本*，以定義 如何 AWS IoT 佈建每個裝置。佈建範本會指定佈建時要為裝置建立的物件、政策和憑證資源。如需詳細資訊，請參閱《 *AWS IoT Core 開發人員指南*》中的[佈建範本](https://docs.aws.amazon.com/iot/latest/developerguide/provision-template.html)。
AWS IoT Greengrass 提供機 AWS IoT 群佈建外掛程式，可讓您使用機 AWS IoT 群佈建建立 AWS 的資源來安裝 AWS IoT Greengrass Core 軟體。機群佈建外掛程式會*依宣告使用佈建*。裝置使用佈建宣告憑證和私有金鑰來取得可用於一般操作的唯一 X.509 裝置憑證和私有金鑰。您可以在製造期間將宣告憑證和私有金鑰嵌入每個裝置，讓您的客戶稍後可以在每個裝置上線時啟用裝置。您可以針對多個裝置使用相同的宣告憑證和私有金鑰。如需詳細資訊，請參閱《 *AWS IoT Core 開發人員指南*》中的[依宣告佈建](https://docs.aws.amazon.com/iot/latest/developerguide/provision-wo-cert.html#claim-based)。
**注意**
機群佈建外掛程式目前不支援在硬體安全模組 (HSM) 中存放私有金鑰和憑證檔案。若要使用 HSM，[請使用手動佈建安裝 AWS IoT Greengrass 核心軟體](manual-installation.md)。
若要使用機 AWS IoT 群佈建安裝 AWS IoT Greengrass 核心軟體，您必須在 中設定 AWS IoT AWS 帳戶 用來佈建 Greengrass 核心裝置的資源。這些資源包括佈建範本、宣告憑證和[字符交換 IAM 角色](device-service-role.md)。建立這些資源之後，您可以重複使用這些資源，在機群中佈建多個核心裝置。如需詳細資訊，請參閱[設定 Greengrass 核心裝置的 AWS IoT 機群佈建](fleet-provisioning-setup.md)。
**重要**
下載 AWS IoT Greengrass Core 軟體之前，請檢查您的核心裝置是否符合安裝和執行 AWS IoT Greengrass Core 軟體 v2.0 [的需求](greengrass-nucleus-component.md#greengrass-v2-requirements)。
**Topics**
+ [先決條件](#fleet-provisioning-prerequisites)
+ [擷取 AWS IoT 端點](#retrieve-iot-endpoints)
+ [下載憑證至裝置](#download-claim-certificates)
+ [設定裝置環境](#set-up-device-environment)
+ [下載 AWS IoT Greengrass 核心軟體](#download-greengrass-core-v2)
+ [下載 AWS IoT 機群佈建外掛程式](#download-fleet-provisioning-plugin)
+ [安裝 AWS IoT Greengrass 核心軟體](#run-greengrass-core-v2-installer-fleet)
+ [設定 Greengrass 核心裝置的 AWS IoT 機群佈建](fleet-provisioning-setup.md)
+ [設定 AWS IoT 機群佈建外掛程式](fleet-provisioning-configuration.md)
+ [AWS IoT 機群佈建外掛程式 changelog](fleet-provisioning-changelog.md)
## 先決條件
若要使用機 AWS IoT 群佈建安裝 AWS IoT Greengrass 核心軟體，您必須先[為 Greengrass 核心裝置設定 AWS IoT 機群佈建](fleet-provisioning-setup.md)。完成這些步驟一次後，您可以使用機群佈建，在任何數量的裝置上安裝 AWS IoT Greengrass Core 軟體。
## 擷取 AWS IoT 端點
取得 的 AWS IoT 端點 AWS 帳戶，並儲存它們以供稍後使用。您的裝置會使用這些端點來連線 AWS IoT。請執行下列操作：
1. 取得 AWS IoT 的資料端點 AWS 帳戶。
```
aws iot describe-endpoint --endpoint-type iot:Data-ATS
```
如果請求成功，回應看起來與下列範例類似。
```
{
"endpointAddress": "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
}
```
1. 取得 的 AWS IoT 登入資料端點 AWS 帳戶。
```
aws iot describe-endpoint --endpoint-type iot:CredentialProvider
```
如果請求成功，回應看起來與下列範例類似。
```
{
"endpointAddress": "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
}
```
## 下載憑證至裝置
裝置使用宣告憑證和私有金鑰來驗證其佈建 AWS 資源和取得 X.509 裝置憑證的請求。您可以在製造期間將宣告憑證和私有金鑰嵌入裝置，或在安裝期間將憑證和金鑰複製到裝置。在本節中，您將宣告憑證和私有金鑰複製到裝置。您也可以將 Amazon 根憑證授權機構 (CA) 憑證下載到裝置。
**重要**
佈建宣告私有金鑰應隨時受到保護，包括在 Greengrass 核心裝置上。我們建議您使用 Amazon CloudWatch 指標和日誌來監控是否有濫用跡象，例如未經授權使用宣告憑證來佈建裝置。如果您偵測到濫用，請停用佈建宣告憑證，使其無法用於裝置佈建。如需詳細資訊，請參閱《 *AWS IoT Core 開發人員指南*》中的[監控 AWS IoT](https://docs.aws.amazon.com/iot/latest/developerguide/monitoring_overview.html)。
為了協助您更有效管理裝置數量，以及在 中自行註冊的裝置 AWS 帳戶，您可以在建立機群佈建範本時指定預先佈建掛鉤。預先佈建掛鉤是一種 AWS Lambda 函數，可驗證裝置在註冊期間提供的範本參數。例如，您可以建立預先佈建掛鉤，檢查資料庫的裝置 ID，以確認裝置具有佈建的許可。如需詳細資訊，請參閱《 *AWS IoT Core 開發人員指南*》中的[預先佈建掛](https://docs.aws.amazon.com/iot/latest/developerguide/pre-provisioning-hook.html)鉤。
**將宣告憑證下載至裝置**
1. 將宣告憑證和私有金鑰複製到裝置。如果在開發電腦和裝置上啟用 SSH 和 SCP，您可以使用開發電腦上的 `scp`命令來傳輸宣告憑證和私有金鑰。下列範例命令`claim-certs`會將開發電腦上名為 的資料夾傳輸至裝置。將 *device-ip-address* 取代為您裝置的 IP 地址。
```
scp -r claim-certs/ device-ip-address:~
```
1. 在裝置上建立 Greengrass 根資料夾。您稍後會將 AWS IoT Greengrass 核心軟體安裝到此資料夾。
**注意**
Windows 的路徑長度限制為 260 個字元。如果您使用的是 Windows，請使用根資料夾，例如 `C:\greengrass\v2`或 `D:\greengrass\v2` ，將 Greengrass 元件路徑保持在 260 個字元限制以下。
------
#### [ Linux or Unix ]
+ `/greengrass/v2` 將 取代為要使用的資料夾。
```
sudo mkdir -p /greengrass/v2
```
------
#### [ Windows Command Prompt ]
+ 將 *C：\$1greengrass\$1v2* 取代為要使用的資料夾。
```
mkdir C:\greengrass\v2
```
------
#### [ PowerShell ]
+ 將 *C：\$1greengrass\$1v2* 取代為要使用的資料夾。
```
mkdir C:\greengrass\v2
```
------
1. （僅限 Linux) 設定 Greengrass 根資料夾父項的許可。
+ 將 */greengrass* 取代為根資料夾的父系。
```
sudo chmod 755 /greengrass
```
1. 將宣告憑證移至 Greengrass 根資料夾。
+ 將 `/greengrass/v2`或 *C：\$1greengrass\$1v2* 取代為 Greengrass 根資料夾。
------
#### [ Linux or Unix ]
```
sudo mv ~/claim-certs /greengrass/v2
```
------
#### [ Windows Command Prompt (CMD) ]
```
move %USERPROFILE%\claim-certs C:\greengrass\v2
```
------
#### [ PowerShell ]
```
mv -Path ~\claim-certs -Destination C:\greengrass\v2
```
------
1. 根據預設，下載 Amazon 根憑證授權機構 (CA) certificate. AWS IoT certificates 會與 Amazon 根憑證授權機構憑證相關聯。
------
#### [ Linux or Unix ]
```
sudo curl -o /greengrass/v2/AmazonRootCA1.pem https://www.amazontrust.com/repository/AmazonRootCA1.pem
```
------
#### [ Windows Command Prompt (CMD) ]
```
curl -o C:\greengrass\v2\\AmazonRootCA1.pem https://www.amazontrust.com/repository/AmazonRootCA1.pem
```
------
#### [ PowerShell ]
```
iwr -Uri https://www.amazontrust.com/repository/AmazonRootCA1.pem -OutFile C:\greengrass\v2\\AmazonRootCA1.pem
```
------
## 設定裝置環境
請依照本節中的步驟設定 Linux 或 Windows 裝置，以用作您的 AWS IoT Greengrass 核心裝置。
### 設定 Linux 裝置
**設定 的 Linux 裝置 AWS IoT Greengrass V2**
1. 安裝執行 AWS IoT Greengrass 核心軟體所需的 Java 執行時間。我們建議您使用 [Amazon Corretto](https://aws.amazon.com/corretto/) 或 [OpenJDK](https://openjdk.java.net/) 長期支援版本。第 8 版或更新版本為必要項目。下列命令說明如何在裝置上安裝 OpenJDK。
+ 針對 Debian 為基礎或 Ubuntu 為基礎的發行版本：
```
sudo apt install default-jdk
```
+ 針對 Red Hat 為基礎的發行版本：
```
sudo yum install java-11-openjdk-devel
```
+ 針對 Amazon Linux 2：
```
sudo amazon-linux-extras install java-openjdk11
```
+ 針對 Amazon Linux 2023：
```
sudo dnf install java-11-amazon-corretto -y
```
安裝完成時，請執行下列命令來驗證 Java 是否在您的 Linux 裝置上執行。
```
java -version
```
命令會列印在裝置上執行的 Java 版本。例如，在 Debian 型分佈上，輸出看起來可能會類似下列範例。
```
openjdk version "11.0.9.1" 2020-11-04
OpenJDK Runtime Environment (build 11.0.9.1+1-post-Debian-1deb10u2)
OpenJDK 64-Bit Server VM (build 11.0.9.1+1-post-Debian-1deb10u2, mixed mode)
```
1. （選用） 建立在裝置上執行元件的預設系統使用者和群組。您也可以選擇讓 AWS IoT Greengrass Core 軟體安裝程式在安裝期間使用`--component-default-user`安裝程式引數建立此使用者和群組。如需詳細資訊，請參閱[安裝程式引數](configure-installer.md)。
```
sudo useradd --system --create-home ggc_user
sudo groupadd --system ggc_group
```
1. 確認執行 AWS IoT Greengrass 核心軟體的使用者 （通常為 `root`) 具有使用任何使用者和任何群組執行 `sudo` 的許可。
1. 執行下列命令以開啟 `/etc/sudoers` 檔案。
```
sudo visudo
```
1. 確認使用者的許可如下範例所示。
```
root ALL=(ALL:ALL) ALL
```
1. （選用） 若要[執行容器化 Lambda 函數](run-lambda-functions.md)，您必須啟用 [cgroups](https://en.wikipedia.org/wiki/Cgroups) v1，而且必須啟用和掛載*記憶體*和*裝置* cgroups。如果您不打算執行容器化 Lambda 函數，您可以略過此步驟。
若要啟用這些 cgroups 選項，請使用下列 Linux 核心參數啟動裝置。
```
cgroup_enable=memory cgroup_memory=1 systemd.unified_cgroup_hierarchy=0
```
如需有關檢視和設定裝置核心參數的資訊，請參閱作業系統和開機載入器的文件。依照指示永久設定核心參數。
1. 在裝置上安裝所有其他必要的相依性，如 中的需求清單所示[裝置要求](greengrass-nucleus-component.md#greengrass-v2-requirements)。
### 設定 Windows 裝置
**注意**
此功能適用於 [Greengrass 核元件](greengrass-nucleus-component.md)的 v2.5.0 和更新版本。
**為 設定 Windows 裝置 AWS IoT Greengrass V2**
1. 安裝執行 AWS IoT Greengrass 核心軟體所需的 Java 執行時間。我們建議您使用 [Amazon Corretto](https://aws.amazon.com/corretto/) 或 [OpenJDK](https://openjdk.java.net/) 長期支援版本。第 8 版或更新版本為必要項目。
1. 檢查 [PATH](https://en.wikipedia.org/wiki/PATH_(variable)) 系統變數上是否提供 Java，如果沒有，請新增它。LocalSystem 帳戶會執行 AWS IoT Greengrass Core 軟體，因此您必須將 Java 新增至 PATH 系統變數，而不是使用者的 PATH 使用者變數。請執行下列操作：
1. 按 Windows 鍵開啟開始選單。
1. 輸入 **environment variables** 以從開始功能表搜尋系統選項。
1. 在開始功能表搜尋結果中，選擇**編輯系統環境變數**以開啟**系統屬性**視窗。
1. 選擇**環境變數...**以開啟**環境變數**視窗。
1. 在**系統變數**下，選取**路徑**，然後選擇**編輯**。在**編輯環境變數**視窗中，您可以檢視個別行上的每個路徑。
1. 檢查 Java 安裝`bin`資料夾的路徑是否存在。路徑看起來可能會類似下列範例。
```
C:\\Program Files\\Amazon Corretto\\jdk11.0.13_8\\bin
```
1. 如果**路徑**中缺少 Java 安裝的`bin`資料夾，請選擇**新增**以新增，然後選擇**確定**。
1. 以管理員身分開啟 Windows 命令提示字元 (`cmd.exe`)。
1. 在 Windows 裝置上的 LocalSystem 帳戶中建立預設使用者。將*密碼*取代為安全密碼。
```
net user /add ggc_user password
```
**提示**
根據您的 Windows 組態，使用者的密碼可能會設定為在未來的日期過期。為了確保您的 Greengrass 應用程式持續運作，請追蹤密碼過期的時間，並在過期前更新它。您也可以將使用者的密碼設定為永不過期。
若要檢查使用者及其密碼何時過期，請執行下列命令。
```
net user ggc_user | findstr /C:expires
```
若要將使用者的密碼設定為永不過期，請執行下列命令。
```
wmic UserAccount where "Name='ggc_user'" set PasswordExpires=False
```
如果您使用的是[`wmic`已棄用命令](https://learn.microsoft.com/en-us/windows/win32/wmisdk/wmic)的 Windows 10 或更新版本，請執行下列 PowerShell 命令。
```
Get-CimInstance -Query "SELECT * from Win32_UserAccount WHERE name = 'ggc_user'" | Set-CimInstance -Property @{PasswordExpires="False"}
```
1. 從 Microsoft 在裝置上下載並安裝 [PsExec 公用程式](https://docs.microsoft.com/en-us/sysinternals/downloads/psexec)。
1. 使用 PsExec 公用程式，將預設使用者的使用者名稱和密碼存放在 LocalSystem 帳戶的 Credential Manager 執行個體中。將*密碼*取代為您先前設定的使用者密碼。
```
psexec -s cmd /c cmdkey /generic:ggc_user /user:ggc_user /pass:password
```
如果 **PsExec License Agreement** 開啟，請選擇 以**Accept**同意授權並執行 命令。
**注意**
在 Windows 裝置上，LocalSystem 帳戶會執行 Greengrass 核，而且您必須使用 PsExec 公用程式將預設使用者資訊存放在 LocalSystem 帳戶中。使用 Credential Manager 應用程式會將此資訊存放在目前登入使用者的 Windows 帳戶中，而不是 LocalSystem 帳戶。
## 下載 AWS IoT Greengrass 核心軟體
您可以從下列位置下載最新版本的 AWS IoT Greengrass Core 軟體：
+ [https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip](https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip)
**注意**
您可以從下列位置下載特定版本的 AWS IoT Greengrass 核心軟體。將*版本*取代為要下載的版本。
```
https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-version.zip
```
**下載 AWS IoT Greengrass 核心軟體**
1. 在您的核心裝置上，將 AWS IoT Greengrass Core 軟體下載至名為 的檔案`greengrass-nucleus-latest.zip`。
------
#### [ Linux or Unix ]
```
curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip > greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
```
curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip > greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
```
iwr -Uri https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip -OutFile greengrass-nucleus-latest.zip
```
------
下載此軟體，即表示您同意 [Greengrass 核心軟體授權合約](https://greengrass-release-license.s3.us-west-2.amazonaws.com/greengrass-license-v1.pdf)之規定。
1. （選用） 驗證 Greengrass 核軟體簽章
**注意**
此功能適用於 Greengrass 核版本 2.9.5 及更新版本。
1. 使用下列命令來驗證 Greengrass 核子成品的簽章：
------
#### [ Linux or Unix ]
```
jarsigner -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
檔案名稱看起來可能會有所不同，視您安裝的 JDK 版本而定。*`jdk17.0.6_10`* 將 取代為您安裝的 JDK 版本。
```
"C:\\Program Files\\Amazon Corretto\\jdk17.0.6_10\\bin\\jarsigner.exe" -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
檔案名稱看起來可能會有所不同，視您安裝的 JDK 版本而定。*`jdk17.0.6_10`* 將 取代為您安裝的 JDK 版本。
```
'C:\\Program Files\\Amazon Corretto\\jdk17.0.6_10\\bin\\jarsigner.exe' -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
1. `jarsigner` 調用會產生輸出，指出驗證的結果。
1. 如果已簽署 Greengrass 核 zip 檔案，輸出會包含下列陳述式：
```
jar verified.
```
1. 如果 Greengrass 核 zip 檔案未簽署，輸出會包含下列陳述式：
```
jar is unsigned.
```
1. 如果您提供 Jarsigner `-certs`選項以及 `-verify`和 `-verbose`選項，輸出也會包含詳細的簽署者憑證資訊。
1. 將 AWS IoT Greengrass Core 軟體解壓縮至裝置上的資料夾。將 *GreengrassInstaller* 取代為您要使用的資料夾。
------
#### [ Linux or Unix ]
```
unzip greengrass-nucleus-latest.zip -d GreengrassInstaller && rm greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
```
mkdir GreengrassInstaller && tar -xf greengrass-nucleus-latest.zip -C GreengrassInstaller && del greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
```
Expand-Archive -Path greengrass-nucleus-latest.zip -DestinationPath .\\GreengrassInstaller
rm greengrass-nucleus-latest.zip
```
------
1. （選用） 執行下列命令以查看 AWS IoT Greengrass 核心軟體版本。
```
java -jar ./GreengrassInstaller/lib/Greengrass.jar --version
```
**重要**
如果您安裝的 Greengrass 核版本早於 2.4.0 版，請勿在安裝 AWS IoT Greengrass 核心軟體之後移除此資料夾。Core AWS IoT Greengrass 軟體會使用此資料夾中的檔案來執行。
如果您下載最新版本的軟體，請安裝 v2.4.0 或更新版本，並在安裝 AWS IoT Greengrass Core 軟體後移除此資料夾。
## 下載 AWS IoT 機群佈建外掛程式
您可以從下列位置下載最新版本的 AWS IoT 機群佈建外掛程式：
+ [https://d2s8p88vqu9w66.cloudfront.net/releases/aws-greengrass-FleetProvisioningByClaim/fleetprovisioningbyclaim-latest.jar](https://d2s8p88vqu9w66.cloudfront.net/releases/aws-greengrass-FleetProvisioningByClaim/fleetprovisioningbyclaim-latest.jar)
**注意**
您可以從下列位置下載特定版本的 AWS IoT 機群佈建外掛程式。將*版本*取代為要下載的版本。如需每個機群佈建外掛程式版本的詳細資訊，請參閱 [AWS IoT 機群佈建外掛程式 changelog](fleet-provisioning-changelog.md)。
```
https://d2s8p88vqu9w66.cloudfront.net/releases/aws-greengrass-FleetProvisioningByClaim/fleetprovisioningbyclaim-version.jar
```
機群佈建外掛程式是開放原始碼。若要檢視其原始程式碼，請參閱 GitHub 上的[AWS IoT 機群佈建外掛程式](https://github.com/aws-greengrass/aws-greengrass-fleet-provisioning-by-claim)。
**下載 AWS IoT 機群佈建外掛程式**
+ 在您的裝置上，將 AWS IoT 機群佈建外掛程式下載至名為 的檔案`aws.greengrass.FleetProvisioningByClaim.jar`。將 *GreengrassInstaller* 取代為您要使用的資料夾。
------
#### [ Linux or Unix ]
```
curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/aws-greengrass-FleetProvisioningByClaim/fleetprovisioningbyclaim-latest.jar > GreengrassInstaller/aws.greengrass.FleetProvisioningByClaim.jar
```
------
#### [ Windows Command Prompt (CMD) ]
```
curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/aws-greengrass-FleetProvisioningByClaim/fleetprovisioningbyclaim-latest.jar > GreengrassInstaller/aws.greengrass.FleetProvisioningByClaim.jar
```
------
#### [ PowerShell ]
```
iwr -Uri https://d2s8p88vqu9w66.cloudfront.net/releases/aws-greengrass-FleetProvisioningByClaim/fleetprovisioningbyclaim-latest.jar -OutFile GreengrassInstaller/aws.greengrass.FleetProvisioningByClaim.jar
```
------
下載此軟體，即表示您同意 [Greengrass 核心軟體授權合約](https://greengrass-release-license.s3.us-west-2.amazonaws.com/greengrass-license-v1.pdf)之規定。
## 安裝 AWS IoT Greengrass 核心軟體
使用指定下列動作的引數執行安裝程式：
+ 從指定使用機群佈建外掛程式佈建 AWS 資源的部分組態檔案安裝 。Core AWS IoT Greengrass 軟體使用組態檔案，指定裝置上每個 Greengrass 元件的組態。安裝程式會從您提供的部分組態檔案和機群佈建外掛程式建立 AWS 的資源建立完整的組態檔案。
+ 指定 以使用`ggc_user`系統使用者在核心裝置上執行軟體元件。在 Linux 裝置上，此命令也會指定 使用`ggc_group`系統群組，安裝程式會為您建立系統使用者和群組。
+ 將 AWS IoT Greengrass Core 軟體設定為開機時執行的系統服務。在 Linux 裝置上，這需要 [Systemd](https://en.wikipedia.org/wiki/Systemd) init 系統。
**重要**
在 Windows 核心裝置上，您必須將 AWS IoT Greengrass Core 軟體設定為系統服務。
如需可指定引數的詳細資訊，請參閱 [安裝程式引數](configure-installer.md)。
**注意**
如果您在記憶體有限的 AWS IoT Greengrass 裝置上執行 ，您可以控制 AWS IoT Greengrass Core 軟體使用的記憶體量。若要控制記憶體配置，您可以在核心元件的`jvmOptions`組態參數中設定 JVM 堆積大小選項。如需詳細資訊，請參閱[使用 JVM 選項控制記憶體配置](configure-greengrass-core-v2.md#jvm-tuning)。
**安裝 AWS IoT Greengrass 核心軟體**
1. 檢查 AWS IoT Greengrass Core 軟體的版本。
+ 將 *GreengrassInstaller* 取代為包含軟體之資料夾的路徑。
```
java -jar ./GreengrassInstaller/lib/Greengrass.jar --version
```
1. 使用文字編輯器來建立名為 的組態檔案`config.yaml`，以提供給安裝程式。
例如，在以 Linux 為基礎的系統上，您可以執行下列命令來使用 GNU nano 來建立 檔案。
```
nano GreengrassInstaller/config.yaml
```
將下列 YAML 內容複製到 檔案。此部分組態檔案會指定機群佈建外掛程式的參數。如需您可以指定之選項的詳細資訊，請參閱 [設定 AWS IoT 機群佈建外掛程式](fleet-provisioning-configuration.md)。
------
#### [ Linux or Unix ]
```
---
services:
aws.greengrass.Nucleus:
version: "2.16.1"
aws.greengrass.FleetProvisioningByClaim:
configuration:
rootPath: "/greengrass/v2"
awsRegion: "us-west-2"
iotDataEndpoint: "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
iotCredentialEndpoint: "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
iotRoleAlias: "GreengrassCoreTokenExchangeRoleAlias"
provisioningTemplate: "GreengrassFleetProvisioningTemplate"
claimCertificatePath: "/greengrass/v2/claim-certs/claim.pem.crt"
claimCertificatePrivateKeyPath: "/greengrass/v2/claim-certs/claim.private.pem.key"
rootCaPath: "/greengrass/v2/AmazonRootCA1.pem"
templateParameters:
ThingName: "MyGreengrassCore"
ThingGroupName: "MyGreengrassCoreGroup"
```
------
#### [ Windows ]
```
---
services:
aws.greengrass.Nucleus:
version: "2.16.1"
aws.greengrass.FleetProvisioningByClaim:
configuration:
rootPath: "C:\\greengrass\\v2"
awsRegion: "us-west-2"
iotDataEndpoint: "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
iotCredentialEndpoint: "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
iotRoleAlias: "GreengrassCoreTokenExchangeRoleAlias"
provisioningTemplate: "GreengrassFleetProvisioningTemplate"
claimCertificatePath: "C:\\greengrass\\v2\\claim-certs\\claim.pem.crt"
claimCertificatePrivateKeyPath: "C:\\greengrass\\v2\\claim-certs\\claim.private.pem.key"
rootCaPath: "C:\\greengrass\\v2\\AmazonRootCA1.pem"
templateParameters:
ThingName: "MyGreengrassCore"
ThingGroupName: "MyGreengrassCoreGroup"
```
------
然後，執行下列動作：
+ 將 *2.16.1* 取代為 AWS IoT Greengrass 核心軟體版本。
+ 將 `/greengrass/v2`或 *C：\$1greengrass\$1v2* 的每個執行個體取代為 Greengrass 根資料夾。
**注意**
在 Windows 裝置上，您必須將路徑分隔符號指定為雙反斜線 (`\\`)，例如 `C:\\greengrass\\v2`。
+ 將 *us-west-2* 取代為您建立佈建範本和其他資源 AWS 的區域。
+ 將 取代`iotDataEndpoint`為您的 AWS IoT 資料端點。
+ 將 取代`iotCredentialEndpoint`為您的 AWS IoT 登入資料端點。
+ 以字符交換角色別名的名稱取代 *GreengrassCoreTokenExchangeRoleAlias*。
+ 以機群佈建範本的名稱取代 *GreengrassFleetProvisioningTemplate*。
+ 將 取代`claimCertificatePath`為裝置上的宣告憑證路徑。
+ 將 取代`claimCertificatePrivateKeyPath`為裝置上的宣告憑證私有金鑰路徑。
+ 將範本參數 (`templateParameters`) 取代為用來佈建裝置的值。此範例是指定義 `ThingName`和 `ThingGroupName` 參數[的範例範本](fleet-provisioning-setup.md#example-fleet-provisioning-template)。
**注意**
在此組態檔案中，您可以自訂其他組態選項，例如要使用的連接埠和網路代理，如下列範例所示。如需詳細資訊，請參閱 [Greengrass 核組態](greengrass-nucleus-component.md#greengrass-nucleus-component-configuration)。
```
---
services:
aws.greengrass.Nucleus:
version: "2.16.1"
configuration:
mqtt:
port: 443
greengrassDataPlanePort: 443
networkProxy:
noProxyAddresses: "http://192.168.0.1,www.example.com"
proxy:
url: "http://my-proxy-server:1100"
username: "Mary_Major"
password: "pass@word1357"
aws.greengrass.FleetProvisioningByClaim:
configuration:
rootPath: "/greengrass/v2"
awsRegion: "us-west-2"
iotDataEndpoint: "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
iotCredentialEndpoint: "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
iotRoleAlias: "GreengrassCoreTokenExchangeRoleAlias"
provisioningTemplate: "GreengrassFleetProvisioningTemplate"
claimCertificatePath: "/greengrass/v2/claim-certs/claim.pem.crt"
claimCertificatePrivateKeyPath: "/greengrass/v2/claim-certs/claim.private.pem.key"
rootCaPath: "/greengrass/v2/AmazonRootCA1.pem"
templateParameters:
ThingName: "MyGreengrassCore"
ThingGroupName: "MyGreengrassCoreGroup"
mqttPort: 443
proxyUrl: "http://my-proxy-server:1100"
proxyUserName: "Mary_Major"
proxyPassword: "pass@word1357"
```
```
---
services:
aws.greengrass.Nucleus:
version: "2.16.1"
configuration:
mqtt:
port: 443
greengrassDataPlanePort: 443
networkProxy:
noProxyAddresses: "http://192.168.0.1,www.example.com"
proxy:
url: "http://my-proxy-server:1100"
username: "Mary_Major"
password: "pass@word1357"
aws.greengrass.FleetProvisioningByClaim:
configuration:
rootPath: "C:\\greengrass\\v2"
awsRegion: "us-west-2"
iotDataEndpoint: "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
iotCredentialEndpoint: "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
iotRoleAlias: "GreengrassCoreTokenExchangeRoleAlias"
provisioningTemplate: "GreengrassFleetProvisioningTemplate"
claimCertificatePath: "C:\\greengrass\\v2\\claim-certs\\claim.pem.crt"
claimCertificatePrivateKeyPath: "C:\\greengrass\\v2\\claim-certs\\claim.private.pem.key"
rootCaPath: "C:\\greengrass\\v2\\AmazonRootCA1.pem"
templateParameters:
ThingName: "MyGreengrassCore"
ThingGroupName: "MyGreengrassCoreGroup"
mqttPort: 443
proxyUrl: "http://my-proxy-server:1100"
proxyUserName: "Mary_Major"
proxyPassword: "pass@word1357"
```
若要使用 HTTPS 代理，您必須使用 1.1.0 版或更新版本的機群佈建外掛程式。您必須另外在 `rootCaPath`下指定 `system`，如下列範例所示。
```
---
system:
rootCaPath: "/greengrass/v2/AmazonRootCA1.pem"
services:
...
```
```
---
system:
rootCaPath: "C:\\greengrass\\v2\\AmazonRootCA1.pem"
services:
...
```
1. 執行安裝程式。指定 `--trusted-plugin`以提供機群佈建外掛程式，並指定 `--init-config` 提供組態檔案。
+ `/greengrass/v2` 將 取代為 Greengrass 根資料夾。
+ 將 *GreengrassInstaller* 的每個執行個體取代為您解壓縮安裝程式的資料夾。
------
#### [ Linux or Unix ]
```
sudo -E java -Droot="/greengrass/v2" -Dlog.store=FILE \
-jar ./GreengrassInstaller/lib/Greengrass.jar \
--trusted-plugin ./GreengrassInstaller/aws.greengrass.FleetProvisioningByClaim.jar \
--init-config ./GreengrassInstaller/config.yaml \
--component-default-user ggc_user:ggc_group \
--setup-system-service true
```
------
#### [ Windows Command Prompt (CMD) ]
```
java -Droot="C:\greengrass\v2" "-Dlog.store=FILE" ^
-jar ./GreengrassInstaller/lib/Greengrass.jar ^
--trusted-plugin ./GreengrassInstaller/aws.greengrass.FleetProvisioningByClaim.jar ^
--init-config ./GreengrassInstaller/config.yaml ^
--component-default-user ggc_user ^
--setup-system-service true
```
------
#### [ PowerShell ]
```
java -Droot="C:\greengrass\v2" "-Dlog.store=FILE" `
-jar ./GreengrassInstaller/lib/Greengrass.jar `
--trusted-plugin ./GreengrassInstaller/aws.greengrass.FleetProvisioningByClaim.jar `
--init-config ./GreengrassInstaller/config.yaml `
--component-default-user ggc_user `
--setup-system-service true
```
------
**重要**
在 Windows 核心裝置上，您必須指定 `--setup-system-service true`將 AWS IoT Greengrass Core 軟體設定為系統服務。
如果您指定 `--setup-system-service true`，安裝程式會在設定並執行軟體做為系統服務`Successfully set up Nucleus as a system service`時列印。否則，如果安裝程式成功安裝軟體，就不會輸出任何訊息。
**注意**
當您在沒有 `deploy-dev-tools`引數的情況下執行安裝程式時，無法使用 `--provision true`引數來部署本機開發工具。如需直接在您的裝置上部署 Greengrass CLI 的資訊，請參閱 [Greengrass 命令列界面](gg-cli.md)。
1. 透過檢視根資料夾中的檔案來驗證安裝。
------
#### [ Linux or Unix ]
```
ls /greengrass/v2
```
------
#### [ Windows Command Prompt (CMD) ]
```
dir C:\greengrass\v2
```
------
#### [ PowerShell ]
```
ls C:\greengrass\v2
```
------
如果安裝成功，根資料夾會包含數個資料夾，例如 `config`、 `packages`和 `logs`。
如果您將 AWS IoT Greengrass Core 軟體安裝為系統服務，安裝程式會為您執行軟體。否則，您必須手動執行軟體。如需詳細資訊，請參閱[執行 AWS IoT Greengrass 核心軟體](run-greengrass-core-v2.md)。
如需如何設定和使用軟體和 的詳細資訊 AWS IoT Greengrass，請參閱以下內容：
+ [設定 AWS IoT Greengrass 核心軟體](configure-greengrass-core-v2.md)
+ [開發 AWS IoT Greengrass 元件](develop-greengrass-components.md)
+ [將 AWS IoT Greengrass 元件部署至裝置](manage-deployments.md)
+ [Greengrass 命令列界面](gg-cli.md)
# 設定 Greengrass 核心裝置的 AWS IoT 機群佈建
若要[使用機群佈建安裝 AWS IoT Greengrass 核心軟體](fleet-provisioning.md)，您必須先在 中設定下列資源 AWS 帳戶。這些資源可讓裝置向 註冊， AWS IoT 並以 Greengrass 核心裝置的形式運作。請遵循本節中的步驟，在 中建立和設定這些資源 AWS 帳戶。
+ 權杖交換 IAM 角色，核心裝置會使用該角色來授權對 AWS 服務的呼叫。
+ 指向字符交換角色 AWS IoT 的角色別名。
+ （選用） 政策，核心裝置會使用該 AWS IoT 政策來授權對 AWS IoT 和 AWS IoT Greengrass 服務的呼叫。此 AWS IoT 政策必須允許指向字符交換 AWS IoT 角色的角色別名`iot:AssumeRoleWithCertificate`許可。
您可以針對機群中的所有核心裝置使用單一 AWS IoT 政策，也可以設定機群佈建範本來為每個核心裝置建立 AWS IoT 政策。
+ AWS IoT 機群佈建範本。此範本必須指定下列項目：
+ 物件 AWS IoT 資源。您可以指定現有物件群組的清單，以便在元件上線時將元件部署到每個裝置。
+ AWS IoT 政策資源。此資源可以定義下列其中一個屬性：
+ 現有 AWS IoT 政策的名稱。如果您選擇此選項，則您從此範本建立的核心裝置會使用相同的 AWS IoT 政策，而且您可以以機群身分管理其許可。
+ AWS IoT 政策文件。如果您選擇此選項，您從此範本建立的每個核心裝置都會使用唯一的 AWS IoT 政策，而且您可以管理每個個別核心裝置的許可。
+ AWS IoT 憑證資源。此憑證資源必須使用 `AWS::IoT::Certificate::Id` 參數將憑證連接至核心裝置。如需詳細資訊，請參閱《 *AWS IoT 開發人員指南*》中的[Just-in-time佈建](https://docs.aws.amazon.com/iot/latest/developerguide/jit-provisioning.html)。
+ 機群 AWS IoT 佈建範本的佈建宣告憑證和私有金鑰。您可以在製造期間將此憑證和私有金鑰嵌入裝置，讓裝置可以在上線時自行註冊和佈建。
**重要**
佈建宣告私有金鑰應隨時受到保護，包括在 Greengrass 核心裝置上。我們建議您使用 Amazon CloudWatch 指標和日誌來監控是否有濫用跡象，例如未經授權使用宣告憑證來佈建裝置。如果您偵測到濫用，請停用佈建宣告憑證，使其無法用於裝置佈建。如需詳細資訊，請參閱《 *AWS IoT Core 開發人員指南*》中的[監控 AWS IoT](https://docs.aws.amazon.com/iot/latest/developerguide/monitoring_overview.html)。
為了協助您更有效管理在 中自行註冊的裝置數量和裝置 AWS 帳戶，您可以在建立機群佈建範本時指定預先佈建掛鉤。預先佈建掛鉤是一種 AWS Lambda 函數，可驗證裝置在註冊期間提供的範本參數。例如，您可以建立預先佈建掛鉤，檢查資料庫的裝置 ID，以確認裝置具有佈建的許可。如需詳細資訊，請參閱[《 開發人員指南》中的預先佈建掛](https://docs.aws.amazon.com/iot/latest/developerguide/pre-provisioning-hook.html)鉤。 *AWS IoT Core *
+ 您連接到佈建宣告憑證 AWS IoT 的政策，允許裝置註冊和使用機群佈建範本。
**Topics**
+ [建立權杖交換角色](#create-token-exchange-role)
+ [建立 AWS IoT 政策](#create-iot-policy)
+ [建立機群佈建範本](#create-provisioning-template)
+ [建立佈建宣告憑證和私有金鑰](#create-claim-certificates)
## 建立權杖交換角色
Greengrass 核心裝置使用稱為*字符交換角色的 IAM 服務角色*來授權呼叫 AWS 服務。裝置使用 AWS IoT 登入資料提供者取得此角色的臨時 AWS 登入資料，允許裝置與 互動 AWS IoT、將日誌傳送至 Amazon CloudWatch Logs，以及從 Amazon S3 下載自訂元件成品。如需詳細資訊，請參閱[授權核心裝置與 AWS 服務互動](device-service-role.md)。
您可以使用 AWS IoT *角色別名*來設定 Greengrass 核心裝置的字符交換角色。角色別名可讓您變更裝置的字符交換角色，但保持裝置的組態相同。如需詳細資訊，請參閱《 *AWS IoT Core 開發人員指南*》中的[授權直接呼叫 AWS 服務](https://docs.aws.amazon.com/iot/latest/developerguide/authorizing-direct-aws.html)。
在本節中，您會建立權杖交換 IAM 角色和指向角色 AWS IoT 的角色別名。如果您已經設定 Greengrass 核心裝置，您可以使用其權杖交換角色和角色別名，而不是建立新的權杖交換角色和角色別名。
**建立字符交換 IAM 角色**
1. 建立您的裝置可用作字符交換角色的 IAM 角色。請執行下列操作：
1. 建立檔案，其中包含權杖交換角色所需的信任政策文件。
例如，在以 Linux 為基礎的系統上，您可以執行下列命令來使用 GNU nano 來建立 檔案。
```
nano device-role-trust-policy.json
```
將下列 JSON 複製到 檔案。
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "credentials.iot.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
1. 使用信任政策文件建立權杖交換角色。
+ 將 *GreengrassV2TokenExchangeRole* 取代為要建立的 IAM 角色名稱。
```
aws iam create-role --role-name GreengrassV2TokenExchangeRole --assume-role-policy-document file://device-role-trust-policy.json
```
如果請求成功，回應看起來與下列範例類似。
```
{
"Role": {
"Path": "/",
"RoleName": "GreengrassV2TokenExchangeRole",
"RoleId": "AROAZ2YMUHYHK5OKM77FB",
"Arn": "arn:aws:iam::123456789012:role/GreengrassV2TokenExchangeRole",
"CreateDate": "2021-02-06T00:13:29+00:00",
"AssumeRolePolicyDocument": {
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "credentials.iot.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
}
```
1. 建立檔案，其中包含字符交換角色所需的存取政策文件。
例如，在以 Linux 為基礎的系統上，您可以執行下列命令來使用 GNU nano 來建立 檔案。
```
nano device-role-access-policy.json
```
將下列 JSON 複製到 檔案。
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents",
"logs:DescribeLogStreams",
"s3:GetBucketLocation"
],
"Resource": "*"
}
]
}
```
**注意**
此存取政策不允許存取 S3 儲存貯體中的元件成品。若要部署定義 Amazon S3 中成品的自訂元件，您必須將許可新增至角色，以允許核心裝置擷取元件成品。如需詳細資訊，請參閱[允許存取元件成品的 S3 儲存貯體](device-service-role.md#device-service-role-access-s3-bucket)。
如果您還沒有元件成品的 S3 儲存貯體，您可以在建立儲存貯體之後新增這些許可。
1. 從政策文件中建立 IAM 政策。
+ 將 *GreengrassV2TokenExchangeRoleAccess* 取代為要建立的 IAM 政策名稱。
```
aws iam create-policy --policy-name GreengrassV2TokenExchangeRoleAccess --policy-document file://device-role-access-policy.json
```
如果請求成功，回應看起來與下列範例類似。
```
{
"Policy": {
"PolicyName": "GreengrassV2TokenExchangeRoleAccess",
"PolicyId": "ANPAZ2YMUHYHACI7C5Z66",
"Arn": "arn:aws:iam::123456789012:policy/GreengrassV2TokenExchangeRoleAccess",
"Path": "/",
"DefaultVersionId": "v1",
"AttachmentCount": 0,
"PermissionsBoundaryUsageCount": 0,
"IsAttachable": true,
"CreateDate": "2021-02-06T00:37:17+00:00",
"UpdateDate": "2021-02-06T00:37:17+00:00"
}
}
```
1. 將 IAM 政策連接至字符交換角色。
+ 將 *GreengrassV2TokenExchangeRole* 取代為 IAM 角色的名稱。
+ 將政策 ARN 取代為您在上一個步驟中建立的 IAM 政策 ARN。
```
aws iam attach-role-policy --role-name GreengrassV2TokenExchangeRole --policy-arn arn:aws:iam::123456789012:policy/GreengrassV2TokenExchangeRoleAccess
```
如果請求成功，命令不會有任何輸出。
1. 建立指向字符交換 AWS IoT 角色的角色別名。
+ 以要建立的角色別名名稱取代 *GreengrassCoreTokenExchangeRoleAlias*。
+ 將角色 ARN 取代為您在上一個步驟中建立之 IAM 角色的 ARN。
```
aws iot create-role-alias --role-alias GreengrassCoreTokenExchangeRoleAlias --role-arn arn:aws:iam::123456789012:role/GreengrassV2TokenExchangeRole
```
如果請求成功，回應看起來與下列範例類似。
```
{
"roleAlias": "GreengrassCoreTokenExchangeRoleAlias",
"roleAliasArn": "arn:aws:iot:us-west-2:123456789012:rolealias/GreengrassCoreTokenExchangeRoleAlias"
}
```
**注意**
若要建立角色別名，您必須具有傳遞字符交換 IAM 角色的許可 AWS IoT。如果您在嘗試建立角色別名時收到錯誤訊息，請檢查您的 AWS 使用者是否具有此許可。如需詳細資訊，請參閱*AWS Identity and Access Management 《 使用者指南*》中的[授予使用者將角色傳遞至 AWS 服務的許可](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_passrole.html)。
## 建立 AWS IoT 政策
將裝置註冊為 AWS IoT 物件後，該裝置可以使用數位憑證進行身分驗證 AWS。此憑證包含一或多個政策，這些 AWS IoT 政策定義裝置可搭配憑證使用的許可。這些政策允許裝置與 AWS IoT 和 通訊 AWS IoT Greengrass。
透過機 AWS IoT 群佈建，裝置會連線至 AWS IoT 以建立和下載裝置憑證。在下一個區段中建立的機群佈建範本中，您可以指定是否將相同的 AWS IoT 政策 AWS IoT 連接到所有裝置的憑證，或為每個裝置建立新的政策。
在本節中，您會建立 AWS IoT 連接到所有裝置憑證 AWS IoT 的政策。透過此方法，您可以將所有裝置的許可管理為機群。如果您想要為每個裝置建立新的 AWS IoT 政策，您可以略過本節，並在定義機群範本時參考其中的政策。
**建立 AWS IoT 政策**
+ 建立 AWS IoT 政策來定義 Greengrass 核心裝置機群的 AWS IoT 許可。下列政策允許存取所有 MQTT 主題和 Greengrass 操作，因此您的裝置可以使用需要新 Greengrass 操作的自訂應用程式和未來變更。此政策也允許 `iot:AssumeRoleWithCertificate`許可，允許您的裝置使用您在上一節中建立的字符交換角色。您可以根據使用案例來限制此政策關閉。如需詳細資訊，請參閱[AWS IoT Greengrass V2 核心裝置的最低 AWS IoT 政策](device-auth.md#greengrass-core-minimal-iot-policy)。
請執行下列操作：
1. 建立檔案，其中包含 Greengrass 核心裝置所需的 AWS IoT 政策文件。
例如，在以 Linux 為基礎的系統上，您可以執行下列命令來使用 GNU nano 來建立 檔案。
```
nano greengrass-v2-iot-policy.json
```
將下列 JSON 複製到 檔案。
+ 以您在上一節中建立 AWS IoT 的角色別名 ARN 取代`iot:AssumeRoleWithCertificate`資源。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Publish",
"iot:Subscribe",
"iot:Receive",
"iot:Connect",
"greengrass:*"
],
"Resource": [
"*"
]
},
{
"Effect": "Allow",
"Action": "iot:AssumeRoleWithCertificate",
"Resource": "arn:aws:iot:us-east-1:123456789012:rolealias/GreengrassCoreTokenExchangeRoleAlias"
}
]
}
```
------
1. 從 AWS IoT 政策文件中建立政策。
+ 將 *GreengrassV2IoTThingPolicy* 取代為要建立的政策名稱。
```
aws iot create-policy --policy-name GreengrassV2IoTThingPolicy --policy-document file://greengrass-v2-iot-policy.json
```
如果請求成功，回應看起來與下列範例類似。
------
#### [ JSON ]
****
```
{
"policyName": "GreengrassV2IoTThingPolicy",
"policyArn": "arn:aws:iot:us-west-2:123456789012:policy/GreengrassV2IoTThingPolicy",
"policyDocument": "{
\"Version\": \"2012-10-17\",
\"Statement\": [
{
\"Effect\": \"Allow\",
\"Action\": [
\"iot:Publish\",
\"iot:Subscribe\",
\"iot:Receive\",
\"iot:Connect\",
\"greengrass:*\"
],
\"Resource\": [
\"*\"
]
},
{
\"Effect\": \"Allow\",
\"Action\": \"iot:AssumeRoleWithCertificate\",
\"Resource\": \"arn:aws:iot:us-west-2:123456789012:rolealias/GreengrassCoreTokenExchangeRoleAlias\"
}
]
}",
"policyVersionId": "1"
}
```
------
## 建立機群佈建範本
AWS IoT 機群佈建範本定義如何佈建 AWS IoT 物件、政策和憑證。若要使用機群佈建外掛程式佈建 Greengrass 核心裝置，您必須建立指定下列項目的範本：
+ 物件 AWS IoT 資源。您可以指定現有物件群組的清單，以便在元件上線時將元件部署到每個裝置。
+ AWS IoT 政策資源。此資源可以定義下列其中一個屬性：
+ 現有 AWS IoT 政策的名稱。如果您選擇此選項，您從此範本建立的核心裝置會使用相同的 AWS IoT 政策，而且您可以將其許可做為機群管理。
+ AWS IoT 政策文件。如果您選擇此選項，您從此範本建立的每個核心裝置都會使用唯一的 AWS IoT 政策，而且您可以管理每個個別核心裝置的許可。
+ AWS IoT 憑證資源。此憑證資源必須使用 `AWS::IoT::Certificate::Id` 參數將憑證連接至核心裝置。如需詳細資訊，請參閱《 *AWS IoT 開發人員指南*》中的[Just-in-time佈建](https://docs.aws.amazon.com/iot/latest/developerguide/jit-provisioning.html)。
在範本中，您可以指定 將 AWS IoT 物件新增至現有物件群組的清單。當核心裝置 AWS IoT Greengrass 第一次連線至 時，它會針對其成員所在的每個物件群組接收 Greengrass 部署。您可以使用物件群組，在裝置上線後立即將最新的軟體部署到每個裝置。如需詳細資訊，請參閱[將 AWS IoT Greengrass 元件部署至裝置](manage-deployments.md)。
在佈建裝置 AWS 帳戶 時， AWS IoT 服務需要許可，才能在 中建立和更新 AWS IoT 資源。若要授予 AWS IoT 服務存取權，您可以建立 IAM 角色，並在建立範本時提供該角色。 AWS IoT 提供受管政策 [AWSIoTThingsRegistration](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/service-role/AWSIoTThingsRegistration)，允許存取佈建裝置時 AWS IoT 可能使用的所有許可。您可以使用此受管政策，或建立自訂政策，針對您的使用案例縮小受管政策中的許可範圍。
在本節中，您會建立允許 AWS IoT 佈建裝置資源的 IAM 角色，並建立使用該 IAM 角色的機群佈建範本。
**建立機群佈建範本**
1. 建立 AWS IoT 可在 中佈建資源的 IAM 角色 AWS 帳戶。請執行下列操作：
1. 建立檔案，其中包含允許 AWS IoT 擔任角色的信任政策文件。
例如，在以 Linux 為基礎的系統上，您可以執行下列命令來使用 GNU nano 來建立 檔案。
```
nano aws-iot-trust-policy.json
```
將下列 JSON 複製到 檔案。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "iot.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
1. 使用信任政策文件建立 IAM 角色。
+ 將 *GreengrassFleetProvisioningRole* 取代為要建立的 IAM 角色名稱。
```
aws iam create-role --role-name GreengrassFleetProvisioningRole --assume-role-policy-document file://aws-iot-trust-policy.json
```
如果請求成功，回應看起來與下列範例類似。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Connect",
"iot:Publish",
"iot:Subscribe",
"iot:Receive"
],
"Resource": "*"
}
]
}
```
------
1. 檢閱 [AWSIoTThingsRegistration](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/service-role/AWSIoTThingsRegistration) 政策，允許存取佈建裝置時 AWS IoT 可能使用的所有許可。您可以使用此受管政策，或建立自訂政策，為您的使用案例定義縮小範圍的許可。如果您選擇建立自訂政策，請現在執行此操作。
1. 將 IAM 政策連接至機群佈建角色。
+ 將 *GreengrassFleetProvisioningRole* 取代為 IAM 角色的名稱。
+ 如果您在上一個步驟中建立了自訂政策，請將政策 ARN 取代為要使用的 IAM 政策的 ARN。
```
aws iam attach-role-policy --role-name GreengrassFleetProvisioningRole --policy-arn arn:aws:iam::aws:policy/service-role/AWSIoTThingsRegistration
```
如果請求成功，命令不會有任何輸出。
1. （選用） 建立*預先佈建掛鉤*，這是 AWS Lambda 驗證裝置在註冊期間提供之範本參數的 函數。您可以使用預先佈建掛鉤，進一步控制您的 中加入哪些裝置以及裝置數量 AWS 帳戶。如需詳細資訊，請參閱《 *AWS IoT Core 開發人員指南*》中的[預先佈建掛](https://docs.aws.amazon.com/iot/latest/developerguide/pre-provisioning-hook.html)鉤。
1. 建立機群佈建範本。請執行下列操作：
1. 建立 檔案以包含佈建範本文件。
例如，在以 Linux 為基礎的系統上，您可以執行下列命令來使用 GNU nano 來建立 檔案。
```
nano greengrass-fleet-provisioning-template.json
```
撰寫佈建範本文件。您可以從下列範例佈建範本開始，該範本指定 建立具有下列屬性的 AWS IoT 物件：
+ 物件的名稱是您在`ThingName`範本參數中指定的值。
+ 物件是您在`ThingGroupName`範本參數中指定之物件群組的成員。物件群組必須存在於您的 中 AWS 帳戶。
+ 物件的憑證已`GreengrassV2IoTThingPolicy`附加名為 AWS IoT 的政策。
如需詳細資訊，請參閱《 *AWS IoT Core 開發人員指南*》中的[佈建範本](https://docs.aws.amazon.com/iot/latest/developerguide/provision-template.html)。
```
{
"Parameters": {
"ThingName": {
"Type": "String"
},
"ThingGroupName": {
"Type": "String"
},
"AWS::IoT::Certificate::Id": {
"Type": "String"
}
},
"Resources": {
"MyThing": {
"OverrideSettings": {
"AttributePayload": "REPLACE",
"ThingGroups": "REPLACE",
"ThingTypeName": "REPLACE"
},
"Properties": {
"AttributePayload": {},
"ThingGroups": [
{
"Ref": "ThingGroupName"
}
],
"ThingName": {
"Ref": "ThingName"
}
},
"Type": "AWS::IoT::Thing"
},
"MyPolicy": {
"Properties": {
"PolicyName": "GreengrassV2IoTThingPolicy"
},
"Type": "AWS::IoT::Policy"
},
"MyCertificate": {
"Properties": {
"CertificateId": {
"Ref": "AWS::IoT::Certificate::Id"
},
"Status": "Active"
},
"Type": "AWS::IoT::Certificate"
}
}
}
```
**注意**
*MyThing*、*MyPolicy* 和 *MyCertificate* 是任意名稱，可識別機群佈建範本中的每個資源規格。 AWS IoT 不會在從範本建立的資源中使用這些名稱。您可以使用這些名稱，或將其取代為可協助您識別範本中每個資源的值。
1. 從佈建範本文件建立機群佈建範本。
+ 將 *GreengrassFleetProvisioningTemplate* 取代為要建立的範本名稱。
+ 將範本描述取代為您的範本描述。
+ 將佈建角色 ARN 取代為您先前建立之角色的 ARN。
------
#### [ Linux or Unix ]
```
aws iot create-provisioning-template \
--template-name GreengrassFleetProvisioningTemplate \
--description "A provisioning template for Greengrass core devices." \
--provisioning-role-arn "arn:aws:iam::123456789012:role/GreengrassFleetProvisioningRole" \
--template-body file://greengrass-fleet-provisioning-template.json \
--enabled
```
------
#### [ Windows Command Prompt (CMD) ]
```
aws iot create-provisioning-template ^
--template-name GreengrassFleetProvisioningTemplate ^
--description "A provisioning template for Greengrass core devices." ^
--provisioning-role-arn "arn:aws:iam::123456789012:role/GreengrassFleetProvisioningRole" ^
--template-body file://greengrass-fleet-provisioning-template.json ^
--enabled
```
------
#### [ PowerShell ]
```
aws iot create-provisioning-template `
--template-name GreengrassFleetProvisioningTemplate `
--description "A provisioning template for Greengrass core devices." `
--provisioning-role-arn "arn:aws:iam::123456789012:role/GreengrassFleetProvisioningRole" `
--template-body file://greengrass-fleet-provisioning-template.json `
--enabled
```
------
**注意**
如果您建立了預先佈建掛鉤，請使用 `--pre-provisioning-hook`引數指定預先佈建掛鉤 Lambda 函數的 ARN。
```
--pre-provisioning-hook targetArn=arn:aws:lambda:us-west-2:123456789012:function:GreengrassPreProvisioningHook
```
如果請求成功，回應看起來與下列範例類似。
```
{
"templateArn": "arn:aws:iot:us-west-2:123456789012:provisioningtemplate/GreengrassFleetProvisioningTemplate",
"templateName": "GreengrassFleetProvisioningTemplate",
"defaultVersionId": 1
}
```
## 建立佈建宣告憑證和私有金鑰
宣告憑證是 X.509 憑證，允許裝置註冊為 AWS IoT 實物，並擷取唯一 X.509 裝置憑證以用於一般操作。建立宣告憑證後，您可以連接 AWS IoT 政策，允許裝置使用它來建立唯一的裝置憑證，並使用機群佈建範本進行佈建。具有宣告憑證的裝置只能使用您在政策中 AWS IoT 允許的佈建範本進行佈建。
在本節中，您會建立宣告憑證，並將其設定為讓裝置與您在上一節中建立的機群佈建範本搭配使用。
**重要**
佈建宣告私有金鑰應隨時受到保護，包括在 Greengrass 核心裝置上。我們建議您使用 Amazon CloudWatch 指標和日誌來監控是否有濫用跡象，例如未經授權使用宣告憑證來佈建裝置。如果您偵測到濫用，請停用佈建宣告憑證，使其無法用於裝置佈建。如需詳細資訊，請參閱《 *AWS IoT Core 開發人員指南*》中的[監控 AWS IoT](https://docs.aws.amazon.com/iot/latest/developerguide/monitoring_overview.html)。
為了協助您更有效管理裝置數量，以及在 中自行註冊的裝置 AWS 帳戶，您可以在建立機群佈建範本時指定預先佈建掛鉤。預先佈建掛鉤是一種 AWS Lambda 函數，可驗證裝置在註冊期間提供的範本參數。例如，您可以建立預先佈建掛鉤，檢查資料庫的裝置 ID，以確認裝置具有佈建的許可。如需詳細資訊，請參閱《 *AWS IoT Core 開發人員指南*》中的[預先佈建掛](https://docs.aws.amazon.com/iot/latest/developerguide/pre-provisioning-hook.html)鉤。
**建立佈建宣告憑證和私有金鑰**
1. 建立資料夾以下載宣告憑證和私有金鑰。
```
mkdir claim-certs
```
1. 建立並儲存憑證和私有金鑰以用於佈建。 AWS IoT 提供由 Amazon 根憑證授權機構 (CA) 簽署的用戶端憑證。
------
#### [ Linux or Unix ]
```
aws iot create-keys-and-certificate \
--certificate-pem-outfile "claim-certs/claim.pem.crt" \
--public-key-outfile "claim-certs/claim.public.pem.key" \
--private-key-outfile "claim-certs/claim.private.pem.key" \
--set-as-active
```
------
#### [ Windows Command Prompt (CMD) ]
```
aws iot create-keys-and-certificate ^
--certificate-pem-outfile "claim-certs/claim.pem.crt" ^
--public-key-outfile "claim-certs/claim.public.pem.key" ^
--private-key-outfile "claim-certs/claim.private.pem.key" ^
--set-as-active
```
------
#### [ PowerShell ]
```
aws iot create-keys-and-certificate `
--certificate-pem-outfile "claim-certs/claim.pem.crt" `
--public-key-outfile "claim-certs/claim.public.pem.key" `
--private-key-outfile "claim-certs/claim.private.pem.key" `
--set-as-active
```
------
如果請求成功，回應會包含憑證的相關資訊。儲存憑證的 ARN 以供稍後使用。
1. 建立並連接 AWS IoT 政策，允許裝置使用憑證來建立唯一的裝置憑證，並使用機群佈建範本進行佈建。下列政策允許存取裝置佈建 MQTT API。如需詳細資訊，請參閱《 *AWS IoT Core 開發人員指南*》中的[裝置佈建 MQTT API](https://docs.aws.amazon.com/iot/latest/developerguide/fleet-provision-api.html)。
請執行下列操作：
1. 建立檔案，其中包含 Greengrass 核心裝置所需的 AWS IoT 政策文件。
例如，在以 Linux 為基礎的系統上，您可以執行下列命令來使用 GNU nano 來建立 檔案。
```
nano greengrass-provisioning-claim-iot-policy.json
```
將下列 JSON 複製到 檔案。
+ 將每個*區域*執行個體取代為您設定機群佈建 AWS 區域 的 。
+ 將 *account-id* 的每個執行個體取代為您的 AWS 帳戶 ID。
+ 以您在上一節中建立的機群佈建範本名稱取代 *GreengrassFleetProvisioningTemplate* 的每個執行個體。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "iot:Connect",
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"iot:Publish",
"iot:Receive"
],
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topic/$aws/certificates/create/*",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/provisioning-templates/GreengrassFleetProvisioningTemplate/provision/*"
]
},
{
"Effect": "Allow",
"Action": "iot:Subscribe",
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/certificates/create/*",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/provisioning-templates/GreengrassFleetProvisioningTemplate/provision/*"
]
}
]
}
```
------
1. 從 AWS IoT 政策文件建立政策。
+ 將 *GreengrassProvisioningClaimPolicy* 取代為要建立的政策名稱。
```
aws iot create-policy --policy-name GreengrassProvisioningClaimPolicy --policy-document file://greengrass-provisioning-claim-iot-policy.json
```
如果請求成功，回應看起來與下列範例類似。
------
#### [ JSON ]
****
```
{
"policyName": "GreengrassProvisioningClaimPolicy",
"policyArn": "arn:aws:iot:us-west-2:123456789012:policy/GreengrassProvisioningClaimPolicy",
"policyDocument": "{
\"Version\": \"2012-10-17\",
\"Statement\": [
{
\"Effect\": \"Allow\",
\"Action\": \"iot:Connect\",
\"Resource\": \"*\"
},
{
\"Effect\": \"Allow\",
\"Action\": [
\"iot:Publish\",
\"iot:Receive\"
],
\"Resource\": [
\"arn:aws:iot:us-east-1:123456789012:topic/$aws/certificates/create/*\",
\"arn:aws:iot:us-east-1:123456789012:topic/$aws/provisioning-templates/GreengrassFleetProvisioningTemplate/provision/*\"
]
},
{
\"Effect\": \"Allow\",
\"Action\": \"iot:Subscribe\",
\"Resource\": [
\"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/certificates/create/*\",
\"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/provisioning-templates/GreengrassFleetProvisioningTemplate/provision/*\"
]
}
]
}",
"policyVersionId": "1"
}
```
------
1. 將 AWS IoT 政策連接至佈建宣告憑證。
+ 將 *GreengrassProvisioningClaimPolicy* 取代為要連接的政策名稱。
+ 將目標 ARN 取代為佈建宣告憑證的 ARN。
```
aws iot attach-policy --policy-name GreengrassProvisioningClaimPolicy --target arn:aws:iot:us-west-2:123456789012:cert/aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4
```
如果請求成功，命令不會有任何輸出。
您現在擁有佈建宣告憑證和私有金鑰，裝置可用來向 註冊 AWS IoT ，並將自己佈建為 Greengrass 核心裝置。您可以在製造期間將宣告憑證和私有金鑰嵌入裝置，或在安裝 AWS IoT Greengrass 核心軟體之前將憑證和金鑰複製到裝置。如需詳細資訊，請參閱[使用 AWS IoT 機群佈建安裝 AWS IoT Greengrass 核心軟體](fleet-provisioning.md)。
# 設定 AWS IoT 機群佈建外掛程式
AWS IoT 機群佈建外掛程式提供下列組態參數，您可以在[使用機群佈建安裝 AWS IoT Greengrass Core 軟體](fleet-provisioning.md)時自訂這些參數。
`rootPath`
要做為 AWS IoT Greengrass Core 軟體根目錄的資料夾路徑。
`awsRegion`
機群佈建外掛程式用來佈建 AWS 資源 AWS 區域 的 。
`iotDataEndpoint`
您 AWS IoT 的資料端點 AWS 帳戶。
`iotCredentialEndpoint`
您 的 AWS IoT 登入資料端點 AWS 帳戶。
`iotRoleAlias`
指向字符交換 IAM AWS IoT 角色的角色別名。 AWS IoT 登入資料提供者會擔任此角色，以允許 Greengrass 核心裝置與 AWS 服務互動。如需詳細資訊，請參閱[授權核心裝置與 AWS 服務互動](device-service-role.md)。
`provisioningTemplate`
用於佈建 AWS 資源的 AWS IoT 機群佈建範本。此範本必須指定下列項目：
+ AWS IoT 物件資源。您可以指定現有物件群組的清單，以便在元件上線時將元件部署到每個裝置。
+ AWS IoT 政策資源。此資源可以定義下列其中一個屬性：
+ 現有 AWS IoT 政策的名稱。如果您選擇此選項，您從此範本建立的核心裝置會使用相同的 AWS IoT 政策，而且您可以將其許可做為機群管理。
+ AWS IoT 政策文件。如果您選擇此選項，您從此範本建立的每個核心裝置都會使用唯一的 AWS IoT 政策，而且您可以管理每個個別核心裝置的許可。
+ AWS IoT 憑證資源。此憑證資源必須使用 `AWS::IoT::Certificate::Id` 參數將憑證連接至核心裝置。如需詳細資訊，請參閱《 *AWS IoT 開發人員指南*》中的[Just-in-time佈建](https://docs.aws.amazon.com/iot/latest/developerguide/jit-provisioning.html)。
如需詳細資訊，請參閱《 *AWS IoT Core 開發人員指南*》中的[佈建範本](https://docs.aws.amazon.com/iot/latest/developerguide/provision-template.html)。
`claimCertificatePath`
您在 中指定之佈建範本的佈建宣告憑證路徑`provisioningTemplate`。如需詳細資訊，請參閱 *AWS IoT Core API 參考*中的 [CreateProvisioningClaim](https://docs.aws.amazon.com/iot/latest/apireference/API_CreateProvisioningClaim.html)。
`claimCertificatePrivateKeyPath`
您在 中指定的佈建範本之佈建宣告憑證私有金鑰的路徑`provisioningTemplate`。如需詳細資訊，請參閱 *AWS IoT Core API 參考*中的 [CreateProvisioningClaim](https://docs.aws.amazon.com/iot/latest/apireference/API_CreateProvisioningClaim.html)。
佈建宣告私有金鑰應隨時受到保護，包括在 Greengrass 核心裝置上。我們建議您使用 Amazon CloudWatch 指標和日誌來監控是否有濫用跡象，例如未經授權使用宣告憑證來佈建裝置。如果您偵測到濫用，請停用佈建宣告憑證，使其無法用於裝置佈建。如需詳細資訊，請參閱《 *AWS IoT Core 開發人員指南*》中的[監控 AWS IoT](https://docs.aws.amazon.com/iot/latest/developerguide/monitoring_overview.html)。
為了協助您更有效管理裝置數量，以及在 中自行註冊的裝置 AWS 帳戶，您可以在建立機群佈建範本時指定預先佈建掛鉤。預先佈建掛鉤是一種 AWS Lambda 函數，可驗證裝置在註冊期間提供的範本參數。例如，您可以建立預先佈建掛鉤，檢查資料庫的裝置 ID，以確認裝置具有佈建的許可。如需詳細資訊，請參閱《 *AWS IoT Core 開發人員指南*》中的[預先佈建掛](https://docs.aws.amazon.com/iot/latest/developerguide/pre-provisioning-hook.html)鉤。
`rootCaPath`
Amazon 根憑證授權機構 (CA) 憑證的路徑。
`templateParameters`
（選用） 要提供給機群佈建範本的參數映射。如需詳細資訊，請參閱《 *AWS IoT Core 開發人員指南*》中的[佈建範本的參數一節](https://docs.aws.amazon.com/iot/latest/developerguide/provision-template.html#parameters-section)。
`deviceId`
（選用） 當機群佈建外掛程式建立 MQTT 連線時，用作用戶端 ID 的裝置識別符 AWS IoT。
預設：隨機 UUID。
`mqttPort`
（選用） 用於 MQTT 連線的連接埠。
預設：`8883`
`proxyUrl`
（選用） 代理伺服器的 URL，格式為 `scheme://userinfo@host:port`。若要使用 HTTPS 代理，您必須使用 1.1.0 版或更新版本的機群佈建外掛程式。
+ `scheme` – 結構描述，必須是 `http`或 `https`。
**重要**
Greengrass 核心裝置必須執行 [Greengrass 核 v](greengrass-nucleus-component.md)2.5.0 或更新版本，才能使用 HTTPS 代理。
如果您設定 HTTPS 代理，則必須將代理伺服器 CA 憑證新增至核心裝置的 Amazon 根 CA 憑證。如需詳細資訊，請參閱[讓核心裝置信任 HTTPS 代理](configure-greengrass-core-v2.md#https-proxy-certificate-trust)。
+ `userinfo` – （選用） 使用者名稱和密碼資訊。如果您在 中指定此資訊`url`，Greengrass 核心裝置會忽略 `username`和 `password` 欄位。
+ `host` – 代理伺服器的主機名稱或 IP 地址。
+ `port` – （選用） 連接埠號碼。如果您未指定連接埠，則 Greengrass 核心裝置會使用下列預設值：
+ `http` – 80
+ `https` – 443
`proxyUserName`
（選用） 驗證代理伺服器的使用者名稱。
`proxyPassword`
（選用） 驗證代理伺服器的使用者名稱。
csrPath
（選用） 憑證簽署請求 (CSR) 檔案的路徑，用於從 CSR 建立裝置憑證。如需詳細資訊，請參閱《 * AWS IoT Core 開發人員指南*》中的[依宣告佈建](https://docs.aws.amazon.com/iot/latest/developerguide/provision-wo-cert.html#claim-based)。
csrPrivateKeyPath
（選用，如果宣告`csrPath`則為必要） 用於產生 CSR 的私有金鑰路徑。私有金鑰必須已用於產生 CSR。如需詳細資訊，請參閱《 *AWS IoT Core 開發人員指南*》中的[依宣告佈建](https://docs.aws.amazon.com/iot/latest/developerguide/provision-wo-cert.html#claim-based)。
certificatePath
（選用） 用來儲存下載裝置憑證的路徑。
privateKeyPath
（選用） 用來儲存下載裝置私有金鑰的路徑。
# AWS IoT 機群佈建外掛程式 changelog
下表說明透過宣告外掛程式 () 進行機 AWS IoT 群佈建的每個版本變更`aws.greengrass.FleetProvisioningByClaim`。
| 版本 | 變更 |
| --- | --- |
| 1.2.2 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/greengrass/v2/developerguide/fleet-provisioning-changelog.html) |
| 1.2.1 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/greengrass/v2/developerguide/fleet-provisioning-changelog.html) |
| 1.2.0 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/greengrass/v2/developerguide/fleet-provisioning-changelog.html) |
| 1.1.0 | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/greengrass/v2/developerguide/fleet-provisioning-changelog.html) |
| 1.0.0 | 初始版本。 |
# 使用自訂資源佈建安裝 AWS IoT Greengrass 核心軟體
此功能適用於 [Greengrass 核元件](greengrass-nucleus-component.md)的 v2.4.0 和更新版本。
Core AWS IoT Greengrass 軟體安裝程式提供 Java 界面，您可以在佈建必要 AWS 資源的自訂外掛程式中實作此界面。您可以開發佈建外掛程式來使用自訂 X.509 用戶端憑證，或執行其他安裝程序不支援的複雜佈建步驟。如需詳細資訊，請參閱《 *AWS IoT Core 開發人員指南*》中的[建立您自己的用戶端憑證](https://docs.aws.amazon.com/iot/latest/developerguide/device-certs-your-own.html)。
若要在安裝 AWS IoT Greengrass Core 軟體時執行自訂佈建外掛程式，您可以建立您提供給安裝程式的 JAR 檔案。安裝程式會執行外掛程式，而外掛程式會傳回佈建組態，以定義 Greengrass 核心裝置 AWS 的資源。安裝程式會使用此資訊在裝置上設定 AWS IoT Greengrass Core 軟體。如需詳細資訊，請參閱[開發自訂佈建外掛程式](develop-custom-provisioning-plugins.md)。
**重要**
下載 AWS IoT Greengrass Core 軟體之前，請檢查您的核心裝置是否符合安裝和執行 AWS IoT Greengrass Core 軟體 v2.0 [的需求](greengrass-nucleus-component.md#greengrass-v2-requirements)。
**Topics**
+ [先決條件](#custom-provisioning-prerequisites)
+ [設定裝置環境](#set-up-device-environment)
+ [下載 AWS IoT Greengrass 核心軟體](#download-greengrass-core-v2)
+ [安裝 AWS IoT Greengrass 核心軟體](#run-greengrass-core-v2-installer-custom)
+ [開發自訂佈建外掛程式](develop-custom-provisioning-plugins.md)
## 先決條件
若要使用自訂佈建安裝 AWS IoT Greengrass 核心軟體，您必須具備下列項目：
+ 實作 之自訂佈建外掛程式的 JAR 檔案`DeviceIdentityInterface`。自訂佈建外掛程式必須傳回每個系統和 nucleus 組態參數的值。否則，您必須在安裝期間在組態檔案中提供這些值。如需詳細資訊，請參閱[開發自訂佈建外掛程式](develop-custom-provisioning-plugins.md)。
## 設定裝置環境
請依照本節中的步驟設定 Linux 或 Windows 裝置，以用作您的 AWS IoT Greengrass 核心裝置。
### 設定 Linux 裝置
**設定 的 Linux 裝置 AWS IoT Greengrass V2**
1. 安裝執行 AWS IoT Greengrass 核心軟體所需的 Java 執行時間。我們建議您使用 [Amazon Corretto](https://aws.amazon.com/corretto/) 或 [OpenJDK](https://openjdk.java.net/) 長期支援版本。第 8 版或更新版本為必要項目。下列命令說明如何在裝置上安裝 OpenJDK。
+ 針對 Debian 為基礎或 Ubuntu 為基礎的發行版本：
```
sudo apt install default-jdk
```
+ 針對 Red Hat 為基礎的發行版本：
```
sudo yum install java-11-openjdk-devel
```
+ 針對 Amazon Linux 2：
```
sudo amazon-linux-extras install java-openjdk11
```
+ 針對 Amazon Linux 2023：
```
sudo dnf install java-11-amazon-corretto -y
```
安裝完成時，請執行下列命令來驗證 Java 是否在您的 Linux 裝置上執行。
```
java -version
```
命令會列印在裝置上執行的 Java 版本。例如，在 Debian 型分佈上，輸出看起來可能會類似下列範例。
```
openjdk version "11.0.9.1" 2020-11-04
OpenJDK Runtime Environment (build 11.0.9.1+1-post-Debian-1deb10u2)
OpenJDK 64-Bit Server VM (build 11.0.9.1+1-post-Debian-1deb10u2, mixed mode)
```
1. （選用） 建立在裝置上執行元件的預設系統使用者和群組。您也可以選擇讓 AWS IoT Greengrass Core 軟體安裝程式在安裝期間使用`--component-default-user`安裝程式引數建立此使用者和群組。如需詳細資訊，請參閱[安裝程式引數](configure-installer.md)。
```
sudo useradd --system --create-home ggc_user
sudo groupadd --system ggc_group
```
1. 確認執行 AWS IoT Greengrass 核心軟體的使用者 （通常為 `root`) 具有使用任何使用者和任何群組執行 `sudo` 的許可。
1. 執行下列命令以開啟 `/etc/sudoers` 檔案。
```
sudo visudo
```
1. 確認使用者的許可如下範例所示。
```
root ALL=(ALL:ALL) ALL
```
1. （選用） 若要[執行容器化 Lambda 函數](run-lambda-functions.md)，您必須啟用 [cgroups](https://en.wikipedia.org/wiki/Cgroups) v1，而且必須啟用和掛載*記憶體*和*裝置* cgroups。如果您不打算執行容器化 Lambda 函數，您可以略過此步驟。
若要啟用這些 cgroups 選項，請使用下列 Linux 核心參數啟動裝置。
```
cgroup_enable=memory cgroup_memory=1 systemd.unified_cgroup_hierarchy=0
```
如需有關檢視和設定裝置核心參數的資訊，請參閱作業系統和開機載入器的文件。依照指示永久設定核心參數。
1. 在裝置上安裝所有其他必要的相依性，如 中的需求清單所示[裝置要求](greengrass-nucleus-component.md#greengrass-v2-requirements)。
### 設定 Windows 裝置
**注意**
此功能適用於 [Greengrass 核元件](greengrass-nucleus-component.md)的 v2.5.0 和更新版本。
**為 設定 Windows 裝置 AWS IoT Greengrass V2**
1. 安裝執行 AWS IoT Greengrass 核心軟體所需的 Java 執行時間。我們建議您使用 [Amazon Corretto](https://aws.amazon.com/corretto/) 或 [OpenJDK](https://openjdk.java.net/) 長期支援版本。第 8 版或更新版本為必要項目。
1. 檢查 [PATH](https://en.wikipedia.org/wiki/PATH_(variable)) 系統變數上是否提供 Java，如果沒有，請新增它。LocalSystem 帳戶會執行 AWS IoT Greengrass Core 軟體，因此您必須將 Java 新增至 PATH 系統變數，而不是使用者的 PATH 使用者變數。請執行下列操作：
1. 按 Windows 鍵開啟開始選單。
1. 輸入 **environment variables** 以從開始功能表搜尋系統選項。
1. 在開始功能表搜尋結果中，選擇**編輯系統環境變數**以開啟**系統屬性**視窗。
1. 選擇**環境變數...**以開啟**環境變數**視窗。
1. 在**系統變數**下，選取**路徑**，然後選擇**編輯**。在**編輯環境變數**視窗中，您可以檢視個別行上的每個路徑。
1. 檢查 Java 安裝`bin`資料夾的路徑是否存在。路徑看起來可能會類似下列範例。
```
C:\\Program Files\\Amazon Corretto\\jdk11.0.13_8\\bin
```
1. 如果**路徑**中缺少 Java 安裝的`bin`資料夾，請選擇**新增**以新增，然後選擇**確定**。
1. 以管理員身分開啟 Windows 命令提示字元 (`cmd.exe`)。
1. 在 Windows 裝置上的 LocalSystem 帳戶中建立預設使用者。將*密碼*取代為安全密碼。
```
net user /add ggc_user password
```
**提示**
根據您的 Windows 組態，使用者的密碼可能會設定為在未來的日期過期。為了確保您的 Greengrass 應用程式持續運作，請追蹤密碼過期的時間，並在過期之前更新它。您也可以將使用者的密碼設定為永不過期。
若要檢查使用者及其密碼何時過期，請執行下列命令。
```
net user ggc_user | findstr /C:expires
```
若要將使用者的密碼設定為永不過期，請執行下列命令。
```
wmic UserAccount where "Name='ggc_user'" set PasswordExpires=False
```
如果您使用的是[`wmic`已棄用命令](https://learn.microsoft.com/en-us/windows/win32/wmisdk/wmic)的 Windows 10 或更新版本，請執行下列 PowerShell 命令。
```
Get-CimInstance -Query "SELECT * from Win32_UserAccount WHERE name = 'ggc_user'" | Set-CimInstance -Property @{PasswordExpires="False"}
```
1. 從 Microsoft 在裝置上下載並安裝 [PsExec 公用程式](https://docs.microsoft.com/en-us/sysinternals/downloads/psexec)。
1. 使用 PsExec 公用程式，將預設使用者的使用者名稱和密碼存放在 LocalSystem 帳戶的 Credential Manager 執行個體中。將*密碼*取代為您先前設定的使用者密碼。
```
psexec -s cmd /c cmdkey /generic:ggc_user /user:ggc_user /pass:password
```
如果 **PsExec License Agreement** 開啟，請選擇 以**Accept**同意授權並執行 命令。
**注意**
在 Windows 裝置上，LocalSystem 帳戶會執行 Greengrass 核，而且您必須使用 PsExec 公用程式將預設使用者資訊存放在 LocalSystem 帳戶中。使用 Credential Manager 應用程式會將此資訊存放在目前登入使用者的 Windows 帳戶中，而不是 LocalSystem 帳戶。
## 下載 AWS IoT Greengrass 核心軟體
您可以從下列位置下載最新版本的 AWS IoT Greengrass Core 軟體：
+ [https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip](https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip)
**注意**
您可以從下列位置下載特定版本的 AWS IoT Greengrass 核心軟體。將*版本*取代為要下載的版本。
```
https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-version.zip
```
**下載 AWS IoT Greengrass 核心軟體**
1. 在您的核心裝置上，將 AWS IoT Greengrass Core 軟體下載至名為 的檔案`greengrass-nucleus-latest.zip`。
------
#### [ Linux or Unix ]
```
curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip > greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
```
curl -s https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip > greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
```
iwr -Uri https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip -OutFile greengrass-nucleus-latest.zip
```
------
下載此軟體，即表示您同意 [Greengrass 核心軟體授權合約](https://greengrass-release-license.s3.us-west-2.amazonaws.com/greengrass-license-v1.pdf)之規定。
1. （選用） 驗證 Greengrass 核軟體簽章
**注意**
此功能適用於 Greengrass 核版本 2.9.5 和更新版本。
1. 使用下列命令來驗證 Greengrass 核子成品的簽章：
------
#### [ Linux or Unix ]
```
jarsigner -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
檔案名稱看起來可能會有所不同，視您安裝的 JDK 版本而定。*`jdk17.0.6_10`* 將 取代為您安裝的 JDK 版本。
```
"C:\\Program Files\\Amazon Corretto\\jdk17.0.6_10\\bin\\jarsigner.exe" -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
檔案名稱看起來可能會有所不同，視您安裝的 JDK 版本而定。*`jdk17.0.6_10`* 將 取代為您安裝的 JDK 版本。
```
'C:\\Program Files\\Amazon Corretto\\jdk17.0.6_10\\bin\\jarsigner.exe' -verify -certs -verbose greengrass-nucleus-latest.zip
```
------
1. `jarsigner` 調用會產生輸出，指出驗證的結果。
1. 如果已簽署 Greengrass 核 zip 檔案，輸出會包含下列陳述式：
```
jar verified.
```
1. 如果 Greengrass 核 zip 檔案未簽署，輸出會包含下列陳述式：
```
jar is unsigned.
```
1. 如果您提供 Jarsigner `-certs`選項以及 `-verify`和 `-verbose`選項，輸出也會包含詳細的簽署者憑證資訊。
1. 將 AWS IoT Greengrass Core 軟體解壓縮至裝置上的資料夾。將 *GreengrassInstaller* 取代為您要使用的資料夾。
------
#### [ Linux or Unix ]
```
unzip greengrass-nucleus-latest.zip -d GreengrassInstaller && rm greengrass-nucleus-latest.zip
```
------
#### [ Windows Command Prompt (CMD) ]
```
mkdir GreengrassInstaller && tar -xf greengrass-nucleus-latest.zip -C GreengrassInstaller && del greengrass-nucleus-latest.zip
```
------
#### [ PowerShell ]
```
Expand-Archive -Path greengrass-nucleus-latest.zip -DestinationPath .\\GreengrassInstaller
rm greengrass-nucleus-latest.zip
```
------
1. （選用） 執行下列命令以查看 AWS IoT Greengrass 核心軟體版本。
```
java -jar ./GreengrassInstaller/lib/Greengrass.jar --version
```
**重要**
如果您安裝比 v2.4.0 更舊的 Greengrass 核版本，請勿在安裝 AWS IoT Greengrass 核心軟體之後移除此資料夾。Core AWS IoT Greengrass 軟體會使用此資料夾中的檔案來執行。
如果您下載最新版本的軟體，請安裝 v2.4.0 或更新版本，並在安裝 AWS IoT Greengrass 核心軟體後移除此資料夾。
## 安裝 AWS IoT Greengrass 核心軟體
使用指定下列動作的引數執行安裝程式：
+ 從指定 的部分組態檔案安裝 ，以使用您的自訂佈建外掛程式來佈建 AWS 資源。Core AWS IoT Greengrass 軟體使用組態檔案，指定裝置上每個 Greengrass 元件的組態。安裝程式會從您提供的部分組態檔案和自訂佈建外掛程式建立 AWS 的資源建立完整的組態檔案。
+ 指定 以使用`ggc_user`系統使用者在核心裝置上執行軟體元件。在 Linux 裝置上，此命令也會指定 使用`ggc_group`系統群組，安裝程式會為您建立系統使用者和群組。
+ 將 AWS IoT Greengrass Core 軟體設定為開機時執行的系統服務。在 Linux 裝置上，這需要 [Systemd](https://en.wikipedia.org/wiki/Systemd) init 系統。
**重要**
在 Windows 核心裝置上，您必須將 AWS IoT Greengrass Core 軟體設定為系統服務。
如需可指定引數的詳細資訊，請參閱 [安裝程式引數](configure-installer.md)。
**注意**
如果您在記憶體有限的 AWS IoT Greengrass 裝置上執行 ，您可以控制 AWS IoT Greengrass Core 軟體使用的記憶體量。若要控制記憶體配置，您可以在核心元件的`jvmOptions`組態參數中設定 JVM 堆積大小選項。如需詳細資訊，請參閱[使用 JVM 選項控制記憶體配置](configure-greengrass-core-v2.md#jvm-tuning)。
**安裝 AWS IoT Greengrass Core 軟體 (Linux)**
1. 檢查 AWS IoT Greengrass Core 軟體的版本。
+ 將 *GreengrassInstaller* 取代為包含軟體之資料夾的路徑。
```
java -jar ./GreengrassInstaller/lib/Greengrass.jar --version
```
1. 使用文字編輯器來建立名為 的組態檔案`config.yaml`，以提供給安裝程式。
例如，在以 Linux 為基礎的系統上，您可以執行下列命令來使用 GNU nano 來建立 檔案。
```
nano GreengrassInstaller/config.yaml
```
將下列 YAML 內容複製到 檔案。
```
---
system:
rootpath: "/greengrass/v2"
# The following values are optional. Return them from the provisioning plugin or set them here.
# certificateFilePath: ""
# privateKeyPath: ""
# rootCaPath: ""
# thingName: ""
services:
aws.greengrass.Nucleus:
version: "2.16.1"
configuration:
# The following values are optional. Return them from the provisioning plugin or set them here.
# awsRegion: ""
# iotRoleAlias: ""
# iotDataEndpoint: ""
# iotCredEndpoint: ""
com.example.CustomProvisioning:
configuration:
# You can specify configuration parameters to provide to your plugin.
# pluginParameter: ""
```
然後，執行下列動作：
+ 將 *2.16.1* 取代為 AWS IoT Greengrass 核心軟體版本。
+ 將 的每個執行個體取代`/greengrass/v2`為 Greengrass 根資料夾。
+ （選用） 指定系統和核組態值。如果您的佈建外掛程式不提供這些值，則必須設定這些值。
+ （選用） 指定要提供給佈建外掛程式的組態參數。
**注意**
在此組態檔案中，您可以自訂其他組態選項，例如要使用的連接埠和網路代理，如下列範例所示。如需詳細資訊，請參閱 [Greengrass 核組態](greengrass-nucleus-component.md#greengrass-nucleus-component-configuration)。
```
---
system:
rootpath: "/greengrass/v2"
# The following values are optional. Return them from the provisioning plugin or set them here.
# certificateFilePath: ""
# privateKeyPath: ""
# rootCaPath: ""
# thingName: ""
services:
aws.greengrass.Nucleus:
version: "2.16.1"
configuration:
mqtt:
port: 443
greengrassDataPlanePort: 443
networkProxy:
noProxyAddresses: "http://192.168.0.1,www.example.com"
proxy:
url: "http://my-proxy-server:1100"
username: "Mary_Major"
password: "pass@word1357"
# The following values are optional. Return them from the provisioning plugin or set them here.
# awsRegion: ""
# iotRoleAlias: ""
# iotDataEndpoint: ""
# iotCredEndpoint: ""
com.example.CustomProvisioning:
configuration:
# You can specify configuration parameters to provide to your plugin.
# pluginParameter: ""
```
1. 執行安裝程式。指定 `--trusted-plugin`以提供您的自訂佈建外掛程式，並指定 `--init-config`提供組態檔案。
**注意**
Windows 的路徑長度限制為 260 個字元。如果您使用的是 Windows，請使用根資料夾，例如 `C:\greengrass\v2`或 `D:\greengrass\v2` ，將 Greengrass 元件路徑保持在 260 個字元限制以下。
+ 將 `/greengrass/v2`或 *C：\$1greengrass\$1v2* 取代為 Greengrass 根資料夾。
+ 將 *GreengrassInstaller* 的每個執行個體取代為您解壓縮安裝程式的資料夾。
+ 將自訂佈建外掛程式 JAR 檔案的路徑取代為外掛程式 JAR 檔案的路徑。
------
#### [ Linux or Unix ]
```
sudo -E java -Droot="/greengrass/v2" -Dlog.store=FILE \
-jar ./GreengrassInstaller/lib/Greengrass.jar \
--trusted-plugin /path/to/com.example.CustomProvisioning.jar \
--init-config ./GreengrassInstaller/config.yaml \
--component-default-user ggc_user:ggc_group \
--setup-system-service true
```
------
#### [ Windows Command Prompt (CMD) ]
```
java -Droot="C:\greengrass\v2" "-Dlog.store=FILE" ^
-jar ./GreengrassInstaller/lib/Greengrass.jar ^
--trusted-plugin /path/to/com.example.CustomProvisioning.jar ^
--init-config ./GreengrassInstaller/config.yaml ^
--component-default-user ggc_user ^
--setup-system-service true
```
------
#### [ PowerShell ]
```
java -Droot="C:\greengrass\v2" "-Dlog.store=FILE" `
-jar ./GreengrassInstaller/lib/Greengrass.jar `
--trusted-plugin /path/to/com.example.CustomProvisioning.jar `
--init-config ./GreengrassInstaller/config.yaml `
--component-default-user ggc_user `
--setup-system-service true
```
------
**重要**
在 Windows 核心裝置上，您必須指定 `--setup-system-service true`將 AWS IoT Greengrass Core 軟體設定為系統服務。
如果您指定 `--setup-system-service true`，安裝程式會在設定並執行軟體做為系統服務`Successfully set up Nucleus as a system service`時列印。否則，如果安裝程式成功安裝軟體，就不會輸出任何訊息。
**注意**
當您在沒有 `deploy-dev-tools`引數的情況下執行安裝程式時，無法使用 `--provision true`引數來部署本機開發工具。如需有關直接在您的裝置上部署 Greengrass CLI 的資訊，請參閱 [Greengrass 命令列界面](gg-cli.md)。
1. 透過檢視根資料夾中的檔案來驗證安裝。
------
#### [ Linux or Unix ]
```
ls /greengrass/v2
```
------
#### [ Windows Command Prompt (CMD) ]
```
dir C:\greengrass\v2
```
------
#### [ PowerShell ]
```
ls C:\greengrass\v2
```
------
如果安裝成功，根資料夾會包含數個資料夾，例如 `config`、 `packages`和 `logs`。
如果您將 AWS IoT Greengrass Core 軟體安裝為系統服務，安裝程式會為您執行軟體。否則，您必須手動執行軟體。如需詳細資訊，請參閱[執行 AWS IoT Greengrass 核心軟體](run-greengrass-core-v2.md)。
如需如何設定和使用軟體的詳細資訊 AWS IoT Greengrass，請參閱以下內容：
+ [設定 AWS IoT Greengrass 核心軟體](configure-greengrass-core-v2.md)
+ [開發 AWS IoT Greengrass 元件](develop-greengrass-components.md)
+ [將 AWS IoT Greengrass 元件部署至裝置](manage-deployments.md)
+ [Greengrass 命令列界面](gg-cli.md)
# 開發自訂佈建外掛程式
若要開發自訂佈建外掛程式，請建立實作`com.aws.greengrass.provisioning.DeviceIdentityInterface`界面的 Java 類別。您可以在專案中包含 Greengrass 核 JAR 檔案，以存取此界面及其類別。此界面會定義輸入外掛程式組態並輸出佈建組態的方法。佈建組態會定義系統和 [Greengrass 核元件](greengrass-nucleus-component.md)的組態。Core AWS IoT Greengrass 軟體安裝程式使用此佈建組態在裝置上設定 AWS IoT Greengrass Core 軟體。
在您開發自訂佈建外掛程式之後，將其建置為 JAR 檔案，您可以提供給 AWS IoT Greengrass Core 軟體安裝程式，以在安裝期間執行外掛程式。安裝程式會在安裝程式使用的相同 JVM 中執行自訂佈建外掛程式，因此您可以建立僅包含外掛程式程式碼的 JAR。
**注意**
[AWS IoT 機群佈建外掛程式](fleet-provisioning.md)實作 `DeviceIdentityInterface`，以在安裝期間使用機群佈建。機群佈建外掛程式是開放原始碼，因此您可以探索其原始程式碼，以查看如何使用佈建外掛程式界面的範例。如需詳細資訊，請參閱 GitHub 上的[AWS IoT 機群佈建外掛程式](https://github.com/aws-greengrass/aws-greengrass-fleet-provisioning-by-claim)。
**Topics**
+ [要求](#custom-provisioning-plugin-requirements)
+ [實作 DeviceIdentityInterface 介面](#implement-device-identity-interface)
## 要求
若要開發自訂佈建外掛程式，您必須建立符合下列要求的 Java 類別：
+ 使用`com.aws.greengrass`套件或套件內的`com.aws.greengrass`套件。
+ 具有不含任何引數的建構函數。
+ 實作 `DeviceIdentityInterface` 界面。如需詳細資訊，請參閱[實作 DeviceIdentityInterface 介面](#implement-device-identity-interface)。
## 實作 DeviceIdentityInterface 介面
若要在自訂外掛程式中使用 `com.aws.greengrass.provisioning.DeviceIdentityInterface` 界面，請將 Greengrass 核新增為專案的相依性。
**在自訂佈建外掛程式專案中使用 DeviceIdentityInterface**
+ 您可以新增 Greengrass 核 JAR 檔案做為程式庫，或新增 Greengrass 核做為 Maven 相依性。執行以下任意一項：
+ 若要將 Greengrass 核 JAR 檔案新增為程式庫，請下載包含 Greengrass 核 JAR AWS IoT Greengrass 的核心軟體。您可以從下列位置下載最新版本的 AWS IoT Greengrass Core 軟體：
+ [https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip](https://d2s8p88vqu9w66.cloudfront.net/releases/greengrass-nucleus-latest.zip)
您可以在 ZIP 檔案的 `lib` 資料夾中找到 Greengrass 核 JAR 檔案 (`Greengrass.jar`)。將此 JAR 檔案新增至您的專案。
+ 若要在 Maven 專案中使用 Greengrass 核，請在 `com.aws.greengrass`群組中的`nucleus`成品上新增相依性 。您也必須新增`greengrass-common`儲存庫，因為 Maven Central Repository 中無法使用 Greengrass 核。
```
...
greengrass-common
greengrass common
https://d2jrmugq4soldf.cloudfront.net/snapshots
...
com.aws.greengrass
nucleus
2.5.0-SNAPSHOT
provided
```
### DeviceIdentityInterface 介面
`com.aws.greengrass.provisioning.DeviceIdentityInterface` 界面的形狀如下。
**注意**
您也可以在 GitHub 上 [Greengrass 核原始碼](https://github.com/aws-greengrass/aws-greengrass-nucleus)的 [com.aws.greengrass.provisioning 套件](https://github.com/aws-greengrass/aws-greengrass-nucleus/tree/main/src/main/java/com/aws/greengrass/provisioning)中探索這些類別。
```
public interface com.aws.greengrass.provisioning.DeviceIdentityInterface {
ProvisionConfiguration updateIdentityConfiguration(ProvisionContext context)
throws RetryableProvisioningException, InterruptedException;
// Return the name of the plugin.
String name();
}
com.aws.greengrass.provisioning.ProvisionConfiguration {
SystemConfiguration systemConfiguration;
NucleusConfiguration nucleusConfiguration
}
com.aws.greengrass.provisioning.ProvisionConfiguration.SystemConfiguration {
String certificateFilePath;
String privateKeyPath;
String rootCAPath;
String thingName;
}
com.aws.greengrass.provisioning.ProvisionConfiguration.NucleusConfiguration {
String awsRegion;
String iotCredentialsEndpoint;
String iotDataEndpoint;
String iotRoleAlias;
}
com.aws.greengrass.provisioning.ProvisioningContext {
Map parameterMap;
String provisioningPolicy; // The policy is always "PROVISION_IF_NOT_PROVISIONED".
}
com.aws.greengrass.provisioning.exceptions.RetryableProvisioningException {}
```
`SystemConfiguration` 和 中的每個組態值`NucleusConfiguration`都需要安裝 AWS IoT Greengrass Core 軟體，但您可以傳回 `null`。如果您的自訂佈建外掛程式傳回`null`任何組態值，則必須在建立 `config.yaml` 檔案以提供給 AWS IoT Greengrass Core 軟體安裝程式時，在系統或核心組態中提供該值。如果您的自訂佈建外掛程式針對您也在 中定義的選項傳回非空值`config.yaml`，則安裝程式會將 中的值取代`config.yaml`為外掛程式傳回的值。
# 安裝程式引數
AWS IoT Greengrass 核心軟體包含 安裝程式，可設定軟體並佈建 Greengrass 核心裝置執行所需的 AWS 資源。安裝程式包含下列引數，您可以指定這些引數來設定安裝：
`-h`, `--help`
（選用） 顯示安裝程式的說明資訊。
`--version`
（選用） 顯示 AWS IoT Greengrass 核心軟體版本。
`-Droot`
（選用） 要用作 AWS IoT Greengrass Core 軟體根資料夾的路徑。
此引數會設定 JVM 屬性，因此您必須在執行安裝程式`-jar`之前指定它。例如，指定 `java -Droot="/greengrass/v2" -jar /path/to/Greengrass.jar`。
預設：
+ Linux：`~/.greengrass`
+ Windows：`%USERPROFILE%/.greengrass`
`-ar`, `--aws-region`
Core AWS IoT Greengrass 軟體用來擷取或建立其必要 AWS 資源 AWS 區域 的 。
`-p`, `--provision`
（選用） 您可以將此裝置註冊為 AWS IoT 物件， AWS 並佈建核心裝置所需的資源。如果您指定 `true`， AWS IoT Greengrass Core 軟體會佈建 AWS IoT 物件、 （選用） AWS IoT 物件群組、IAM 角色和 AWS IoT 角色別名。
預設：`false`
`-tn`, `--thing-name`
（選用） 您註冊為此核心裝置的 AWS IoT 物件名稱。如果名稱為 的物件不存在於您的 中 AWS 帳戶，則 AWS IoT Greengrass Core 軟體會建立它。
物件名稱不能包含冒號 (`:`) 字元。
您必須指定 `--provision true`才能套用此引數。
預設：`GreengrassV2IotThing_`加上隨機 UUID。
`-tgn`, `--thing-group-name`
（選用） 您新增此核心裝置 AWS IoT AWS IoT 物件的物件群組名稱。如果部署以此物件群組為目標，則此核心裝置會在連線到 時接收該部署 AWS IoT Greengrass。如果您的 中不存在具有此名稱的物件群組 AWS 帳戶，則 AWS IoT Greengrass Core 軟體會建立它。
物件群組名稱不能包含冒號 (`:`) 字元。
您必須指定 `--provision true`才能套用此引數。
`-tpn`, `--thing-policy-name`
此功能適用於 [Greengrass 核元件](greengrass-nucleus-component.md)的 v2.4.0 和更新版本。
（選用） 要連接到此核心裝置 AWS IoT 物件憑證 AWS IoT 的政策名稱。如果您的 中不存在具有此名稱 AWS IoT 的政策 AWS 帳戶，則 AWS IoT Greengrass Core 軟體會建立該政策。
AWS IoT Greengrass 核心軟體預設會建立寬鬆 AWS IoT 政策。您可以縮小此政策的範圍，或建立自訂政策，以限制使用案例的許可。如需詳細資訊，請參閱[AWS IoT Greengrass V2 核心裝置的最低 AWS IoT 政策](device-auth.md#greengrass-core-minimal-iot-policy)。
您必須指定 `--provision true`才能套用此引數。
預設：`GreengrassV2IoTThingPolicy`
`-trn`, `--tes-role-name`
（選用） 用來取得 AWS 憑證的 IAM 角色名稱，讓核心裝置與服務互動 AWS 。如果您的 中不存在具有此名稱的角色 AWS 帳戶，則 AWS IoT Greengrass Core 軟體會使用 `GreengrassV2TokenExchangeRoleAccess`政策建立該角色。此角色無法存取您託管元件成品的 S3 儲存貯體。因此，您必須在建立元件時，將許可新增至成品的 S3 儲存貯體和物件。如需詳細資訊，請參閱[授權核心裝置與 AWS 服務互動](device-service-role.md)。
您必須指定 `--provision true`才能套用此引數。
預設：`GreengrassV2TokenExchangeRole`
`-tra`, `--tes-role-alias-name`
（選用） 指向提供此核心裝置 AWS 登入資料的 IAM 角色 AWS IoT 之角色別名的名稱。如果您的 中不存在具有此名稱的角色別名 AWS 帳戶，則 AWS IoT Greengrass Core 軟體會建立該別名，並將其指向您指定的 IAM 角色。
您必須指定 `--provision true`才能套用此引數。
預設：`GreengrassV2TokenExchangeRoleAlias`
`-ss`, `--setup-system-service`
（選用） 您可以將 AWS IoT Greengrass Core 軟體設定為在此裝置開機時執行的系統服務。系統服務名稱為 `greengrass`。如需詳細資訊，請參閱[將 Greengrass 核設定為系統服務](configure-greengrass-core-v2.md#configure-system-service)。
在 Linux 作業系統上，此引數要求 系統化初始化系統可在裝置上使用。
在 Windows 核心裝置上，您必須將 AWS IoT Greengrass Core 軟體設定為系統服務。
預設：`false`
`-u`, `--component-default-user`
Core AWS IoT Greengrass 軟體用來執行元件的使用者名稱或 ID。例如，您可以指定 **ggc\$1user**。當您在 Windows 作業系統上執行安裝程式時，需要此值。
在 Linux 作業系統上，您也可以選擇性地指定 群組。指定以冒號分隔的使用者和群組。例如：**ggc\$1user:ggc\$1group**。
下列其他考量事項適用於 Linux 作業系統：
+ 如果您以根身分執行，預設元件使用者即為組態檔案中定義的使用者。如果組態檔案未定義使用者，則預設為 `ggc_user:ggc_group`。如果 `ggc_user`或 `ggc_group` 不存在，軟體會建立它們。
+ 如果您以非根使用者身分執行 ，則 AWS IoT Greengrass Core 軟體會使用該使用者來執行元件。
+ 如果您未指定群組， AWS IoT Greengrass 則 Core 軟體會使用系統使用者的主要群組。
如需詳細資訊，請參閱[設定執行元件的使用者](configure-greengrass-core-v2.md#configure-component-user)。
`-d`, `--deploy-dev-tools`
（選用） 您可以將 [Greengrass CLI](greengrass-cli-component.md) 元件下載並部署到此核心裝置。您可以使用此工具來開發和偵錯此核心裝置上的元件。
我們建議您僅在開發環境中使用此元件，而不是在生產環境中。此元件可讓您存取生產環境中通常不需要的資訊和操作。僅將此元件部署到您需要的核心裝置，以遵循最低權限原則。
您必須指定 `--provision true`才能套用此引數。
預設：`false`
`-init`, `--init-config`
（選用） 用於安裝 AWS IoT Greengrass Core 軟體的組態檔案路徑。您可以使用此選項來設定具有特定核組態的新核心裝置，例如。
您指定的組態檔案會與核心裝置上的現有組態檔案合併。這包括核心裝置上的元件和元件組態。我們建議組態檔案只列出您嘗試變更的組態。
`-tp`, `--trusted-plugin`
（選用） 要載入為信任外掛程式的 JAR 檔案路徑。使用此選項提供佈建外掛程式 JAR 檔案，例如使用[機群佈建](fleet-provisioning.md)或[自訂佈建](custom-provisioning.md)安裝 ，或使用私有金鑰和憑證在[硬體安全模組](hardware-security.md)中安裝 。
`-s`, `--start`
（選用） 您可以在 AWS IoT Greengrass 核心軟體安裝後啟動，並選擇性地佈建資源。
預設：`true`
# 執行 AWS IoT Greengrass 核心軟體
[安裝 AWS IoT Greengrass Core 軟體](install-greengrass-core-v2.md)之後，請執行它以連接您的裝置 AWS IoT Greengrass。
安裝 AWS IoT Greengrass Core 軟體時，您可以指定是否要將其安裝為具有 [systemd](https://en.wikipedia.org/wiki/Systemd) 的系統服務。如果您選擇此選項，安裝程式會為您執行軟體，並將其設定為在裝置開機時執行。
**重要**
在 Windows 核心裝置上，您必須將 AWS IoT Greengrass Core 軟體設定為系統服務。
**Topics**
+ [檢查 AWS IoT Greengrass Core 軟體是否以系統服務的形式執行](#check-system-service)
+ [執行 AWS IoT Greengrass Core 軟體做為系統服務](#run-greengrass-core-system-service)
+ [在沒有系統服務的情況下執行 AWS IoT Greengrass Core 軟體](#run-greengrass-core-no-system-service)
## 檢查 AWS IoT Greengrass Core 軟體是否以系統服務的形式執行
安裝 AWS IoT Greengrass Core 軟體時，您可以指定 `--setup-system-service true`引數，將 AWS IoT Greengrass Core 軟體安裝為系統服務。Linux 裝置需要[系統化](https://en.wikipedia.org/wiki/Systemd)初始化系統，才能將 AWS IoT Greengrass Core 軟體設定為系統服務。如果您使用此選項，安裝程式會為您執行軟體，並將其設定為在裝置開機時執行。如果安裝程式成功將 AWS IoT Greengrass Core 軟體安裝為系統服務，安裝程式會輸出下列訊息。
```
Successfully set up Nucleus as a system service
```
如果您之前已安裝 AWS IoT Greengrass Core 軟體，但沒有安裝程式輸出，您可以檢查軟體是否安裝為系統服務。
**檢查 AWS IoT Greengrass Core 軟體是否已安裝為系統服務**
+ 執行下列命令來檢查 Greengrass 系統服務的狀態。
------
#### [ Linux or Unix (systemd) ]
```
sudo systemctl status greengrass.service
```
如果 AWS IoT Greengrass Core 軟體安裝為系統服務且處於作用中狀態，則回應看起來與下列範例類似。
```
● greengrass.service - Greengrass Core
Loaded: loaded (/etc/systemd/system/greengrass.service; enabled; vendor preset: disabled)
Active: active (running) since Thu 2021-02-11 01:33:44 UTC; 4 days ago
Main PID: 16107 (sh)
CGroup: /system.slice/greengrass.service
├─16107 /bin/sh /greengrass/v2/alts/current/distro/bin/loader
└─16111 java -Dlog.store=FILE -Droot=/greengrass/v2 -jar /greengrass/v2/alts/current/distro/lib/Greengrass...
```
如果找不到 `systemctl`或 `greengrass.service` ，則 AWS IoT Greengrass Core 軟體不會安裝為系統服務。若要執行軟體，請參閱 [在沒有系統服務的情況下執行 AWS IoT Greengrass Core 軟體](#run-greengrass-core-no-system-service)。
------
#### [ Windows Command Prompt (CMD) ]
```
sc query greengrass
```
如果 AWS IoT Greengrass Core 軟體安裝為 Windows 服務且處於作用中狀態，則回應看起來與下列範例類似。
```
SERVICE_NAME: greengrass
TYPE : 10 WIN32_OWN_PROCESS
STATE : 4 RUNNING
(STOPPABLE, NOT_PAUSABLE, ACCEPTS_SHUTDOWN)
WIN32_EXIT_CODE : 0 (0x0)
SERVICE_EXIT_CODE : 0 (0x0)
CHECKPOINT : 0x0
WAIT_HINT : 0x0
```
------
#### [ PowerShell ]
```
Get-Service greengrass
```
如果 AWS IoT Greengrass Core 軟體安裝為 Windows 服務且處於作用中狀態，則回應看起來與下列範例類似。
```
Status Name DisplayName
------ ---- -----------
Running greengrass greengrass
```
------
## 執行 AWS IoT Greengrass Core 軟體做為系統服務
如果 AWS IoT Greengrass Core 軟體已安裝為系統服務，您可以使用系統服務管理員來啟動、停止和管理軟體。如需詳細資訊，請參閱[將 Greengrass 核設定為系統服務](configure-greengrass-core-v2.md#configure-system-service)。
**執行 AWS IoT Greengrass 核心軟體**
+ 執行下列命令來啟動 AWS IoT Greengrass Core 軟體。
------
#### [ Linux or Unix (systemd) ]
```
sudo systemctl start greengrass.service
```
------
#### [ Windows Command Prompt (CMD) ]
```
sc start greengrass
```
------
#### [ PowerShell ]
```
Start-Service greengrass
```
------
## 在沒有系統服務的情況下執行 AWS IoT Greengrass Core 軟體
在 Linux 核心裝置上，如果 AWS IoT Greengrass Core 軟體未安裝為系統服務，您可以執行軟體的載入器指令碼來執行軟體。
**在沒有系統服務的情況下執行 AWS IoT Greengrass Core 軟體**
+ 執行下列命令來啟動 AWS IoT Greengrass Core 軟體。如果您在終端機中執行此命令，則必須保持終端機工作階段開啟，以保持 AWS IoT Greengrass 核心軟體的執行。
+ 以您使用的 Greengrass 根資料夾取代 `/greengrass/v2`或 *C：\$1greengrass\$1v2*。
```
sudo /greengrass/v2/alts/current/distro/bin/loader
```
如果成功啟動，軟體會列印下列訊息。
```
Launched Nucleus successfully.
```
# 在 Docker 容器中執行 AWS IoT Greengrass 核心軟體
AWS IoT Greengrass 可以設定為在 Docker 容器中執行。Docker 是一種平台，可為您提供工具來建置、執行、測試和部署以 Linux 容器為基礎的應用程式。當您執行 AWS IoT Greengrass Docker 映像時，您可以選擇是否要將 AWS 登入資料提供給 Docker 容器，並允許 AWS IoT Greengrass Core 軟體安裝程式自動佈建 AWS Greengrass 核心裝置操作所需的資源。如果您不想提供 AWS 登入資料，則可以手動佈建 AWS 資源，並在 Docker 容器中執行 AWS IoT Greengrass Core 軟體。
**Topics**
+ [支援平台和需求](#greengrass-docker-supported-platforms)
+ [軟體下載](#greengrass-docker-downloads)
+ [選擇如何佈建 AWS 資源](#greengrass-docker-resource-provisioning)
+ [從 Dockerfile 建置 AWS IoT Greengrass 映像](build-greengrass-dockerfile.md)
+ [使用自動佈建在 Docker AWS IoT Greengrass 中執行](run-greengrass-docker-automatic-provisioning.md)
+ [使用手動佈建在 Docker AWS IoT Greengrass 中執行](run-greengrass-docker-manual-provisioning.md)
+ [在 Docker AWS IoT Greengrass 容器中進行故障診斷](docker-troubleshooting.md)
## 支援平台和需求
主機電腦必須符合下列最低需求，才能在 Docker 容器中安裝和執行 AWS IoT Greengrass Core 軟體：
+ 具有網際網路連線的 Linux 作業系統。
+ [Docker 引擎](https://docs.docker.com/engine/install/) 18.09 版或更新版本。
+ （選用） [Docker Compose](https://docs.docker.com/compose/install/) 1.22 版或更新版本。只有在您想要使用 Docker Compose CLI 執行 Docker 映像時，才需要 Docker Compose。
若要在 Docker 容器內執行 Lambda 函數元件，您必須設定容器以符合其他需求。如需詳細資訊，請參閱[Lambda 函數需求](setting-up.md#greengrass-v2-lambda-requirements)。
### 在程序模式中執行元件
AWS IoT Greengrass 不支援在 Docker AWS容器內的隔離執行時間環境中執行 Lambda AWS IoT Greengrass 函數或提供的元件。您必須在沒有任何隔離的情況下，以程序模式執行這些元件。
當您設定 Lambda 函數元件時，請將隔離模式設定為**無容器**。如需詳細資訊，請參閱[執行 AWS Lambda 函數](run-lambda-functions.md)。
當您部署下列任何 AWS提供的元件時，請更新每個元件的組態，將 `containerMode` 參數設定為 `NoContainer`。如需組態更新的詳細資訊，請參閱 [更新元件組態](update-component-configurations.md)。
+ [CloudWatch 指標](cloudwatch-metrics-component.md)
+ [Device Defender](device-defender-component.md)
+ [Firehose](kinesis-firehose-component.md)
+ [Modbus-RTU 通訊協定轉接器](modbus-rtu-protocol-adapter-component.md)
+ [Amazon SNS](sns-component.md)
## AWS IoT Greengrass Docker 軟體下載
AWS IoT Greengrass 提供 Dockerfile 來建置容器映像，其具有安裝在 Amazon Linux 2 (x86\$164) 基礎映像上的 AWS IoT Greengrass 核心軟體和相依性。您可以修改 Dockerfile 中的基礎映像，以在不同的平台架構 AWS IoT Greengrass 上執行。
從 [GitHub](https://github.com/aws-greengrass/aws-greengrass-docker) 下載 Dockerfile 套件。
Dockerfile 使用較舊版本的 Greengrass。您應該更新 檔案，以使用您想要的 Greengrass 版本。如需從 Dockerfile 建置 AWS IoT Greengrass 容器映像的相關資訊，請參閱 [從 Dockerfile 建置 AWS IoT Greengrass 容器映像](build-greengrass-dockerfile.md)。
## 選擇如何佈建 AWS 資源
當您在 Docker 容器中安裝 AWS IoT Greengrass Core 軟體時，您可以選擇是否要自動佈建 Greengrass 核心裝置操作所需的 AWS 資源，還是使用您手動佈建的資源。
+ **自動資源佈建** - 當您第一次執行 AWS IoT Greengrass 容器映像時，安裝程式會佈建 AWS IoT 物件、 AWS IoT 物件群組、IAM 角色和 AWS IoT 角色別名。安裝程式也可以將本機開發工具部署到核心裝置，因此您可以使用裝置來開發和測試自訂軟體元件。若要自動佈建這些資源，您必須提供 AWS 登入資料做為 Docker 映像的環境變數。
若要使用自動佈建，您必須設定 Docker 環境變數`PROVISION=true`並掛載登入資料檔案，將登入資料提供給 AWS 容器。
+ **手動資源佈建** - 如果您不想提供 AWS 憑證給容器，則可以在 AWS 執行 AWS IoT Greengrass 容器映像之前手動佈建資源。您必須建立組態檔案，將這些資源的相關資訊提供給 Docker 容器中 AWS IoT Greengrass 的核心軟體安裝程式。
若要使用手動佈建，您必須設定 Docker 環境變數 `PROVISION=false`。手動佈建是預設選項。
如需詳細資訊，請參閱[從 Dockerfile 建置 AWS IoT Greengrass 容器映像](build-greengrass-dockerfile.md)。
# 從 Dockerfile 建置 AWS IoT Greengrass 容器映像
AWS 提供 Dockerfile，您可以下載並使用它在 Docker 容器中執行 AWS IoT Greengrass Core 軟體。Dockerfiles 包含用於建置 AWS IoT Greengrass 容器映像的原始碼。
在建置 AWS IoT Greengrass 容器映像之前，您必須設定 Dockerfile 以選取您要安裝 AWS IoT Greengrass 的核心軟體版本。您也可以設定環境變數，以選擇如何在安裝期間佈建資源，並自訂其他安裝選項。本節說明如何從 AWS IoT Greengrass Dockerfile 設定和建置 Docker 映像。
## 下載 Dockerfile 套件
您可以從 GitHub 下載 AWS IoT Greengrass Dockerfile 套件：
[AWS Greengrass Docker 儲存庫](https://github.com/aws-greengrass/aws-greengrass-docker)
下載套件之後，請將內容解壓縮到電腦上的 `download-directory/aws-greengrass-docker-nucleus-version` 資料夾。Dockerfile 使用較舊版本的 Greengrass。您應該更新 檔案，以使用您想要的 Greengrass 版本。
## 指定 AWS IoT Greengrass 核心軟體版本
在 Dockerfile 中使用下列建置引數，指定您要在 Docker AWS IoT Greengrass 映像中使用的 AWS IoT Greengrass Core 軟體版本。根據預設，Dockerfile 會使用最新版本的 AWS IoT Greengrass Core 軟體。
`GREENGRASS_RELEASE_VERSION`
Core AWS IoT Greengrass 軟體的版本。根據預設，Dockerfile 會下載 Greengrass 核的最新可用版本。將 值設定為您要下載的 nucleus 版本。
## 設定環境變數
環境變數可讓您自訂 AWS IoT Greengrass Core 軟體在 Docker 容器中的安裝方式。您可以透過各種方式設定 Docker AWS IoT Greengrass 映像的環境變數。
+ 若要使用相同的環境變數來建立多個映像，請直接在 Dockerfile 中設定環境變數。
+ 如果您使用 `docker run` 啟動容器，請在 命令中將環境變數做為引數傳遞，或在環境變數檔案中設定環境變數，然後將檔案做為引數傳遞。如需在 Docker 中設定環境變數的詳細資訊，請參閱 Docker 文件中的[環境變數](https://docs.docker.com/engine/reference/commandline/run/#env)。
+ 如果您使用 `docker-compose up` 啟動容器，請在環境變數檔案中設定環境變數，然後將檔案做為引數傳遞。如需在 Compose 中設定環境變數的詳細資訊，請參閱 [Docker 文件](https://docs.docker.com/compose/environment-variables/)。
您可以為 Docker AWS IoT Greengrass 映像設定下列環境變數。
**注意**
請勿修改 Dockerfile 中的`TINI_KILL_PROCESS_GROUP`變數。此變數允許轉送`SIGTERM`至 PIDs 群組中的所有 PID，以便在 Docker 容器停止時 AWS IoT Greengrass ，核心軟體可以正確關閉。
`GGC_ROOT_PATH`
（選用） 容器內資料夾的路徑，做為 AWS IoT Greengrass Core 軟體的根目錄。
預設：`/greengrass/v2`
`PROVISION`
（選用） 判斷 AWS IoT Greengrass 核心是否佈建 AWS 資源。
+ 如果您指定 `true`， AWS IoT Greengrass Core 軟體會將容器映像註冊為 AWS IoT 物件，並佈建 Greengrass 核心裝置所需的 AWS 資源。Core AWS IoT Greengrass 軟體會佈建 AWS IoT 物件、 （選用） AWS IoT 物件群組、IAM 角色和 AWS IoT 角色別名。如需詳細資訊，請參閱[AWS IoT Greengrass 在具有自動資源佈建的 Docker 容器中執行](run-greengrass-docker-automatic-provisioning.md)。
+ 如果您指定 `false`，則必須建立組態檔案，以提供給 AWS IoT Greengrass 核心安裝程式，指定 使用您手動建立 AWS 的資源和憑證。如需詳細資訊，請參閱[AWS IoT Greengrass 在具有手動資源佈建的 Docker 容器中執行](run-greengrass-docker-manual-provisioning.md)。
預設：`false`
`AWS_REGION`
（選用） AWS IoT Greengrass 核心軟體用來擷取或建立必要 AWS 資源 AWS 區域 的 。
預設：`us-east-1`。
`THING_NAME`
（選用） 您註冊為此核心裝置的 AWS IoT 物件名稱。如果您的 中不存在具有此名稱的物件 AWS 帳戶，則 AWS IoT Greengrass Core 軟體會建立它。
您必須指定 `PROVISION=true`才能套用此引數。
預設：`GreengrassV2IotThing_`加上隨機 UUID。
`THING_GROUP_NAME`
（選用） 您新增此核心裝置的 AWS IoT AWS IoT 物件群組名稱 如果部署以此物件群組為目標，則該群組中的此和其他核心裝置會在其連線時接收該部署 AWS IoT Greengrass。如果您的 中不存在具有此名稱的物件群組 AWS 帳戶，則 AWS IoT Greengrass Core 軟體會建立它。
您必須指定 `PROVISION=true`才能套用此引數。
`TES_ROLE_NAME`
（選用） IAM 角色的名稱，用來取得可讓 Greengrass 核心裝置與 AWS 服務互動的 AWS 登入資料。如果您的 中不存在具有此名稱的角色 AWS 帳戶，則 AWS IoT Greengrass Core 軟體會使用 `GreengrassV2TokenExchangeRoleAccess`政策建立該角色。此角色無法存取託管元件成品的 S3 儲存貯體。因此，您必須在建立元件時，將許可新增至成品的 S3 儲存貯體和物件。如需詳細資訊，請參閱[授權核心裝置與 AWS 服務互動](device-service-role.md)。
預設：`GreengrassV2TokenExchangeRole`
`TES_ROLE_ALIAS_NAME`
（選用） 指向為 Greengrass 核心裝置提供 AWS 登入資料之 IAM 角色 AWS IoT 的角色別名名稱。如果您的 中不存在具有此名稱的角色別名 AWS 帳戶，則 AWS IoT Greengrass Core 軟體會建立它，並將其指向您指定的 IAM 角色。
預設：`GreengrassV2TokenExchangeRoleAlias`
`COMPONENT_DEFAULT_USER`
（選用） AWS IoT Greengrass 核心軟體用來執行元件之系統使用者和群組的名稱或 ID。指定使用者和群組，以冒號分隔。群組為選用項目。例如，您可以指定 **ggc\$1user:ggc\$1group** 或 **ggc\$1user**。
+ 如果您以根身分執行，這會預設為組態檔案定義的使用者和群組。如果組態檔案未定義使用者和群組，則預設為 `ggc_user:ggc_group`。如果 `ggc_user`或`ggc_group`不存在，軟體會建立它們。
+ 如果您以非根使用者身分執行 ， AWS IoT Greengrass Core 軟體會使用該使用者來執行元件。
+ 如果您未指定群組，則 AWS IoT Greengrass Core 軟體會使用系統使用者的主要群組。
如需詳細資訊，請參閱[設定執行元件的使用者](configure-greengrass-core-v2.md#configure-component-user)。
`DEPLOY_DEV_TOOLS`
定義是否要在容器映像中下載和部署 [Greengrass CLI 元件](greengrass-cli-component.md)。您可以使用 Greengrass CLI 在本機開發和偵錯元件。
建議您僅在開發環境中使用此元件，而非生產環境中。此元件可讓您存取生產環境中通常不需要的資訊和操作。僅將此元件部署到您需要的核心裝置，以遵循最低權限原則。
預設：`false`
`INIT_CONFIG`
（選用） 用於安裝 AWS IoT Greengrass Core 軟體的組態檔案路徑。您可以使用此選項來設定具有特定核心組態的新 Greengrass 核心裝置，或指定手動佈建的資源，例如 。您必須將組態檔案掛載至您在此引數中指定的路徑。
`TRUSTED_PLUGIN`
此功能適用於 [Greengrass 核元件](greengrass-nucleus-component.md)的 v2.4.0 和更新版本。
（選用） 要載入為信任外掛程式的 JAR 檔案路徑。使用此選項提供佈建外掛程式 JAR 檔案，例如使用[機群佈建](fleet-provisioning.md)或[自訂佈建](custom-provisioning.md)安裝 。
`THING_POLICY_NAME`
此功能適用於 [Greengrass 核元件](greengrass-nucleus-component.md)的 v2.4.0 和更新版本。
（選用） 要連接到此核心裝置 AWS IoT 物件憑證 AWS IoT 的政策名稱。如果具有此名稱 AWS IoT 的政策不存在 AWS 帳戶 於您的 AWS IoT Greengrass Core 軟體中。
您必須指定 `PROVISION=true`才能套用此引數。
Core AWS IoT Greengrass 軟體預設會建立寬鬆 AWS IoT 政策。您可以縮小此政策的範圍，或建立自訂政策，以限制使用案例的許可。如需詳細資訊，請參閱[AWS IoT Greengrass V2 核心裝置的最低 AWS IoT 政策](device-auth.md#greengrass-core-minimal-iot-policy)。
## 指定要安裝的相依性
Dockerfile 中的 RUN AWS IoT Greengrass 指令會準備容器環境來執行 AWS IoT Greengrass Core 軟體安裝程式。您可以自訂 AWS IoT Greengrass Core 軟體安裝程式在 Docker 容器中執行之前安裝的相依性。
## 建置 AWS IoT Greengrass 映像
使用 AWS IoT Greengrass Dockerfile 建置 AWS IoT Greengrass 容器映像。您可以使用 Docker CLI 或 Docker Compose CLI 來建置映像並啟動容器。您也可以使用 Docker CLI 建置映像，然後使用 Docker Compose 從該映像啟動容器。
------
#### [ Docker ]
1. 在主機電腦上，執行下列命令來切換到包含已設定 Dockerfile 的目錄。
```
cd download-directory/aws-greengrass-docker-nucleus-version
```
1. 執行下列命令，從 Dockerfile 建置 AWS IoT Greengrass 容器映像。
```
sudo docker build -t "platform/aws-iot-greengrass:nucleus-version" ./
```
------
#### [ Docker Compose ]
1. 在主機電腦上，執行下列命令來切換到包含 Dockerfile 和 Compose 檔案的目錄。
```
cd download-directory/aws-greengrass-docker-nucleus-version
```
1. 執行下列命令，使用 Compose 檔案來建置 AWS IoT Greengrass 容器映像。
```
docker-compose -f docker-compose.yml build
```
------
您已成功建立 AWS IoT Greengrass 容器映像。Docker 映像檔已安裝 AWS IoT Greengrass 核心軟體。您現在可以在 Docker 容器中執行 AWS IoT Greengrass Core 軟體。
# AWS IoT Greengrass 在具有自動資源佈建的 Docker 容器中執行
本教學課程說明如何使用自動佈建 AWS 的資源和本機開發工具，在 Docker 容器中安裝和執行 AWS IoT Greengrass Core 軟體。您可以使用此開發環境來探索 Docker 容器中 AWS IoT Greengrass 的功能。軟體需要 AWS 登入資料才能佈建這些資源並部署本機開發工具。
如果您無法提供 AWS 登入資料給容器，您可以佈建 AWS 核心裝置操作所需的資源。您也可以將開發工具部署到核心裝置，以用作開發裝置。這可讓您在執行容器時為裝置提供較少的許可。如需詳細資訊，請參閱[AWS IoT Greengrass 在具有手動資源佈建的 Docker 容器中執行](run-greengrass-docker-manual-provisioning.md)。
## 先決條件
若要完成本教學課程，您需要下列項目。
+ AWS 帳戶。如果您沒有帳戶，請參閱 [設定 AWS 帳戶](setting-up.md#set-up-aws-account)。
+ 具有為 Greengrass AWS 核心裝置佈建 AWS IoT 和 IAM 資源許可的 IAM 使用者。Core AWS IoT Greengrass 軟體安裝程式使用您的 AWS 登入資料來自動佈建這些資源。如需自動佈建資源的最低 IAM 政策資訊，請參閱 [安裝程式佈建資源的最低 IAM 政策](provision-minimal-iam-policy.md)。
+ Docker AWS IoT Greengrass 映像。您可以從 [Dockerfile AWS IoT Greengrass 建置映像](build-greengrass-dockerfile.md)。
+ 您執行 Docker 容器的主機電腦必須符合下列要求：
+ 具有網際網路連線的 Linux 作業系統。
+ [Docker 引擎](https://docs.docker.com/engine/install/) 18.09 版或更新版本。
+ （選用） [Docker Compose](https://docs.docker.com/compose/install/) 1.22 版或更新版本。只有在您想要使用 Docker Compose CLI 執行 Docker 映像時，才需要 Docker Compose。
## 設定您的 AWS 登入資料
在此步驟中，您會在包含安全 AWS 登入資料的主機電腦上建立登入資料檔案。當您執行 AWS IoT Greengrass Docker 映像時，您必須在 Docker 容器中將包含此登入資料檔案的資料夾掛載至 `/root/.aws/` 。 AWS IoT Greengrass 安裝程式使用這些登入資料來佈建 中的資源 AWS 帳戶。如需安裝程式自動佈建資源所需的最低 IAM 政策的相關資訊，請參閱 [安裝程式佈建資源的最低 IAM 政策](provision-minimal-iam-policy.md)。
1. 擷取下列其中一項。
+ IAM 使用者的長期登入資料。如需如何擷取長期憑證的資訊，請參閱《[IAM 使用者指南》中的管理 IAM 使用者的存取金鑰](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html)。 **
+ （建議） IAM 角色的暫時登入資料。如需如何擷取臨時登入資料的資訊，請參閱《*IAM 使用者指南*》中的[搭配 使用臨時安全登入 AWS CLI](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html#using-temp-creds-sdk-cli)資料。
1. 建立放置登入資料檔案的資料夾。
```
mkdir ./greengrass-v2-credentials
```
1. 使用文字編輯器在 `./greengrass-v2-credentials` 資料夾中建立名為 `credentials`的組態檔案。
例如，您可以執行下列命令，使用 GNU nano 建立 `credentials` 檔案。
```
nano ./greengrass-v2-credentials/credentials
```
1. 以下列格式將您的 AWS 登入資料新增至 `credentials` 檔案。
```
[default]
aws_access_key_id = AKIAIOSFODNN7EXAMPLE
aws_secret_access_key = wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
aws_session_token = AQoEXAMPLEH4aoAH0gNCAPy...truncated...zrkuWJOgQs8IZZaIv2BXIa2R4Olgk
```
僅包含`aws_session_token`暫時登入資料。
**重要**
啟動 AWS IoT Greengrass 容器後，請從主機電腦移除登入資料檔案。如果您不移除登入資料檔案，您的 AWS 登入資料將保持掛載在容器內。如需詳細資訊，請參閱[在容器中執行 AWS IoT Greengrass 核心軟體](#run-greengrass-image-automatic-provisioning)。
## 建立環境檔案
本教學課程使用環境檔案來設定將傳遞至 Docker 容器內 AWS IoT Greengrass Core 軟體安裝程式的環境變數。您也可以在`docker run`命令中使用 [`-e`或 `--env`引數](https://docs.docker.com/engine/reference/commandline/run/#env)，在 Docker 容器中設定環境變數，也可以在 `docker-compose.yml` 檔案的 [`environment`區塊](https://docs.docker.com/compose/compose-file/compose-file-v3/#environment)中設定變數。
1. 使用文字編輯器來建立名為 的環境檔案`.env`。
例如，在以 Linux 為基礎的系統上，您可以執行下列命令，使用 GNU nano `.env` 在目前的目錄中建立 。
```
nano .env
```
1. 將下列內容複製到 檔案。
```
GGC_ROOT_PATH=/greengrass/v2
AWS_REGION=region
PROVISION=true
THING_NAME=MyGreengrassCore
THING_GROUP_NAME=MyGreengrassCoreGroup
TES_ROLE_NAME=GreengrassV2TokenExchangeRole
TES_ROLE_ALIAS_NAME=GreengrassCoreTokenExchangeRoleAlias
COMPONENT_DEFAULT_USER=ggc_user:ggc_group
```
然後，取代下列值。
+ `/greengrass/v2`。 您要用於安裝的 Greengrass 根資料夾。您可以使用 `GGC_ROOT`環境變數來設定此值。
+ *區域*。您建立資源 AWS 區域 的 。
+ *MyGreengrassCore*。物件的名稱 AWS IoT 。如果物件不存在，安裝程式會建立它。安裝程式會下載憑證以驗證為 AWS IoT 實物。
+ *MyGreengrassCoreGroup*。 AWS IoT 物件群組的名稱。如果物件群組不存在，安裝程式會建立它，並將該物件新增至其中。如果物件群組存在且具有作用中部署，核心裝置會下載並執行部署指定的軟體。
+ *GreengrassV2TokenExchangeRole*。以允許 Greengrass 核心裝置取得臨時 AWS 登入資料的 IAM 字符交換角色名稱取代 。如果角色不存在，安裝程式會建立它，並建立和連接名為 *GreengrassV2TokenExchangeRole* Access 的政策。如需詳細資訊，請參閱[授權核心裝置與 AWS 服務互動](device-service-role.md)。
+ *GreengrassCoreTokenExchangeRoleAlias*。字符交換角色別名。如果角色別名不存在，安裝程式會建立它，並將其指向您指定的 IAM 字符交換角色。如需詳細資訊，請參閱
**注意**
您可以將`DEPLOY_DEV_TOOLS`環境變數設定為 `true`以部署 [Greengrass CLI 元件](greengrass-cli-component.md)，這可讓您在 Docker 容器內開發自訂元件。建議您僅在開發環境中使用此元件，而非生產環境中。此元件可讓您存取生產環境中通常不需要的資訊和操作。僅將此元件部署到您需要的核心裝置，以遵循最低權限原則。
## 在容器中執行 AWS IoT Greengrass 核心軟體
本教學課程說明如何啟動您在 Docker 容器中建置的 Docker 映像。您可以使用 Docker CLI 或 Docker Compose CLI 在 Docker 容器中執行 AWS IoT Greengrass 核心軟體映像。
------
#### [ Docker ]
1. 執行下列命令來啟動 Docker 容器。
```
docker run --rm --init -it --name docker-image \
-v path/to/greengrass-v2-credentials:/root/.aws/:ro \
--env-file .env \
-p 8883 \
your-container-image:version
```
此範例命令使用下列引數來執行 [docker：](https://docs.docker.com/engine/reference/commandline/run/)
+ [https://docs.docker.com/engine/reference/run/#clean-up---rm](https://docs.docker.com/engine/reference/run/#clean-up---rm)。 在容器結束時清除容器。
+ [https://docs.docker.com/engine/reference/run/#specify-an-init-process](https://docs.docker.com/engine/reference/run/#specify-an-init-process)。 在容器中使用初始化程序。
**注意**
當您停止 Docker 容器時，需要 `--init`引數來關閉 AWS IoT Greengrass Core 軟體。
+ [https://docs.docker.com/engine/reference/run/#foreground](https://docs.docker.com/engine/reference/run/#foreground)。 （選用） 在前景中以互動式程序執行 Docker 容器。您可以使用 `-d`引數取代此值，以分離模式執行 Docker 容器。如需詳細資訊，請參閱 Docker 文件中的[分離與前景](https://docs.docker.com/engine/reference/run/#detached-vs-foreground)。
+ [https://docs.docker.com/engine/reference/run/#name---name](https://docs.docker.com/engine/reference/run/#name---name)。 執行名為 的容器 `aws-iot-greengrass`
+ [https://docs.docker.com/storage/volumes/](https://docs.docker.com/storage/volumes/)。 將磁碟區掛載到 Docker 容器，讓組態檔案和憑證檔案可供容器內 AWS IoT Greengrass 執行。
+ [https://docs.docker.com/engine/reference/commandline/run/#env](https://docs.docker.com/engine/reference/commandline/run/#env)。 （選用） 指定環境檔案，以設定要傳遞至 Docker 容器內 AWS IoT Greengrass Core 軟體安裝程式的環境變數。只有在您建立[環境檔案](run-greengrass-docker-manual-provisioning.md#create-env-file-manual-provisioning)來設定環境變數時，才需要此引數。如果您未建立環境檔案，您可以使用`--env`引數直接在 Docker 執行命令中設定環境變數。
+ [https://docs.docker.com/engine/reference/commandline/run/#publish](https://docs.docker.com/engine/reference/commandline/run/#publish)。 （選用） 將 8883 容器連接埠發佈至主機。如果您想要透過 MQTT 連接和通訊，則需要此引數，因為 AWS IoT Greengrass 使用連接埠 8883 處理 MQTT 流量。若要開啟其他連接埠，請使用其他引`-p`數。
**注意**
若要以更高的安全性執行 Docker 容器，您可以使用 `--cap-drop`和 `--cap-add`引數來選擇性地為您的容器啟用 Linux 功能。如需詳細資訊，請參閱 Docker 文件中的[執行期權限和 Linux 功能](https://docs.docker.com/engine/reference/run/#runtime-privilege-and-linux-capabilities)。
1. 在主機裝置`./greengrass-v2-credentials`上從 移除登入資料。
```
rm -rf ./greengrass-v2-credentials
```
**重要**
您正在移除這些登入資料，因為它們提供核心裝置只在設定期間需要的廣泛許可。如果您未移除這些登入資料，Greengrass 元件和容器中執行的其他程序可以存取這些登入資料。如果您需要提供 AWS 憑證給 Greengrass 元件，請使用字符交換服務。如需詳細資訊，請參閱[與 AWS 服務互動](interact-with-aws-services.md)。
------
#### [ Docker Compose ]
1. 使用文字編輯器來建立名為 的 Docker Compose 檔案`docker-compose.yml`。
例如，在以 Linux 為基礎的系統上，您可以執行下列命令，使用 GNU nano `docker-compose.yml` 在目前的目錄中建立 。
```
nano docker-compose.yml
```
**注意**
您也可以從 [GitHub](https://github.com/aws-greengrass/aws-greengrass-docker/releases/) 下載並使用 AWS最新版本的 Compose 檔案。
1. 將下列內容新增至 Compose 檔案。您的檔案看起來應該如下列範例：將 *docker-image* 取代為 Docker 映像的名稱。
```
version: '3.7'
services:
greengrass:
init: true
container_name: aws-iot-greengrass
image: docker-image
volumes:
- ./greengrass-v2-credentials:/root/.aws/:ro
env_file: .env
ports:
- "8883:8883"
```
此範例中的下列參數 Compose 檔案為選用：
+ `ports`—發佈 8883 容器連接埠至主機。如果您想要透過 MQTT 連接和通訊，則需要此參數，因為 AWS IoT Greengrass 使用連接埠 8883 處理 MQTT 流量。
+ `env_file`- 指定環境檔案，以設定將傳遞至 Docker 容器內 AWS IoT Greengrass Core 軟體安裝程式的環境變數。只有在您建立[環境檔案](run-greengrass-docker-manual-provisioning.md#create-env-file-manual-provisioning)來設定環境變數時，才需要此參數。如果您未建立環境檔案，您可以使用[環境](https://docs.docker.com/compose/compose-file/compose-file-v3/#environment)參數直接在 Compose 檔案中設定變數。
**注意**
若要以更高的安全性執行 Docker 容器，您可以在 `cap_add` Compose 檔案中使用 `cap_drop`和 ，為您的容器選擇性地啟用 Linux 功能。如需詳細資訊，請參閱 Docker 文件中的[執行期權限和 Linux 功能](https://docs.docker.com/engine/reference/run/#runtime-privilege-and-linux-capabilities)。
1. 執行下列命令來啟動 Docker 容器。
```
docker-compose -f docker-compose.yml up
```
1. 在主機裝置`./greengrass-v2-credentials`上從 移除登入資料。
```
rm -rf ./greengrass-v2-credentials
```
**重要**
您正在移除這些登入資料，因為它們提供核心裝置只在設定期間需要的廣泛許可。如果您未移除這些登入資料，Greengrass 元件和容器中執行的其他程序可以存取這些登入資料。如果您需要提供 AWS 憑證給 Greengrass 元件，請使用字符交換服務。如需詳細資訊，請參閱[與 AWS 服務互動](interact-with-aws-services.md)。
------
## 後續步驟
AWS IoT Greengrass 核心軟體現在正在 Docker 容器中執行。執行下列命令，以擷取目前執行中容器的容器 ID。
```
docker ps
```
然後，您可以執行下列命令來存取容器，並探索在容器內執行 AWS IoT Greengrass 的核心軟體。
```
docker exec -it container-id /bin/bash
```
如需建立簡單元件的詳細資訊，請參閱 [步驟 4：在您的裝置上開發和測試元件](create-first-component.md)中的 [教學課程：入門 AWS IoT Greengrass V2](getting-started.md)
**注意**
當您使用 在 Docker 容器內`docker exec`執行命令時，這些命令不會記錄在 Docker 日誌中。若要在 Docker 日誌中記錄命令，請將互動式 shell 連接到 Docker 容器。如需詳細資訊，請參閱[將互動式 shell 連接至 Docker 容器](docker-troubleshooting.md#debugging-docker-attach-shell)。
AWS IoT Greengrass 核心日誌檔案稱為 `greengrass.log`，位於 中`/greengrass/v2/logs`。元件日誌檔案也位於相同的目錄中。若要將 Greengrass 日誌複製到主機上的暫存目錄，請執行下列命令：
```
docker cp container-id:/greengrass/v2/logs /tmp/logs
```
如果您想要在容器結束或移除後保留日誌，建議您僅將`/greengrass/v2/logs`目錄繫結至主機上的暫存日誌目錄，而不是掛載整個 Greengrass 目錄。如需詳細資訊，請參閱[在 Docker 容器外保留 Greengrass 日誌](docker-troubleshooting.md#debugging-docker-persist-logs)。
若要停止執行中的 AWS IoT Greengrass Docker 容器，請執行 `docker stop`或 `docker-compose -f docker-compose.yml stop`。此動作會`SIGTERM`傳送至 Greengrass 程序，並關閉在容器中啟動的所有相關程序。Docker 容器會使用`docker-init`可執行檔初始化為程序 PID 1，這有助於移除任何剩餘的殭屍程序。如需詳細資訊，請參閱 Docker 文件中的[指定初始化程序](https://docs.docker.com/engine/reference/run/#specify-an-init-process)。
如需對 AWS IoT Greengrass 在 Docker 容器中執行 的問題進行故障診斷的資訊，請參閱 [在 Docker AWS IoT Greengrass 容器中進行故障診斷](docker-troubleshooting.md)。
# AWS IoT Greengrass 在具有手動資源佈建的 Docker 容器中執行
本教學課程說明如何使用手動佈建 AWS 的資源，在 Docker 容器中安裝和執行 AWS IoT Greengrass 核心軟體。
**Topics**
+ [先決條件](#docker-manual-provisioning-prereqs)
+ [擷取 AWS IoT 端點](#retrieve-iot-endpoints)
+ [建立 AWS IoT 物件](#create-iot-thing)
+ [建立物件憑證](#create-thing-certificate-mp)
+ [建立權杖交換角色](#create-token-exchange-role)
+ [將憑證下載至裝置](#download-thing-certificates)
+ [建立組態檔案](#create-docker-install-configuration-file)
+ [建立環境檔案](#create-env-file-manual-provisioning)
+ [在容器中執行 AWS IoT Greengrass 核心軟體](#run-greengrass-image-manual-provisioning)
+ [後續步驟](#run-greengrass-docker-next-steps)
## 先決條件
為了完成本教學，您需要以下項目：
+ AWS 帳戶。如果您沒有帳戶，請參閱 [設定 AWS 帳戶](setting-up.md#set-up-aws-account)。
+ Docker AWS IoT Greengrass 映像。您可以從 [Dockerfile AWS IoT Greengrass 建置映像](build-greengrass-dockerfile.md)。
+ 您執行 Docker 容器的主機電腦必須符合下列要求：
+ 具有網際網路連線的 Linux 作業系統。
+ [Docker 引擎](https://docs.docker.com/engine/install/) 18.09 版或更新版本。
+ （選用） [Docker Compose](https://docs.docker.com/compose/install/) 1.22 版或更新版本。只有在您想要使用 Docker Compose CLI 執行 Docker 映像時，才需要 Docker Compose。
## 擷取 AWS IoT 端點
取得 的 AWS IoT 端點 AWS 帳戶，並儲存它們以供稍後使用。您的裝置使用這些端點來連線 AWS IoT。請執行下列操作：
1. 取得 AWS IoT 的資料端點 AWS 帳戶。
```
aws iot describe-endpoint --endpoint-type iot:Data-ATS
```
如果請求成功，回應看起來與下列範例類似。
```
{
"endpointAddress": "device-data-prefix-ats.iot.us-west-2.amazonaws.com"
}
```
1. 取得 的 AWS IoT 登入資料端點 AWS 帳戶。
```
aws iot describe-endpoint --endpoint-type iot:CredentialProvider
```
如果請求成功，回應看起來與下列範例類似。
```
{
"endpointAddress": "device-credentials-prefix.credentials.iot.us-west-2.amazonaws.com"
}
```
## 建立 AWS IoT 物件
AWS IoT *物件*代表連線至 的裝置和邏輯實體 AWS IoT。Greengrass 核心裝置是 AWS IoT 實物。當您將裝置註冊為 AWS IoT 物件時，該裝置可以使用數位憑證進行身分驗證 AWS。
在本節中，您會建立代表裝置的 AWS IoT 物件。
**建立 AWS IoT 物件**
1. 為您的裝置建立 AWS IoT 物件。在您的開發電腦上，執行下列命令。
+ 將 *MyGreengrassCore* 取代為要使用的物件名稱。此名稱也是 Greengrass 核心裝置的名稱。
**注意**
物件名稱不能包含冒號 (`:`) 字元。
```
aws iot create-thing --thing-name MyGreengrassCore
```
如果請求成功，回應看起來與下列範例類似。
```
{
"thingName": "MyGreengrassCore",
"thingArn": "arn:aws:iot:us-west-2:123456789012:thing/MyGreengrassCore",
"thingId": "8cb4b6cd-268e-495d-b5b9-1713d71dbf42"
}
```
1. （選用） 將 AWS IoT 物件新增至新的或現有的物件群組。您可以使用物件群組來管理 Greengrass 核心裝置的機群。將軟體元件部署至裝置時，您可以將個別裝置或裝置群組設為目標。您可以將裝置新增至具有作用中 Greengrass 部署的物件群組，以將該物件群組的軟體元件部署到裝置。請執行下列操作：
1. （選用） 建立 AWS IoT 物件群組。
+ 將 *MyGreengrassCoreGroup* 取代為要建立的物件群組名稱。
**注意**
物件群組名稱不能包含冒號 (`:`) 字元。
```
aws iot create-thing-group --thing-group-name MyGreengrassCoreGroup
```
如果請求成功，回應看起來與下列範例類似。
```
{
"thingGroupName": "MyGreengrassCoreGroup",
"thingGroupArn": "arn:aws:iot:us-west-2:123456789012:thinggroup/MyGreengrassCoreGroup",
"thingGroupId": "4df721e1-ff9f-4f97-92dd-02db4e3f03aa"
}
```
1. 將 AWS IoT 物件新增至物件群組。
+ 將 *MyGreengrassCore* 取代為您的 AWS IoT 物件名稱。
+ 將 *MyGreengrassCoreGroup* 取代為物件群組的名稱。
```
aws iot add-thing-to-thing-group --thing-name MyGreengrassCore --thing-group-name MyGreengrassCoreGroup
```
如果請求成功，命令不會有任何輸出。
## 建立物件憑證
當您將裝置註冊為 AWS IoT 物件時，該裝置可以使用數位憑證進行身分驗證 AWS。此憑證可讓裝置與 AWS IoT 和 通訊 AWS IoT Greengrass。
在本節中，您可以建立和下載裝置可用來連線的憑證 AWS。
**建立物件憑證**
1. 建立資料夾以下載 AWS IoT 物件的憑證。
```
mkdir greengrass-v2-certs
```
1. 建立並下載 AWS IoT 物件的憑證。
```
aws iot create-keys-and-certificate --set-as-active --certificate-pem-outfile greengrass-v2-certs/device.pem.crt --public-key-outfile greengrass-v2-certs/public.pem.key --private-key-outfile greengrass-v2-certs/private.pem.key
```
如果請求成功，回應看起來與下列範例類似。
```
{
"certificateArn": "arn:aws:iot:us-west-2:123456789012:cert/aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4",
"certificateId": "aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4",
"certificatePem": "-----BEGIN CERTIFICATE-----
MIICiTCCAfICCQD6m7oRw0uXOjANBgkqhkiG9w
0BAQUFADCBiDELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAldBMRAwDgYDVQQHEwdTZ
WF0dGxlMQ8wDQYDVQQKEwZBbWF6b24xFDASBgNVBAsTC0lBTSBDb25zb2xlMRIw
EAYDVQQDEwlUZXN0Q2lsYWMxHzAdBgkqhkiG9w0BCQEWEG5vb25lQGFtYXpvbi5
jb20wHhcNMTEwNDI1MjA0NTIxWhcNMTIwNDI0MjA0NTIxWjCBiDELMAkGA1UEBh
MCVVMxCzAJBgNVBAgTAldBMRAwDgYDVQQHEwdTZWF0dGxlMQ8wDQYDVQQKEwZBb
WF6b24xFDASBgNVBAsTC0lBTSBDb25zb2xlMRIwEAYDVQQDEwlUZXN0Q2lsYWMx
HzAdBgkqhkiG9w0BCQEWEG5vb25lQGFtYXpvbi5jb20wgZ8wDQYJKoZIhvcNAQE
BBQADgY0AMIGJAoGBAMaK0dn+a4GmWIWJ21uUSfwfEvySWtC2XADZ4nB+BLYgVI
k60CpiwsZ3G93vUEIO3IyNoH/f0wYK8m9TrDHudUZg3qX4waLG5M43q7Wgc/MbQ
ITxOUSQv7c7ugFFDzQGBzZswY6786m86gpEIbb3OhjZnzcvQAaRHhdlQWIMm2nr
AgMBAAEwDQYJKoZIhvcNAQEFBQADgYEAtCu4nUhVVxYUntneD9+h8Mg9q6q+auN
KyExzyLwaxlAoo7TJHidbtS4J5iNmZgXL0FkbFFBjvSfpJIlJ00zbhNYS5f6Guo
EDmFJl0ZxBHjJnyp378OD8uTs7fLvjx79LjSTbNYiytVbZPQUQ5Yaxu2jXnimvw
3rrszlaEXAMPLE=
-----END CERTIFICATE-----",
"keyPair": {
"PublicKey": "-----BEGIN PUBLIC KEY-----\
MIIBIjANBgkqhkEXAMPLEQEFAAOCAQ8AMIIBCgKCAQEAEXAMPLE1nnyJwKSMHw4h\
MMEXAMPLEuuN/dMAS3fyce8DW/4+EXAMPLEyjmoF/YVF/gHr99VEEXAMPLE5VF13\
59VK7cEXAMPLE67GK+y+jikqXOgHh/xJTwo+sGpWEXAMPLEDz18xOd2ka4tCzuWEXAMPLEahJbYkCPUBSU8opVkR7qkEXAMPLE1DR6sx2HocliOOLtu6Fkw91swQWEXAMPLE\\GB3ZPrNh0PzQYvjUStZeccyNCx2EXAMPLEvp9mQOUXP6plfgxwKRX2fEXAMPLEDa\
hJLXkX3rHU2xbxJSq7D+XEXAMPLEcw+LyFhI5mgFRl88eGdsAEXAMPLElnI9EesG\
FQIDAQAB\
-----END PUBLIC KEY-----\
",
"PrivateKey": "-----BEGIN RSA PRIVATE KEY-----\
key omitted for security reasons\
-----END RSA PRIVATE KEY-----\
"
}
}
```
儲存憑證的 Amazon Resource Name (ARN)，以供稍後用於設定憑證。
接著，設定物件憑證。如需詳細資訊，請參閱[設定物件憑證](manual-installation.md#configure-thing-certificate)。
## 建立權杖交換角色
Greengrass 核心裝置使用稱為*字符交換角色的 IAM 服務角色*來授權呼叫 AWS 服務。裝置使用 AWS IoT 登入資料提供者取得此角色的臨時 AWS 登入資料，允許裝置與 互動 AWS IoT、將日誌傳送至 Amazon CloudWatch Logs，以及從 Amazon S3 下載自訂元件成品。如需詳細資訊，請參閱[授權核心裝置與 AWS 服務互動](device-service-role.md)。
您可以使用 AWS IoT *角色別名*來設定 Greengrass 核心裝置的字符交換角色。角色別名可讓您變更裝置的字符交換角色，但讓裝置組態保持不變。如需詳細資訊，請參閱《 *AWS IoT Core 開發人員指南*》中的[授權直接呼叫 AWS 服務](https://docs.aws.amazon.com/iot/latest/developerguide/authorizing-direct-aws.html)。
在本節中，您會建立權杖交換 IAM 角色和指向角色 AWS IoT 的角色別名。如果您已經設定 Greengrass 核心裝置，您可以使用其權杖交換角色和角色別名，而不是建立新的權杖交換角色和角色別名。然後，您將裝置的 AWS IoT 物件設定為使用該角色和別名。
**建立權杖交換 IAM 角色**
1. 建立您的裝置可用作字符交換角色的 IAM 角色。請執行下列操作：
1. 建立檔案，其中包含權杖交換角色所需的信任政策文件。
例如，在以 Linux 為基礎的系統上，您可以執行下列命令來使用 GNU nano 來建立 檔案。
```
nano device-role-trust-policy.json
```
將下列 JSON 複製到 檔案。
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "credentials.iot.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
1. 使用信任政策文件建立權杖交換角色。
+ 將 *GreengrassV2TokenExchangeRole* 取代為要建立的 IAM 角色名稱。
```
aws iam create-role --role-name GreengrassV2TokenExchangeRole --assume-role-policy-document file://device-role-trust-policy.json
```
如果請求成功，回應看起來與下列範例類似。
```
{
"Role": {
"Path": "/",
"RoleName": "GreengrassV2TokenExchangeRole",
"RoleId": "AROAZ2YMUHYHK5OKM77FB",
"Arn": "arn:aws:iam::123456789012:role/GreengrassV2TokenExchangeRole",
"CreateDate": "2021-02-06T00:13:29+00:00",
"AssumeRolePolicyDocument": {
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "credentials.iot.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
}
```
1. 建立檔案，其中包含權杖交換角色所需的存取政策文件。
例如，在以 Linux 為基礎的系統上，您可以執行下列命令來使用 GNU nano 來建立 檔案。
```
nano device-role-access-policy.json
```
將下列 JSON 複製到 檔案。
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents",
"logs:DescribeLogStreams",
"s3:GetBucketLocation"
],
"Resource": "*"
}
]
}
```
**注意**
此存取政策不允許存取 S3 儲存貯體中的元件成品。若要在 Amazon S3 中部署定義成品的自訂元件，您必須將許可新增至角色，以允許核心裝置擷取元件成品。如需詳細資訊，請參閱[允許存取元件成品的 S3 儲存貯體](device-service-role.md#device-service-role-access-s3-bucket)。
如果您還沒有元件成品的 S3 儲存貯體，您可以在建立儲存貯體之後新增這些許可。
1. 從政策文件中建立 IAM 政策。
+ 以要建立的 IAM 政策名稱取代 *GreengrassV2TokenExchangeRoleAccess*。
```
aws iam create-policy --policy-name GreengrassV2TokenExchangeRoleAccess --policy-document file://device-role-access-policy.json
```
如果請求成功，回應看起來與下列範例類似。
```
{
"Policy": {
"PolicyName": "GreengrassV2TokenExchangeRoleAccess",
"PolicyId": "ANPAZ2YMUHYHACI7C5Z66",
"Arn": "arn:aws:iam::123456789012:policy/GreengrassV2TokenExchangeRoleAccess",
"Path": "/",
"DefaultVersionId": "v1",
"AttachmentCount": 0,
"PermissionsBoundaryUsageCount": 0,
"IsAttachable": true,
"CreateDate": "2021-02-06T00:37:17+00:00",
"UpdateDate": "2021-02-06T00:37:17+00:00"
}
}
```
1. 將 IAM 政策連接至字符交換角色。
+ 將 *GreengrassV2TokenExchangeRole* 取代為 IAM 角色的名稱。
+ 將政策 ARN 取代為您在上一個步驟中建立的 IAM 政策 ARN。
```
aws iam attach-role-policy --role-name GreengrassV2TokenExchangeRole --policy-arn arn:aws:iam::123456789012:policy/GreengrassV2TokenExchangeRoleAccess
```
如果請求成功，命令不會有任何輸出。
1. 建立指向字符交換 AWS IoT 角色的角色別名。
+ 以要建立的角色別名名稱取代 *GreengrassCoreTokenExchangeRoleAlias*。
+ 將角色 ARN 取代為您在上一個步驟中建立之 IAM 角色的 ARN。
```
aws iot create-role-alias --role-alias GreengrassCoreTokenExchangeRoleAlias --role-arn arn:aws:iam::123456789012:role/GreengrassV2TokenExchangeRole
```
如果請求成功，回應看起來與下列範例類似。
```
{
"roleAlias": "GreengrassCoreTokenExchangeRoleAlias",
"roleAliasArn": "arn:aws:iot:us-west-2:123456789012:rolealias/GreengrassCoreTokenExchangeRoleAlias"
}
```
**注意**
若要建立角色別名，您必須具有將字符交換 IAM 角色傳遞至 的許可 AWS IoT。如果您在嘗試建立角色別名時收到錯誤訊息，請檢查您的 AWS 使用者是否具有此許可。如需詳細資訊，請參閱*AWS Identity and Access Management 《 使用者指南*》中的[授予使用者將角色傳遞至 AWS 服務的許可](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_passrole.html)。
1. 建立並連接允許 Greengrass 核心裝置使用角色別名來擔任字符交換角色 AWS IoT 的政策。如果您之前已設定 Greengrass 核心裝置，您可以連接其角色別名 AWS IoT 政策，而不是建立新的。請執行下列操作：
1. （選用） 建立檔案，其中包含角色別名所需的 AWS IoT 政策文件。
例如，在以 Linux 為基礎的系統上，您可以執行下列命令來使用 GNU nano 來建立 檔案。
```
nano greengrass-v2-iot-role-alias-policy.json
```
將下列 JSON 複製到 檔案。
+ 使用角色別名的 ARN 取代資源 ARN。
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "iot:AssumeRoleWithCertificate",
"Resource": "arn:aws:iot:us-west-2:123456789012:rolealias/GreengrassCoreTokenExchangeRoleAlias"
}
]
}
```
1. 從 AWS IoT 政策文件中建立政策。
+ 將 *GreengrassCoreTokenExchangeRoleAliasPolicy* 取代為要建立 AWS IoT 的政策名稱。
```
aws iot create-policy --policy-name GreengrassCoreTokenExchangeRoleAliasPolicy --policy-document file://greengrass-v2-iot-role-alias-policy.json
```
如果請求成功，回應看起來與下列範例類似。
```
{
"policyName": "GreengrassCoreTokenExchangeRoleAliasPolicy",
"policyArn": "arn:aws:iot:us-west-2:123456789012:policy/GreengrassCoreTokenExchangeRoleAliasPolicy",
"policyDocument": "{
\\"Version\\":\\"2012-10-17 \\",
\\"Statement\\": [
{
\\"Effect\\": \\"Allow\\",
\\"Action\\": \\"iot:AssumeRoleWithCertificate\\",
\\"Resource\\": \\"arn:aws:iot:us-west-2:123456789012:rolealias/GreengrassCoreTokenExchangeRoleAlias\\"
}
]
}",
"policyVersionId": "1"
}
```
1. 將 AWS IoT 政策連接至 AWS IoT 物件的憑證。
+ 以角色別名 AWS IoT 政策的名稱取代 *GreengrassCoreTokenExchangeRoleAliasPolicy*。
+ 將目標 ARN 取代為物件 AWS IoT 憑證的 ARN。
```
aws iot attach-policy --policy-name GreengrassCoreTokenExchangeRoleAliasPolicy --target arn:aws:iot:us-west-2:123456789012:cert/aa0b7958770878eabe251d8a7ddd547f4889c524c9b574ab9fbf65f32248b1d4
```
如果請求成功，命令不會有任何輸出。
## 將憑證下載至裝置
先前，您已將裝置的憑證下載到開發電腦。在本節中，您會下載 Amazon 根憑證授權機構 (CA) 憑證。然後，如果您計劃在開發電腦以外的電腦上在 Docker 中執行 AWS IoT Greengrass Core 軟體，您可以將憑證複製到該主機電腦。Core AWS IoT Greengrass 軟體使用這些憑證來連線至 AWS IoT 雲端服務。
**將憑證下載至裝置**
1. 在您的開發電腦上，下載 Amazon 根憑證授權機構 (CA) certificate. AWS IoT certificates 預設會與 Amazon 根憑證授權機構憑證相關聯。
------
#### [ Linux or Unix ]
```
sudo curl -o ./greengrass-v2-certs/AmazonRootCA1.pem https://www.amazontrust.com/repository/AmazonRootCA1.pem
```
------
#### [ Windows Command Prompt (CMD) ]
```
curl -o .\greengrass-v2-certs\AmazonRootCA1.pem https://www.amazontrust.com/repository/AmazonRootCA1.pem
```
------
#### [ PowerShell ]
```
iwr -Uri https://www.amazontrust.com/repository/AmazonRootCA1.pem -OutFile .\greengrass-v2-certs\AmazonRootCA1.pem
```
------
1. 如果您打算在與開發電腦不同的裝置上在 Docker 中執行 AWS IoT Greengrass Core 軟體，請將憑證複製到主機電腦。如果在開發電腦和主機電腦上啟用 SSH 和 SCP，您可以使用開發電腦上的 `scp`命令來傳輸憑證。將 *device-ip-address* 取代為主機電腦的 IP 地址。
```
scp -r greengrass-v2-certs/ device-ip-address:~
```
## 建立組態檔案
1. 在主機電腦上，建立您放置組態檔案的資料夾。
```
mkdir ./greengrass-v2-config
```
1. 使用文字編輯器在 `./greengrass-v2-config` 資料夾中建立名為 `config.yaml`的組態檔案。
例如，您可以執行下列命令來使用 GNU nano 來建立 `config.yaml`。
```
nano ./greengrass-v2-config/config.yaml
```
1. 將下列 YAML 內容複製到 檔案。此部分組態檔案會指定系統參數和 Greengrass 核參數。
```
---
system:
certificateFilePath: "/tmp/certs/device.pem.crt"
privateKeyPath: "/tmp/certs/private.pem.key"
rootCaPath: "/tmp/certs/AmazonRootCA1.pem"
rootpath: "/greengrass/v2"
thingName: "MyGreengrassCore"
services:
aws.greengrass.Nucleus:
componentType: "NUCLEUS"
version: "nucleus-version"
configuration:
awsRegion: "region"
iotRoleAlias: "GreengrassCoreTokenExchangeRoleAlias"
iotDataEndpoint: "device-data-prefix-ats.iot.region.amazonaws.com"
iotCredEndpoint: "device-credentials-prefix.credentials.region.amazonaws.com"
```
然後，取代下列值：
+ */tmp/certs*。您在啟動容器時，將下載的憑證掛載到 Docker 容器中的目錄。
+ `/greengrass/v2`。 您要用於安裝的 Greengrass 根資料夾。您可以使用 `GGC_ROOT`環境變數來設定此值。
+ *MyGreengrassCore*。物件的名稱 AWS IoT 。
+ *nucleus-version*。要安裝 AWS IoT Greengrass 的核心軟體版本。此值必須符合您下載的 Docker 映像或 Dockerfile 版本。如果您使用 `latest`標籤下載 Greengrass Docker 映像，請使用 ****docker inspect *image-id***** 查看映像版本。
+ *區域*。您建立 AWS IoT 資源 AWS 區域 的 。您也必須為`AWS_REGION`環境[檔案中](#create-env-file-manual-provisioning)的環境變數指定相同的值。
+ *GreengrassCoreTokenExchangeRoleAlias*。字符交換角色別名。
+ *device-data-prefix*。 AWS IoT 資料端點的字首。
+ *device-credentials-prefix*。登入 AWS IoT 資料端點的字首。
## 建立環境檔案
本教學課程使用環境檔案來設定將傳遞至 Docker 容器內 AWS IoT Greengrass Core 軟體安裝程式的環境變數。您也可以在`docker run`命令中使用 [`-e`或 `--env`引數](https://docs.docker.com/engine/reference/commandline/run/#env)，在 Docker 容器中設定環境變數，也可以在 `docker-compose.yml` 檔案的 [`environment`區塊](https://docs.docker.com/compose/compose-file/compose-file-v3/#environment)中設定變數。
1. 使用文字編輯器來建立名為 的環境檔案`.env`。
例如，在以 Linux 為基礎的系統上，您可以執行下列命令，使用 GNU nano `.env` 在目前的目錄中建立 。
```
nano .env
```
1. 將下列內容複製到 檔案。
```
GGC_ROOT_PATH=/greengrass/v2
AWS_REGION=region
PROVISION=false
COMPONENT_DEFAULT_USER=ggc_user:ggc_group
INIT_CONFIG=/tmp/config/config.yaml
```
然後，取代下列值。
+ `/greengrass/v2`。 用來安裝 AWS IoT Greengrass Core 軟體的根資料夾路徑。
+ *區域*。您建立 AWS IoT 資源 AWS 區域 的 。您必須為`awsRegion`組態[檔案中的組態](#create-docker-install-configuration-file)參數指定相同的值。
+ */tmp/config/*。您在啟動 Docker 容器時掛載組態檔案的資料夾。
**注意**
您可以將`DEPLOY_DEV_TOOLS`環境變數設定為 `true`以部署 [Greengrass CLI 元件](greengrass-cli-component.md)，這可讓您在 Docker 容器內開發自訂元件。建議您僅在開發環境中使用此元件，而非生產環境中。此元件可讓您存取生產環境中通常不需要的資訊和操作。僅將此元件部署到您需要的核心裝置，以遵循最低權限原則。
## 在容器中執行 AWS IoT Greengrass 核心軟體
本教學課程說明如何啟動您在 Docker 容器中建置的 Docker 映像。您可以使用 Docker CLI 或 Docker Compose CLI 在 Docker 容器中執行 AWS IoT Greengrass 核心軟體映像。
------
#### [ Docker ]
+ 本教學課程說明如何啟動您在 Docker 容器中建置的 Docker 映像。
```
docker run --rm --init -it --name docker-image \
-v path/to/greengrass-v2-config:/tmp/config/:ro \
-v path/to/greengrass-v2-certs:/tmp/certs:ro \
--env-file .env \
-p 8883 \
your-container-image:version
```
此範例命令使用下列引數來執行 [docker：](https://docs.docker.com/engine/reference/commandline/run/)
+ [https://docs.docker.com/engine/reference/run/#clean-up---rm](https://docs.docker.com/engine/reference/run/#clean-up---rm)。 在容器結束時清除容器。
+ [https://docs.docker.com/engine/reference/run/#specify-an-init-process](https://docs.docker.com/engine/reference/run/#specify-an-init-process)。 在容器中使用初始化程序。
**注意**
當您停止 Docker 容器時，需要 `--init`引數來關閉 AWS IoT Greengrass Core 軟體。
+ [https://docs.docker.com/engine/reference/run/#foreground](https://docs.docker.com/engine/reference/run/#foreground)。 （選用） 在前景中以互動式程序執行 Docker 容器。您可以使用 `-d`引數取代此值，以分離模式執行 Docker 容器。如需詳細資訊，請參閱 Docker 文件中的[分離與前景](https://docs.docker.com/engine/reference/run/#detached-vs-foreground)。
+ [https://docs.docker.com/engine/reference/run/#name---name](https://docs.docker.com/engine/reference/run/#name---name)。 執行名為 的容器 `aws-iot-greengrass`
+ [https://docs.docker.com/storage/volumes/](https://docs.docker.com/storage/volumes/)。 將磁碟區掛載到 Docker 容器，讓組態檔案和憑證檔案可供容器內 AWS IoT Greengrass 執行。
+ [https://docs.docker.com/engine/reference/commandline/run/#env](https://docs.docker.com/engine/reference/commandline/run/#env)。 （選用） 指定環境檔案，以設定要傳遞至 Docker 容器內 AWS IoT Greengrass Core 軟體安裝程式的環境變數。只有在您建立[環境檔案](#create-env-file-manual-provisioning)來設定環境變數時，才需要此引數。如果您未建立環境檔案，您可以使用`--env`引數直接在 Docker 執行命令中設定環境變數。
+ [https://docs.docker.com/engine/reference/commandline/run/#publish](https://docs.docker.com/engine/reference/commandline/run/#publish)。 （選用） 將 8883 容器連接埠發佈至主機。如果您想要透過 MQTT 連接和通訊，則需要此引數，因為 AWS IoT Greengrass 使用連接埠 8883 處理 MQTT 流量。若要開啟其他連接埠，請使用其他引`-p`數。
**注意**
若要以更高的安全性執行 Docker 容器，您可以使用 `--cap-drop`和 `--cap-add`引數來選擇性地為您的容器啟用 Linux 功能。如需詳細資訊，請參閱 Docker 文件中的[執行期權限和 Linux 功能](https://docs.docker.com/engine/reference/run/#runtime-privilege-and-linux-capabilities)。
------
#### [ Docker Compose ]
1. 使用文字編輯器來建立名為 的 Docker Compose 檔案`docker-compose.yml`。
例如，在以 Linux 為基礎的系統上，您可以執行下列命令，使用 GNU nano `docker-compose.yml` 在目前的目錄中建立 。
```
nano docker-compose.yml
```
**注意**
您也可以從 [GitHub](https://github.com/aws-greengrass/aws-greengrass-docker/releases/) 下載並使用最新版本的 AWS Compose 檔案。
1. 將下列內容新增至 Compose 檔案。您的檔案看起來應該如下列範例：將 *your-container-name：version* 取代為 Docker 映像的名稱。
```
version: '3.7'
services:
greengrass:
init: true
build:
context: .
container_name: aws-iot-greengrass
image: your-container-name:version
volumes:
- /path/to/greengrass-v2-config:/tmp/config/:ro
- /path/to/greengrass-v2-certs:/tmp/certs:ro
env_file: .env
ports:
- "8883:8883"
```
此範例中的下列參數 Compose 檔案為選用：
+ `ports`—發佈 8883 容器連接埠至主機。如果您想要透過 MQTT 連接和通訊，則需要此參數，因為 AWS IoT Greengrass 使用連接埠 8883 處理 MQTT 流量。
+ `env_file`- 指定環境檔案，以設定將傳遞至 Docker 容器內 AWS IoT Greengrass Core 軟體安裝程式的環境變數。只有在您建立[環境檔案](#create-env-file-manual-provisioning)來設定環境變數時，才需要此參數。如果您未建立環境檔案，您可以使用[環境](https://docs.docker.com/compose/compose-file/compose-file-v3/#environment)參數直接在 Compose 檔案中設定變數。
**注意**
若要以更高的安全性執行 Docker 容器，您可以在 `cap_add` Compose 檔案中使用 `cap_drop`和 ，為您的容器選擇性地啟用 Linux 功能。如需詳細資訊，請參閱 Docker 文件中的[執行期權限和 Linux 功能](https://docs.docker.com/engine/reference/run/#runtime-privilege-and-linux-capabilities)。
1. 執行下列命令來啟動容器。
```
docker-compose -f docker-compose.yml up
```
------
## 後續步驟
AWS IoT Greengrass 核心軟體現在正在 Docker 容器中執行。執行下列命令，以擷取目前執行中容器的容器 ID。
```
docker ps
```
然後，您可以執行下列命令來存取容器，並探索在容器內執行 AWS IoT Greengrass 的核心軟體。
```
docker exec -it container-id /bin/bash
```
如需建立簡單元件的詳細資訊，請參閱 [步驟 4：在您的裝置上開發和測試元件](create-first-component.md)中的 [教學課程：入門 AWS IoT Greengrass V2](getting-started.md)
**注意**
當您使用 在 Docker 容器內`docker exec`執行命令時，這些命令不會記錄在 Docker 日誌中。若要在 Docker 日誌中記錄命令，請將互動式 shell 連接到 Docker 容器。如需詳細資訊，請參閱[將互動式 shell 連接至 Docker 容器](docker-troubleshooting.md#debugging-docker-attach-shell)。
AWS IoT Greengrass 核心日誌檔案稱為 `greengrass.log`，位於 中`/greengrass/v2/logs`。元件日誌檔案也位於相同的目錄中。若要將 Greengrass 日誌複製到主機上的暫存目錄，請執行下列命令：
```
docker cp container-id:/greengrass/v2/logs /tmp/logs
```
如果您想要在容器結束或移除後保留日誌，建議您僅將`/greengrass/v2/logs`目錄繫結至主機上的暫存日誌目錄，而不是掛載整個 Greengrass 目錄。如需詳細資訊，請參閱[在 Docker 容器外保留 Greengrass 日誌](docker-troubleshooting.md#debugging-docker-persist-logs)。
若要停止執行中的 AWS IoT Greengrass Docker 容器，請執行 `docker stop`或 `docker-compose -f docker-compose.yml stop`。此動作會`SIGTERM`傳送至 Greengrass 程序，並關閉在容器中啟動的所有相關程序。Docker 容器會使用`docker-init`可執行檔初始化為程序 PID 1，這有助於移除任何剩餘的殭屍程序。如需詳細資訊，請參閱 Docker 文件中的[指定初始化程序](https://docs.docker.com/engine/reference/run/#specify-an-init-process)。
如需對 AWS IoT Greengrass 在 Docker 容器中執行 的問題進行故障診斷的資訊，請參閱 [在 Docker AWS IoT Greengrass 容器中進行故障診斷](docker-troubleshooting.md)。
# 在 Docker AWS IoT Greengrass 容器中進行故障診斷
使用下列資訊來協助您對 AWS IoT Greengrass 在 Docker 容器中執行的 問題進行故障診斷，並對 AWS IoT Greengrass Docker 容器中的 問題進行偵錯。
**Topics**
+ [對執行 Docker 容器的問題進行故障診斷](#troubleshooting-container-errors)
+ [在 Docker AWS IoT Greengrass 容器中偵錯](#debugging-greengrass-in-docker)
## 對執行 Docker 容器的問題進行故障診斷
使用以下資訊來協助疑難排解在 Docker 容器中執行 AWS IoT Greengrass 的問題。
**Topics**
+ [錯誤：無法從非 TTY 裝置執行互動式登入](#docker-troubleshootin-ecr-get-login-password)
+ [錯誤：不明選項：-no-include-email](#docker-troubleshooting-cli-version)
+ [錯誤：防火牆封鎖了 Windows 和容器之間的檔案共用。](#docker-troubleshooting-firewall)
+ [錯誤：呼叫 GetAuthorizationToken 操作時發生錯誤 (AccessDeniedException)：使用者：arn：aws：iam：：*account-id*：user/ 未獲授權在資源上執行：ecr：GetAuthorizationToken：\$1](#docker-troubleshooting-ecr-perms)
+ [錯誤：您已經達到提取率限制](#docker-troubleshooting-too-many-requests)
### 錯誤：無法從非 TTY 裝置執行互動式登入
當您執行 `aws ecr get-login-password`命令時，可能會發生此錯誤。請確定您已安裝最新版本 AWS CLI 2 或版本 1。我們建議您使用 第 2 AWS CLI 版。如需詳細資訊，請參閱「AWS Command Line Interface 使用者指南」**中的[安裝 AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html)。
### 錯誤：不明選項：-no-include-email
當您執行 `aws ecr get-login`命令時，可能會發生此錯誤。請確定您已安裝 AWS CLI 最新版本 （例如，執行：`pip install awscli --upgrade --user`)。如需詳細資訊，請參閱*AWS Command Line Interface 《 使用者指南*》中的在 [Microsoft Windows AWS Command Line Interface 上安裝](https://docs.aws.amazon.com/cli/latest/userguide/awscli-install-windows.html) 。
### 錯誤：防火牆封鎖了 Windows 和容器之間的檔案共用。
在 Windows 電腦上執行 Docker 時，您可能會收到此錯誤或`Firewall Detected`訊息。如果您登入虛擬私有網路 (VPN)，而您的網路設定防止掛載共用磁碟機，也可能會發生這個錯誤。在這種情況下，請關閉 VPN 並重新執行 Docker 容器。
### 錯誤：呼叫 GetAuthorizationToken 操作時發生錯誤 (AccessDeniedException)：使用者：arn：aws：iam：：*account-id*：user/ 未獲授權在資源上執行：ecr：GetAuthorizationToken：\$1
如果您沒有足夠的許可來存取 Amazon ECR 儲存庫，則執行 `aws ecr get-login-password`命令時可能會收到此錯誤。如需詳細資訊，請參閱《[Amazon ECR 使用者指南》中的 Amazon ECR 儲存庫政策範例](https://docs.aws.amazon.com/AmazonECR/latest/userguide/repository-policy-examples.html)**[和存取一個 Amazon ECR 儲存庫](https://docs.aws.amazon.com/AmazonECR/latest/userguide/security_iam_id-based-policy-examples.html)。
### 錯誤：您已經達到提取率限制
Docker Hub 限制匿名和 Free Docker Hub 使用者可以提出的提取請求數量。如果您超過匿名或免費使用者提取請求的速率限制，則會收到下列其中一個錯誤：
```
ERROR: toomanyrequests: Too Many Requests.
```
```
You have reached your pull rate limit.
```
若要解決這些錯誤，您可以等待幾個小時，然後再嘗試另一個提取請求。如果您打算持續提交大量提取請求，請參閱 [Docker Hub 網站](https://www.docker.com/increase-rate-limits)，以取得速率限制的相關資訊，以及驗證和升級 Docker 帳戶的選項。
## 在 Docker AWS IoT Greengrass 容器中偵錯
為了對 Docker 容器的問題進行偵錯，您可以保留 Greengrass 執行時間日誌或將互動式 shell 連接到 Docker 容器。
### 在 Docker 容器外保留 Greengrass 日誌
停止 AWS IoT Greengrass 容器之後，您可以使用下列`docker cp `命令，將 Docker 容器的 Greengrass 日誌複製到暫時日誌目錄。
```
docker cp container-id:/greengrass/v2/logs /tmp/logs
```
若要即使在容器結束或移除之後仍保留日誌，您必須在繫結掛載`/greengrass/v2/logs`目錄之後執行 AWS IoT Greengrass Docker 容器。
若要繫結掛載`/greengrass/v2/logs`目錄，請在執行新的 Docker AWS IoT Greengrass 容器時執行下列其中一項操作。
+ 將 包含在`docker run`命令`-v /tmp/logs:/greengrass/v2/logs:ro`中。
在執行`docker-compose up`命令之前，修改 Compose 檔案中的 `volumes` 區塊，以包含以下行。
```
volumes:
- /tmp/logs:/greengrass/v2/logs:ro
```
然後，您可以在主機`/tmp/logs`上檢查日誌，在 AWS IoT Greengrass Docker 容器內執行時查看 Greengrass 日誌。
如需有關執行 Greengrass Docker 容器的資訊，請參閱 [使用手動佈建在 Docker AWS IoT Greengrass 中執行](run-greengrass-docker-manual-provisioning.md) 和 [使用自動佈建在 Docker AWS IoT Greengrass 中執行](run-greengrass-docker-automatic-provisioning.md)
### 將互動式 shell 連接至 Docker 容器
當您使用 在 Docker 容器內`docker exec`執行命令時，這些命令不會擷取在 Docker 日誌中。在 Docker 日誌中記錄命令可協助您調查 Greengrass Docker 容器的狀態。執行以下任意一項：
+ 在個別終端機中執行下列命令，將終端機的標準輸入、輸出和錯誤連接至執行中的容器。這可讓您從目前的終端機檢視和控制 Docker 容器。
```
docker attach container-id
```
+ 在個別終端機中執行下列命令。這可讓您以互動式模式執行命令，即使未連接容器也一樣。
```
docker exec -it container-id sh -c "command > /proc/1/fd/1"
```
如需一般 AWS IoT Greengrass 故障診斷，請參閱 [故障診斷 AWS IoT Greengrass V2](troubleshooting.md)。
# 設定 AWS IoT Greengrass 核心軟體
Core AWS IoT Greengrass 軟體提供可用來設定軟體的選項。您可以建立部署，在每個 AWS IoT Greengrass 核心裝置上設定 核心軟體。
**Topics**
+ [部署 Greengrass 核元件](#configure-nucleus-component)
+ [將 Greengrass 核設定為系統服務](#configure-system-service)
+ [使用 JVM 選項控制記憶體配置](#jvm-tuning)
+ [設定執行元件的使用者](#configure-component-user)
+ [設定元件的系統資源限制](#configure-component-system-resource-limits)
+ [連線至連接埠 443 或透過網路代理](#configure-alpn-network-proxy)
+ [使用私有 CA 簽署的裝置憑證](#configure-nucleus-private-ca)
+ [設定 MQTT 逾時和快取設定](#configure-mqtt)
+ [在 IPv6 網路上設定 Greengrass Nucleus](#configure-ipv6)
## 部署 Greengrass 核元件
AWS IoT Greengrass 提供 AWS IoT Greengrass Core 軟體做為元件，您可以將其部署到 Greengrass 核心裝置。您可以建立部署，將相同的組態套用至多個 Greengrass 核心裝置。如需詳細資訊，請參閱[Greengrass 核](greengrass-nucleus-component.md)及[更新 AWS IoT Greengrass 核心軟體 (OTA)](update-greengrass-core-v2.md)。
## 將 Greengrass 核設定為系統服務
您必須將 AWS IoT Greengrass Core 軟體設定為裝置初始化系統中的系統服務，才能執行下列動作：
+ 在裝置開機時啟動 AWS IoT Greengrass Core 軟體。如果您管理大型裝置機群，這是很好的做法。
+ 安裝並執行外掛程式元件。數個 AWS提供的元件是外掛程式元件，可讓它們直接與 Greengrass 核連接。如需元件類型的詳細資訊，請參閱 [元件類型](develop-greengrass-components.md#component-types)。
+ 將over-the-air(OTA) 更新套用至核心裝置 AWS IoT Greengrass 的核心軟體。如需詳細資訊，請參閱[更新 AWS IoT Greengrass 核心軟體 (OTA)](update-greengrass-core-v2.md)。
+ 當部署將元件更新至新版本或更新特定組態參數時，啟用元件以重新啟動 AWS IoT Greengrass Core 軟體或核心裝置。如需詳細資訊，請參閱[引導生命週期步驟](component-recipe-reference.md#bootstrap-lifecycle-definition)。
**重要**
在 Windows 核心裝置上，您必須將 AWS IoT Greengrass Core 軟體設定為系統服務。
**Topics**
+ [將 核設定為系統服務 (Linux)](#configure-system-service-linux)
+ [將核心設定為系統服務 (Windows)](#configure-system-service-windows)
### 將 核設定為系統服務 (Linux)
Linux 裝置支援不同的初始化系統，例如 initd、Systemd 和 SystemV。當您安裝 AWS IoT Greengrass Core 軟體時，您可以使用 `--setup-system-service true`引數，以系統服務的形式啟動核心，並將其設定為在裝置開機時啟動。安裝程式會將 AWS IoT Greengrass Core 軟體設定為具有 systemd 的系統服務。
您也可以手動設定要做為系統服務執行的 核。以下範例為 systemd 的服務檔案：
```
[Unit]
Description=Greengrass Core
[Service]
Type=simple
PIDFile=/greengrass/v2/alts/loader.pid
RemainAfterExit=no
Restart=on-failure
RestartSec=10
ExecStart=/bin/sh /greengrass/v2/alts/current/distro/bin/loader
[Install]
WantedBy=multi-user.target
```
設定系統服務之後，您可以執行下列命令來設定在開機時啟動裝置，以及啟動或停止 AWS IoT Greengrass Core 軟體。
+ 檢查服務的狀態 （系統化）
```
sudo systemctl status greengrass.service
```
+ 若要在裝置開機時啟動核心。
```
sudo systemctl enable greengrass.service
```
+ 在裝置開機時停止啟動核心。
```
sudo systemctl disable greengrass.service
```
+ 啟動 AWS IoT Greengrass Core 軟體。
```
sudo systemctl start greengrass.service
```
+ 停止 AWS IoT Greengrass Core 軟體。
```
sudo systemctl stop greengrass.service
```
### 將核心設定為系統服務 (Windows)
安裝 AWS IoT Greengrass 核心軟體時，您可以使用 `--setup-system-service true`引數，以 Windows 服務的形式啟動核心，並將其設定為在裝置開機時啟動。
設定服務之後，您可以執行下列命令來設定在開機時啟動裝置，以及啟動或停止 AWS IoT Greengrass Core 軟體。您必須以管理員身分執行命令提示字元或 PowerShell，才能執行這些命令。
------
#### [ Windows Command Prompt (CMD) ]
+ 檢查服務的狀態
```
sc query "greengrass"
```
+ 若要在裝置開機時啟動核心。
```
sc config "greengrass" start=auto
```
+ 在裝置開機時停止啟動核心。
```
sc config "greengrass" start=disabled
```
+ 啟動 AWS IoT Greengrass Core 軟體。
```
sc start "greengrass"
```
+ 停止 AWS IoT Greengrass Core 軟體。
```
sc stop "greengrass"
```
**注意**
在 Windows 裝置上， AWS IoT Greengrass Core 軟體會在關閉 Greengrass 元件程序時忽略此關閉訊號。如果 AWS IoT Greengrass Core 軟體在您執行此命令時忽略關閉訊號，請等待幾秒鐘，然後再試一次。
------
#### [ PowerShell ]
+ 檢查服務的狀態
```
Get-Service -Name "greengrass"
```
+ 若要在裝置開機時啟動核心。
```
Set-Service -Name "greengrass" -Status stopped -StartupType automatic
```
+ 在裝置開機時停止啟動核心。
```
Set-Service -Name "greengrass" -Status stopped -StartupType disabled
```
+ 啟動 AWS IoT Greengrass Core 軟體。
```
Start-Service -Name "greengrass"
```
+ 停止 AWS IoT Greengrass Core 軟體。
```
Stop-Service -Name "greengrass"
```
**注意**
在 Windows 裝置上， AWS IoT Greengrass Core 軟體會在關閉 Greengrass 元件程序時忽略此關閉訊號。如果 AWS IoT Greengrass Core 軟體在您執行此命令時忽略關閉訊號，請等待幾秒鐘，然後再試一次。
------
## 使用 JVM 選項控制記憶體配置
如果您在記憶體有限的 AWS IoT Greengrass 裝置上執行，您可以使用 Java 虛擬機器 (JVM) 選項來控制堆積大小上限、垃圾收集模式和編譯器選項，以控制 AWS IoT Greengrass 核心軟體使用的記憶體數量。JVM 中的堆積大小會決定應用程式在[垃圾收集](https://docs.oracle.com/javase/8/docs/technotes/guides/vm/gctuning/introduction.html)發生之前或應用程式用盡記憶體之前可以使用多少記憶體。堆積大小的上限，指定了在繁重的作業進行期間擴充堆疊時，JVM 可以分配的最大記憶體容量。
若要控制記憶體配置，請建立新的部署或修改包含 nucleus 元件的現有部署，並在 [nucleus 元件組態](greengrass-nucleus-component.md#greengrass-nucleus-component-configuration-jvm-options)中的`jvmOptions`組態參數中指定您的 JVM 選項。
根據您的需求，您可以執行 AWS IoT Greengrass 核心軟體，減少記憶體配置或減少記憶體配置。
**減少記憶體配置**
若要在記憶體配置減少的情況下執行 AWS IoT Greengrass 核心軟體，建議您使用下列範例組態合併更新，在核心組態中設定 JVM 選項：
```
{
"jvmOptions": "-XX:+UseSerialGC -XX:TieredStopAtLevel=1"
}
```
**記憶體配置下限**
若要以最低記憶體配置執行 AWS IoT Greengrass 核心軟體，建議您使用下列範例組態合併更新，在核心組態中設定 JVM 選項：
```
{
"jvmOptions": "-Xmx32m -XX:+UseSerialGC -Xint"
}
```
**重要**
執行具有最低記憶體配置 AWS IoT Greengrass 的核心軟體可能會對低規格系統產生重大效能影響，因為使用較少記憶體時，JVM 會執行更多處理。建議您調校選項，以平衡記憶體和效能需求。
這些範例組態合併更新使用以下 JVM 選項：
`-XX:+UseSerialGC`
指定 將序列垃圾回收用於 JVM 堆積空間。序列垃圾收集器速度較慢，但比其他 JVM 垃圾收集實作使用的記憶體較少。
`-XX:TieredStopAtLevel=1`
指示 JVM 使用一次 Java just-in-time(JIT) 編譯器。由於 JIT 編譯程式碼使用裝置記憶體中的空間，因此使用 JIT 編譯器多次耗用比單一編譯更多的記憶體。
`-XmxNNm`
設定最大 JVM 堆積大小。
設定過小的堆積大小上限可能會導致效能變慢或out-of-memory錯誤。建議您先測量目前的堆積用量，再使用 `-XmxNNm`選項設定大小上限。使用 JVM 選項設定您的 `-XX:NativeMemoryTracking=detail` JVM。然後，使用 [jcmd 公用程式](https://docs.oracle.com/javase/8/docs/technotes/guides/troubleshoot/tooldescr006.html)中的`VM.native_memory`命令請求來測量您目前的堆積用量。
如果堆積的測量不是選項，請使用 `-Xmx64m`作為開始值，將堆積大小限制為 64 MB。然後，您可以逐步減少堆積大小上限。對於最小記憶體配置，請使用 `-Xmx32m`作為起始值，將堆積大小限制為 32 MB。
您可以根據實際需求來增加或減少`-Xmx`值；不過，強烈建議不要將堆積大小上限設定為低於 16 MB。根據部署到核心裝置的外掛程式元件，所需的 JVM 堆積大小也可能隨著時間而不同。如果最大堆積大小對您的環境而言太低，則 AWS IoT Greengrass Core 軟體可能會因為記憶體不足而遇到非預期錯誤。如果您因為記憶體不足而遇到效能較慢或發生錯誤，請還原為已知良好的設定。例如，如果您的正常遞交堆積大小為 `41428KB`，請使用 `-Xmx40m` 來稍微限制堆積用量。
`-Xint`
指示 JVM 不使用just-in-time(JIT) 編譯器。反之，JVM 會以僅解譯模式執行。此模式比執行 JIT 編譯程式碼慢 （在低端系統上部署可能慢 20 倍）；不過，編譯的程式碼不會使用任何記憶體空間。
如需建立組態合併更新的資訊，請參閱 [更新元件組態](update-component-configurations.md)。
## 設定執行元件的使用者
AWS IoT Greengrass 核心軟體可以系統使用者身分執行元件程序，並將與執行軟體程序不同的程序分組。這可提高安全性，因為您可以以根或管理員使用者身分執行 AWS IoT Greengrass 核心軟體，而無需將這些許可授予在核心裝置上執行的元件。
下表指出 AWS IoT Greengrass Core 軟體可以以您指定的使用者身分執行的元件類型。如需詳細資訊，請參閱[元件類型](develop-greengrass-components.md#component-types)。
| 元件類型 | 設定元件使用者 |
| --- | --- |
| Huleus | ![\[No\]](http://docs.aws.amazon.com/zh_tw/greengrass/v2/developerguide/images/icon-no.png) 否 |
| 外掛程式 | ![\[No\]](http://docs.aws.amazon.com/zh_tw/greengrass/v2/developerguide/images/icon-no.png) 否 |
| 一般 | ![\[Yes\]](http://docs.aws.amazon.com/zh_tw/greengrass/v2/developerguide/images/icon-yes.png) 是 |
| Lambda （非容器化） | ![\[Yes\]](http://docs.aws.amazon.com/zh_tw/greengrass/v2/developerguide/images/icon-yes.png) 是 |
| Lambda （容器化） | ![\[Yes\]](http://docs.aws.amazon.com/zh_tw/greengrass/v2/developerguide/images/icon-yes.png) 是 |
您必須先建立元件使用者，才能在部署組態中指定它。在 Windows 型裝置上，您還必須將使用者的使用者名稱和密碼存放在 LocalSystem 帳戶的登入資料管理員執行個體中。如需詳細資訊，請參閱[在 Windows 裝置上設定元件使用者](#create-component-user-windows)。
當您在 Linux 型裝置上設定元件使用者時，您也可以選擇性地指定群組。您可以指定使用者和群組，並以冒號 (`:`) 分隔，格式如下：`user:group`。如果您未指定群組，則 AWS IoT Greengrass Core 軟體會預設為使用者的主要群組。您可以使用名稱或 ID 來識別使用者和群組。
在 Linux 型裝置上，您也可以以不存在的系統使用者身分執行元件，也稱為未知使用者，以提高安全性。Linux 程序可以發出由相同使用者執行的任何其他程序的訊號。未知使用者不會執行其他程序，因此您可以使用未知使用者身分執行元件，以防止元件向核心裝置上的其他元件發出訊號。若要以未知使用者身分執行元件，請指定核心裝置上不存在的使用者 ID。您也可以指定不存在的群組 ID，以做為未知群組執行。
您可以為每個元件和每個核心裝置設定使用者。
+ **為元件設定**
您可以設定每個元件，以與該元件特定的使用者一起執行。當您建立部署時，您可以為該元件`runWith`組態中的每個元件指定使用者。如果您設定元件， AWS IoT Greengrass 則 Core 軟體會以指定的使用者身分執行元件。否則，預設會以您為核心裝置設定的預設使用者身分執行元件。如需在部署組態中指定元件使用者的詳細資訊，請參閱 中的[`runWith`](create-deployments.md#component-run-with-config)組態參數[建立部署](create-deployments.md)。
+ **設定核心裝置的預設使用者**
您可以設定 AWS IoT Greengrass Core 軟體用來執行元件的預設使用者。 AWS IoT Greengrass 核心軟體執行元件時，會檢查您是否為該元件指定使用者，並使用它來執行元件。如果元件未指定使用者，則 AWS IoT Greengrass Core 軟體會以您為核心裝置設定的預設使用者身分執行元件。如需詳細資訊，請參閱[設定預設元件使用者](#configure-default-component-user)。
**注意**
在 Windows 型裝置上，您必須至少指定預設使用者才能執行元件。
在 Linux 型裝置上，如果您未將使用者設定為執行元件，則適用下列考量：
如果您執行 AWS IoT Greengrass Core 軟體做為根，則軟體不會執行元件。如果您以根身分執行 ，則必須指定預設使用者來執行元件。
如果您以非根使用者身分執行 AWS IoT Greengrass Core 軟體，則軟體會以該使用者身分執行元件。
**Topics**
+ [在 Windows 裝置上設定元件使用者](#create-component-user-windows)
+ [設定預設元件使用者](#configure-default-component-user)
### 在 Windows 裝置上設定元件使用者
**在 Windows 型裝置上設定元件使用者**
1. 在裝置上的 LocalSystem 帳戶中建立元件使用者。
```
net user /add component-user password
```
1. 使用 [Microsoft 的 PsExec 公用程式](https://docs.microsoft.com/en-us/sysinternals/downloads/psexec)，將元件使用者的使用者名稱和密碼存放在 LocalSystem 帳戶的 Credential Manager 執行個體中。
```
psexec -s cmd /c cmdkey /generic:component-user /user:component-user /pass:password
```
**注意**
在 Windows 型裝置上，LocalSystem 帳戶會執行 Greengrass 核，而且您必須使用 PsExec 公用程式將元件使用者資訊存放在 LocalSystem 帳戶中。使用 Credential Manager 應用程式會將此資訊存放在目前登入使用者的 Windows 帳戶中，而不是 LocalSystem 帳戶。
### 設定預設元件使用者
您可以使用部署來設定核心裝置上的預設使用者。在此部署中，您會更新 [nucleus 元件](greengrass-nucleus-component.md)組態。
**注意**
您也可以在使用 `--component-default-user`選項安裝 AWS IoT Greengrass Core 軟體時設定預設使用者。如需詳細資訊，請參閱[安裝 AWS IoT Greengrass Core 軟體](install-greengrass-core-v2.md)。
[建立 部署](create-deployments.md)，指定 `aws.greengrass.Nucleus`元件的下列組態更新。
------
#### [ Linux ]
```
{
"runWithDefault": {
"posixUser": "ggc_user:ggc_group"
}
}
```
------
#### [ Windows ]
```
{
"runWithDefault": {
"windowsUser": "ggc_user"
}
}
```
**注意**
您指定的使用者必須存在，且此使用者的使用者名稱和密碼必須存放在 Windows 裝置上的 LocalSystem 帳戶的登入資料管理員執行個體中。如需詳細資訊，請參閱[在 Windows 裝置上設定元件使用者](#create-component-user-windows)。
------
下列範例定義以 Linux 為基礎的裝置的部署，將 設定為`ggc_user`預設使用者，並將 `ggc_group`設定為預設群組。`merge` 組態更新需要序列化 JSON 物件。
```
{
"components": {
"aws.greengrass.Nucleus": {
"version": "2.16.1",
"configurationUpdate": {
"merge": "{\"runWithDefault\":{\"posixUser\":\"ggc_user:ggc_group\"}}"
}
}
}
}
```
## 設定元件的系統資源限制
**注意**
此功能適用於 [Greengrass 核元件](greengrass-nucleus-component.md)的 v2.4.0 和更新版本。目前 AWS IoT Greengrass 不支援 Windows 核心裝置上的此功能。
您可以設定每個元件程序可在核心裝置上使用的 CPU 和 RAM 用量上限。
下表顯示支援系統資源限制的元件類型。如需詳細資訊，請參閱[元件類型](develop-greengrass-components.md#component-types)。
| 元件類型 | 設定系統資源限制 |
| --- | --- |
| Huleus | ![\[No\]](http://docs.aws.amazon.com/zh_tw/greengrass/v2/developerguide/images/icon-no.png) 否 |
| 外掛程式 | ![\[No\]](http://docs.aws.amazon.com/zh_tw/greengrass/v2/developerguide/images/icon-no.png) 否 |
| 一般 | ![\[Yes\]](http://docs.aws.amazon.com/zh_tw/greengrass/v2/developerguide/images/icon-yes.png) 是 |
| Lambda （非容器化） | ![\[Yes\]](http://docs.aws.amazon.com/zh_tw/greengrass/v2/developerguide/images/icon-yes.png) 是 |
| Lambda （容器化） | ![\[No\]](http://docs.aws.amazon.com/zh_tw/greengrass/v2/developerguide/images/icon-no.png) 否 |
**重要**
當您[在 Docker 容器中執行 AWS IoT Greengrass Core 軟體時，](run-greengrass-docker.md)不支援系統資源限制。
您可以為每個元件和每個核心裝置設定系統資源限制。
+ **為元件設定**
您可以使用該元件特定的系統資源限制來設定每個元件。建立部署時，您可以指定部署中每個元件的系統資源限制。如果元件支援系統資源限制，則 AWS IoT Greengrass Core 軟體會將限制套用至元件的程序。如果您未指定元件的系統資源限制，則 AWS IoT Greengrass Core 軟體會使用您為核心裝置設定的任何預設值。如需詳細資訊，請參閱[建立部署](create-deployments.md)。
+ **設定核心裝置的預設值**
您可以設定 AWS IoT Greengrass Core 軟體套用至支援這些限制之元件的預設系統資源限制。當 AWS IoT Greengrass Core 軟體執行元件時，它會套用您為該元件指定的系統資源限制。如果該元件未指定系統資源限制，則 AWS IoT Greengrass Core 軟體會套用您為核心裝置設定的預設系統資源限制。如果您未指定預設系統資源限制， AWS IoT Greengrass 則 Core 軟體預設不會套用任何系統資源限制。如需詳細資訊，請參閱[設定預設系統資源限制](#configure-default-component-system-resource-limits)。
### 設定預設系統資源限制
您可以部署 [Greengrass 核元件](greengrass-nucleus-component.md)，以設定核心裝置的預設系統資源限制。若要設定預設系統資源限制，[請建立 部署](create-deployments.md)來指定`aws.greengrass.Nucleus`元件的下列組態更新。
```
{
"runWithDefault": {
"systemResourceLimits": {
"cpu": cpuTimeLimit,
"memory": memoryLimitInKb
}
}
}
```
下列範例會定義將 CPU 時間限制設定為 的部署`2`，相當於具有 4 個 CPU 核心之裝置上的 50% 用量。此範例也會將記憶體用量設定為 100 MB。
```
{
"components": {
"aws.greengrass.Nucleus": {
"version": "2.16.1",
"configurationUpdate": {
"merge": "{\"runWithDefault\":{\"systemResourceLimits\":\"cpus\":2,\"memory\":102400}}}"
}
}
}
}
```
## 連線至連接埠 443 或透過網路代理
AWS IoT Greengrass 核心裝置 AWS IoT Core 使用 MQTT 訊息通訊協定搭配 TLS 用戶端身分驗證與 通訊。根據慣例，透過 TLS 的 MQTT 使用連接埠 8883。不過，做為安全措施之用，受限環境可能會將傳入和傳出流量限制於小範圍的 TCP 連接埠。例如，企業防火牆可能會針對 HTTPS 流量開放連接埠 443，但關閉較不常用之通訊協定的其他連接埠，例如 MQTT 流量的連接埠 8883。其他限制性環境可能需要所有流量通過代理才能連線至網際網路。
**注意**
執行 Greengrass [核元件 v2.0.3 和更早版本的 Greengrass](greengrass-nucleus-component.md) 核心裝置使用連接埠 8443 連接到 AWS IoT Greengrass 資料平面端點。這些裝置必須能夠在連接埠 8443 上連線至此端點。如需詳細資訊，請參閱[允許透過代理或防火牆的裝置流量](allow-device-traffic.md)。
若要在這些案例中啟用通訊， AWS IoT Greengrass 提供下列組態選項：
+ **透過連接埠 443 的 MQTT 通訊**。如果您的網路允許連線至連接埠 443，您可以將 Greengrass 核心裝置設定為將連接埠 443 用於 MQTT 流量，而不是預設連接埠 8883。這可以直接連線至連接埠 443，或透過網路代理伺服器連線。與使用憑證型用戶端身分驗證的預設組態不同，連接埠 443 上的 MQTT 會使用[裝置服務角色](device-service-role.md)進行身分驗證。
如需詳細資訊，請參閱[透過連接埠 443 設定 MQTT](#configure-mqtt-port-443)。
+ **透過連接埠 443 的 HTTPS 通訊**。Core AWS IoT Greengrass 軟體預設會透過連接埠 8443 傳送 HTTPS 流量，但您可以將其設定為使用連接埠 443。 AWS IoT Greengrass 會使用[應用程式層通訊協定網路](https://tools.ietf.org/html/rfc7301) (ALPN) TLS 延伸來啟用此連線。如同預設組態，連接埠 443 上的 HTTPS 使用憑證型用戶端身分驗證。
**重要**
若要使用 ALPN 並透過連接埠 443 啟用 HTTPS 通訊，您的核心裝置必須執行 Java 8 更新 252 或更新版本。Java 第 9 版及更新版本的所有更新也支援 ALPN。
如需詳細資訊，請參閱[透過連接埠 443 設定 HTTPS](#configure-https-port-443)。
+ **透過網路代理的連線**。您可以設定網路代理伺服器做為連線至 Greengrass 核心裝置的媒介。 AWS IoT Greengrass 支援 HTTP 和 HTTPS 代理的基本身分驗證。
Greengrass 核心裝置必須執行 [Greengrass 核 v](greengrass-nucleus-component.md)2.5.0 或更新版本，才能使用 HTTPS 代理。
Core AWS IoT Greengrass 軟體會透過 `ALL_PROXY`、`HTTPS_PROXY`、 和 `HTTP_PROXY``NO_PROXY`環境變數，將代理組態傳遞至元件。元件必須使用這些設定來透過代理連線。元件使用常見程式庫 （例如 boto3、cURL 和 python `requests`套件），這些程式庫預設會使用這些環境變數進行連線。如果元件也指定這些環境變數，則 AWS IoT Greengrass 不會覆寫它們。
如需詳細資訊，請參閱[設定網路代理](#configure-network-proxy)。
### 透過連接埠 443 設定 MQTT
您可以在現有的核心裝置上，或在新的核心裝置上安裝 AWS IoT Greengrass 核心軟體時，透過連接埠 443 設定 MQTT。
**Topics**
+ [在現有核心裝置上透過連接埠 443 設定 MQTT](#configure-mqtt-port-443-deployment)
+ [在安裝期間透過連接埠 443 設定 MQTT](#configure-mqtt-port-443-installer)
#### 在現有核心裝置上透過連接埠 443 設定 MQTT
您可以使用部署，在單一核心裝置或一組核心裝置上透過連接埠 443 設定 MQTT。在此部署中，您會更新 [nucleus 元件](greengrass-nucleus-component.md)組態。當您更新其`mqtt`組態時，核會重新啟動。
若要透過連接埠 443 設定 MQTT，[請建立 部署](create-deployments.md)來指定`aws.greengrass.Nucleus`元件的下列組態更新。
```
{
"mqtt": {
"port": 443
}
}
```
下列範例定義透過連接埠 443 設定 MQTT 的部署。`merge` 組態更新需要序列化 JSON 物件。
```
{
"components": {
"aws.greengrass.Nucleus": {
"version": "2.16.1",
"configurationUpdate": {
"merge": "{\"mqtt\":{\"port\":443}}"
}
}
}
}
```
#### 在安裝期間透過連接埠 443 設定 MQTT
您可以在核心裝置上安裝 AWS IoT Greengrass Core 軟體時，透過連接埠 443 設定 MQTT。使用`--init-config`安裝程式引數透過連接埠 443 設定 MQTT。您可以在使用[手動佈建](manual-installation.md)、[機群佈建](fleet-provisioning.md)或[自訂佈建](custom-provisioning.md)安裝 時指定此引數。
### 透過連接埠 443 設定 HTTPS
此功能需要 v2[Greengrass 核](greengrass-nucleus-component.md).0.4 或更新版本。
您可以在現有核心裝置上，或在新核心裝置上安裝 AWS IoT Greengrass 核心軟體時，透過連接埠 443 設定 HTTPS。
**Topics**
+ [在現有核心裝置上透過連接埠 443 設定 HTTPS](#configure-https-port-443-deployment)
+ [在安裝期間透過連接埠 443 設定 HTTPS](#configure-https-port-443-installer)
#### 在現有核心裝置上透過連接埠 443 設定 HTTPS
您可以使用部署，在單一核心裝置或一組核心裝置上透過連接埠 443 設定 HTTPS。在此部署中，您會更新 [nucleus 元件](greengrass-nucleus-component.md)組態。
若要透過連接埠 443 設定 HTTPS，[請建立指定下列元件組態更新的部署](create-deployments.md)。 `aws.greengrass.Nucleus`
```
{
"greengrassDataPlanePort": 443
}
```
下列範例定義透過連接埠 443 設定 HTTPS 的部署。`merge` 組態更新需要序列化 JSON 物件。
```
{
"components": {
"aws.greengrass.Nucleus": {
"version": "2.16.1",
"configurationUpdate": {
"merge": "{\"greengrassDataPlanePort\":443}"
}
}
}
}
```
#### 在安裝期間透過連接埠 443 設定 HTTPS
您可以在核心裝置上安裝 AWS IoT Greengrass Core 軟體時，透過連接埠 443 設定 HTTPS。使用`--init-config`安裝程式引數透過連接埠 443 設定 HTTPS。您可以在使用[手動佈建](manual-installation.md)、[機群佈建](fleet-provisioning.md)或[自訂佈建](custom-provisioning.md)安裝 時指定此引數。
### 設定網路代理
遵循本節中的程序，設定 Greengrass 核心裝置透過 HTTP 或 HTTPS 網路代理連線到網際網路。如需核心裝置使用的端點和連接埠的詳細資訊，請參閱 [允許透過代理或防火牆的裝置流量](allow-device-traffic.md)。
**重要**
如果您的核心裝置執行比 v2.4.0 更舊的 [Greengrass 核](greengrass-nucleus-component.md)版本，您裝置的角色必須允許下列許可才能使用網路代理：
`iot:Connect`
`iot:Publish`
`iot:Receive`
`iot:Subscribe`
這是必要的，因為裝置會使用字符交換服務的 AWS 登入資料來驗證 MQTT 連線 AWS IoT。裝置使用 MQTT 從 接收和安裝部署 AWS 雲端，因此除非您為其角色定義這些許可，否則您的裝置將無法運作。裝置通常會使用 X.509 憑證來驗證 MQTT 連線，但裝置無法使用代理來驗證。
如需如何設定裝置角色的詳細資訊，請參閱 [授權核心裝置與 AWS 服務互動](device-service-role.md)。
**Topics**
+ [在現有核心裝置上設定網路代理](#configure-network-proxy-deployment)
+ [在安裝期間設定網路代理](#configure-network-proxy-installer)
+ [讓核心裝置信任 HTTPS 代理](#https-proxy-certificate-trust)
+ [networkProxy 物件](#network-proxy-object)
#### 在現有核心裝置上設定網路代理
您可以使用部署在單一核心裝置或一組核心裝置上設定網路代理。在此部署中，您會更新 [nucleus 元件](greengrass-nucleus-component.md)組態。當您更新其`networkProxy`組態時，核會重新啟動。
若要設定網路代理，請為合併下列組態更新的`aws.greengrass.Nucleus`元件[建立部署](create-deployments.md)。此組態更新包含 [networkProxy 物件](#network-proxy-object)。
```
{
"networkProxy": {
"noProxyAddresses": "http://192.168.0.1,www.example.com",
"proxy": {
"url": "https://my-proxy-server:1100"
}
}
}
```
下列範例會定義可設定網路代理的部署。`merge` 組態更新需要序列化 JSON 物件。
```
{
"components": {
"aws.greengrass.Nucleus": {
"version": "2.16.1",
"configurationUpdate": {
"merge": "{\"networkProxy\":{\"noProxyAddresses\":\"http://192.168.0.1,www.example.com\",\"proxy\":{\"url\":\"https://my-proxy-server:1100\",\"username\":\"Mary_Major\",\"password\":\"pass@word1357\"}}}"
}
}
}
}
```
#### 在安裝期間設定網路代理
您可以在核心裝置上安裝 AWS IoT Greengrass Core 軟體時設定網路代理。使用`--init-config`安裝程式引數來設定網路代理。您可以在使用[手動佈建](manual-installation.md)、[機群佈建](fleet-provisioning.md)或[自訂佈建](custom-provisioning.md)安裝 時指定此引數。
#### 讓核心裝置信任 HTTPS 代理
當您將核心裝置設定為使用 HTTPS 代理時，必須將代理伺服器憑證鏈新增至核心裝置的 ，讓它信任 HTTPS 代理。否則，核心裝置可能會在嘗試透過代理路由流量時遇到錯誤。將代理伺服器 CA 憑證新增至核心裝置的 Amazon 根 CA 憑證檔案。
**讓核心裝置信任 HTTPS 代理**
1. 尋找核心裝置上的 Amazon 根 CA 憑證檔案。
+ 如果您使用[自動佈建](quick-installation.md)安裝 AWS IoT Greengrass Core 軟體，Amazon 根 CA 憑證檔案會存在於 `/greengrass/v2/rootCA.pem`。
+ 如果您使用[手動](manual-installation.md)或[機群佈建](fleet-provisioning.md)安裝 AWS IoT Greengrass Core 軟體，Amazon 根 CA 憑證檔案可能存在於 `/greengrass/v2/AmazonRootCA1.pem`。
如果這些位置不存在 Amazon 根 CA 憑證，請檢查 中的 `system.rootCaPath` 屬性`/greengrass/v2/config/effectiveConfig.yaml`以尋找其位置。
1. 將代理伺服器 CA 憑證檔案的內容新增至 Amazon 根 CA 憑證檔案。
下列範例顯示新增至 Amazon 根 CA 憑證檔案的代理伺服器 CA 憑證。
```
-----BEGIN CERTIFICATE-----
MIIEFTCCAv2gAwIQWgIVAMHSAzWG/5YVRYtRQOxXUTEpHuEmApzGCSqGSIb3DQEK
\nCwUAhuL9MQswCQwJVUzEPMAVUzEYMBYGA1UECgwP1hem9uLmNvbSBJbmMuMRww
... content of proxy CA certificate ...
+vHIRlt0e5JAm5\noTIZGoFbK82A0/nO7f/t5PSIDAim9V3Gc3pSXxCCAQoFYnui
GaPUlGk1gCE84a0X\n7Rp/lND/PuMZ/s8YjlkY2NmYmNjMCAXDTE5MTEyN2cM216
gJMIADggEPADf2/m45hzEXAMPLE=
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
MIIDQTCCAimgF6AwIBAgITBmyfz/5mjAo54vB4ikPmljZKyjANJmApzyMZFo6qBg
ADA5MQswCQYDVQQGEwJVUzEPMA0tMVT8QtPHRh8jrdkGA1UEChMGDV3QQDExBBKW
... content of root CA certificate ...
o/ufQJQWUCyziar1hem9uMRkwFwYVPSHCb2XV4cdFyQzR1KldZwgJcIQ6XUDgHaa
5MsI+yMRQ+hDaXJiobldXgjUka642M4UwtBV8oK2xJNDd2ZhwLnoQdeXeGADKkpy
rqXRfKoQnoZsG4q5WTP46EXAMPLE
-----END CERTIFICATE-----
```
#### networkProxy 物件
使用 `networkProxy` 物件，指定網路代理的相關資訊。此物件包含下列資訊：
`noProxyAddresses`
（選用） 從代理中豁免的 IP 地址或主機名稱的逗號分隔清單。
`proxy`
要連線的代理。此物件包含下列資訊：
`url`
代理伺服器的 URL，格式為 `scheme://userinfo@host:port`。
+ `scheme` – 結構描述，必須是 `http`或 `https`。
**重要**
Greengrass 核心裝置必須執行 [Greengrass 核 v](greengrass-nucleus-component.md)2.5.0 或更新版本，才能使用 HTTPS 代理。
如果您設定 HTTPS 代理，則必須將代理伺服器 CA 憑證新增至核心裝置的 Amazon 根 CA 憑證。如需詳細資訊，請參閱[讓核心裝置信任 HTTPS 代理](#https-proxy-certificate-trust)。
+ `userinfo` – （選用） 使用者名稱和密碼資訊。如果您在 中指定此資訊`url`，Greengrass 核心裝置會忽略 `username`和 `password` 欄位。
+ `host` – 代理伺服器的主機名稱或 IP 地址。
+ `port` – （選用） 連接埠號碼。如果您未指定連接埠，則 Greengrass 核心裝置會使用下列預設值：
+ `http` – 80
+ `https` – 443
`username`
（選用） 驗證代理伺服器的使用者名稱。
`password`
（選用） 驗證代理伺服器的密碼。
## 使用私有 CA 簽署的裝置憑證
如果您使用自訂私有憑證授權機構 (CA)，您必須將 Greengrass 核**greengrassDataPlaneEndpoint**設定為 **iotdata**。您可以使用**--init-config**[安裝程式引數](configure-installer.md)在部署或安裝期間設定此選項。
您可以自訂裝置連線的 Greengrass 資料平面端點。您可以將此組態選項設定為 **iotdata** ，將 Greengrass 資料平面端點設定為與 IoT 資料端點相同的端點，您可以使用 來指定**iotDataEndpoint**。
## 設定 MQTT 逾時和快取設定
在 AWS IoT Greengrass 環境中，元件可以使用 MQTT 與 通訊 AWS IoT Core。Core AWS IoT Greengrass 軟體會管理元件的 MQTT 訊息。當核心裝置失去與 的連線時 AWS 雲端，軟體會快取 MQTT 訊息，以便在連線還原時稍後重試。您可以設定訊息逾時和快取大小等設定。如需詳細資訊，請參閱 [Greengrass 核元件](greengrass-nucleus-component.md)的 `mqtt`和 `mqtt.spooler`組態參數。
AWS IoT Core 對其 MQTT 訊息代理程式強加服務配額。這些配額可能適用於您在核心裝置和 之間傳送的訊息 AWS IoT Core。如需詳細資訊，請參閱 中的[AWS IoT Core 訊息中介裝置服務配額](https://docs.aws.amazon.com/general/latest/gr/iot-core.html#message-broker-limits)*AWS 一般參考*。
## 在 IPv6 網路上設定 Greengrass Nucleus
Greengrass Nucleus AWS IoT Core 透過 [Greengrass APIs](https://docs.aws.amazon.com/general/latest/gr/greengrassv2.html) 與 通訊。Greengrass APIs雙堆疊環境中支援 IPv6。
若要啟用 IPv6 的雙堆疊端點：
+ 將系統屬性 `aws.useDualstackEndpoint=true`、 和 `java.net.preferIPv6Addresses=true` 新增至 `jvmOptions`
+ 將 `s3EndpointType` 設定為 `DUALSTACK`
在[部署](https://docs.aws.amazon.com/greengrass/v2/developerguide/create-deployments.html)期間設定此選項，或使用`--init-config`[安裝程式引數](https://docs.aws.amazon.com/greengrass/v2/developerguide/configure-installer.html)手動佈建。如需詳細資訊，請參閱[使用 Amazon S3 雙堆疊端點](https://docs.aws.amazon.com/AmazonS3/latest/API/dual-stack-endpoints.html)。
**Example 部署的程式碼：**
```
{
"jvmOptions": "-Daws.useDualstackEndpoint=true",
"s3EndpointType":"DUALSTACK"
}
```
**Example `config.yaml` 透過手動佈建：**
```
---
system:
...
services:
aws.greengrass.Nucleus:
...
configuration:
...
jvmOptions: "-Daws.useDualstackEndpoint=true -Djava.net.preferIPv6Addresses=true"
s3EndpointType: "DUALSTACK"
```
# 更新 AWS IoT Greengrass 核心軟體 (OTA)
AWS IoT Greengrass 核心軟體包含 [Greengrass 核元件](greengrass-nucleus-component.md)和其他選用元件，您可以將這些元件部署到您的裝置，以執行軟體的over-the-air(OTA) 更新。此功能內建於 AWS IoT Greengrass 核心軟體。
OTA 更新可讓您更有效率地執行下列作業：
+ 修復安全漏洞。
+ 解決軟體穩定性問題。
+ 部署新功能和改良的功能。
**Topics**
+ [要求](#ota-update-requirements)
+ [核心裝置的考量事項](#ota-update-considerations)
+ [Greengrass 核更新行為](#ota-update-behavior-nucleus)
+ [執行 OTA 更新](#create-ota-update)
## 要求
下列需求適用於部署 AWS IoT Greengrass 核心軟體的 OTA 更新：
+ Greengrass 核心裝置必須連線至 AWS 雲端 才能接收部署。
+ Greengrass 核心裝置必須正確設定和佈建憑證和金鑰，以便使用 AWS IoT Core 和 進行身分驗證 AWS IoT Greengrass。
+ AWS IoT Greengrass 核心軟體必須設定為系統服務並執行。如果您從 JAR 檔案 執行 核，OTA 更新將無法運作`Greengrass.jar`。如需詳細資訊，請參閱[將 Greengrass 核設定為系統服務](configure-greengrass-core-v2.md#configure-system-service)。
## 核心裝置的考量事項
執行 OTA 更新之前，請注意您更新的核心裝置及其連線的用戶端裝置的影響：
+ Greengrass 核會關閉。
+ 在核心裝置上執行的所有元件也會關閉。如果這些元件寫入本機資源，除非正確關閉，否則這些資源可能會處於不正確的狀態。元件可以使用[程序間通訊](interprocess-communication.md)來告知 nucleus 元件延遲更新，直到清除其使用的資源為止。
+ 當核心元件關閉時，核心裝置會失去與 AWS 雲端 和本機裝置的連線。關閉時，核心裝置不會從用戶端裝置路由訊息。
+ 做為元件執行的長期 Lambda 函數會遺失其動態狀態資訊，並捨棄所有待處理的工作。
## Greengrass 核更新行為
部署元件時， 會 AWS IoT Greengrass 安裝該元件所有相依性的最新支援版本。因此，如果您將新裝置新增至物件群組，或者您更新以這些裝置為目標的部署，則可能會自動將新修補程式版本的 AWS公有元件部署到核心裝置。有些自動更新，例如 核更新，可能會導致您的裝置意外重新啟動。
當 [Greengrass 核子元件](greengrass-nucleus-component.md)的版本變更時，包含您裝置上的核子和所有其他元件 AWS IoT Greengrass 的核心軟體會開始套用變更。由於 核元件更新時[對核心裝置的影響](#ota-update-considerations)，因此您可能想要控制何時將新的核修補程式版本部署至您的裝置。若要這樣做，您必須在部署中直接包含 Greengrass 核元件。直接包含元件表示您在部署組態中包含該元件的特定版本，且不依賴元件相依性將該元件部署至您的裝置。如需在元件配方中定義相依性的詳細資訊，請參閱[配方格式](component-recipe-reference.md#recipe-format)。
檢閱下表，根據您的動作和部署組態了解 Greengrass 核元件的更新行為。
| 動作 | 部署組態 | Nucleus 更新行為 |
| --- | --- | --- |
| 將新裝置新增至現有部署以目標為目標的物件群組，而不修改部署。 | 部署不會直接包含 Greengrass 核。部署直接包含至少一個 AWS提供的元件，或包含取決於 AWS提供的元件或 Greengrass 核的自訂元件。 | 在新裝置上， 安裝符合所有元件相依性需求的最新版 核。在現有裝置上， 不會更新已安裝的 核版本。 |
| 將新裝置新增至現有部署以目標為目標的物件群組，而不修改部署。 | 部署直接包含特定版本的 Greengrass 核。 | 在新裝置上， 安裝指定的 nucleus 版本。在現有裝置上， 不會更新已安裝的 核版本。 |
| 建立新的部署或修改現有的部署。 | 部署不會直接包含 Greengrass 核。部署直接包含至少一個 AWS提供的元件，或包含取決於 AWS提供的元件或 Greengrass 核的自訂元件。 | 在所有目標裝置上， 會安裝符合所有元件相依性需求的最新版 核，包括您新增至目標物件群組的任何新裝置。 |
| 建立新的部署或修改現有的部署。 | 部署直接包含特定版本的 Greengrass 核。 | 在所有目標裝置上， 安裝指定的 核版本，包括您新增至目標物件群組的任何新裝置。 |
## 執行 OTA 更新
若要執行 OTA 更新，[請建立包含 核元件和要安裝之版本的部署](create-deployments.md)。 [Greengrass 核](greengrass-nucleus-component.md)
# 解除安裝 AWS IoT Greengrass Core 軟體
您可以解除安裝 AWS IoT Greengrass Core 軟體，將其從您不想用作 Greengrass 核心裝置的裝置中移除。您也可以使用這些步驟來清除失敗的安裝。
**解除安裝 AWS IoT Greengrass Core 軟體**
1. 如果您以系統服務方式執行軟體，則必須停止、停用和移除服務。根據您的作業系統執行下列命令。
------
#### [ Linux ]
1. 停止 服務。
```
sudo systemctl stop greengrass.service
```
1. 停用服務。
```
sudo systemctl disable greengrass.service
```
1. 移除 服務。
```
sudo rm /etc/systemd/system/greengrass.service
```
1. 確認已刪除服務。
```
sudo systemctl daemon-reload && sudo systemctl reset-failed
```
------
#### [ Windows (Command Prompt) ]
**注意**
您必須以管理員身分執行命令提示，才能執行這些命令。
1. 停止 服務。
```
sc stop "greengrass"
```
1. 停用服務。
```
sc config "greengrass" start=disabled
```
1. 移除 服務。
```
sc delete "greengrass"
```
1. 重新啟動裝置。
------
#### [ Windows (PowerShell) ]
**注意**
您必須以管理員身分執行 PowerShell，才能執行這些命令。
1. 停止 服務。
```
Stop-Service -Name "greengrass"
```
1. 停用服務。
```
Set-Service -Name "greengrass" -Status stopped -StartupType disabled
```
1. 移除 服務。
+ 對於 PowerShell 6.0 和更新版本：
```
Remove-Service -Name "greengrass" -Confirm:$false -Verbose
```
+ 對於 6.0 之前的 PowerShell 版本：
```
Get-Item HKLM:\SYSTEM\CurrentControlSet\Services\greengrass | Remove-Item -Force -Verbose
```
1. 重新啟動裝置。
------
1. 從裝置移除根資料夾。將 `/greengrass/v2`或 *C：\$1greengrass\$1v2* 取代為根資料夾的路徑。
------
#### [ Linux ]
```
sudo rm -rf /greengrass/v2
```
------
#### [ Windows (Command Prompt) ]
```
rmdir /s /q C:\greengrass\v2
```
------
#### [ Windows (PowerShell) ]
```
cmd.exe /c "rmdir /s /q C:\greengrass\v2"
```
------
1. 從 AWS IoT Greengrass 服務中刪除核心裝置。此步驟會從 移除核心裝置的狀態資訊 AWS 雲端。如果您計劃將 AWS IoT Greengrass Core 軟體重新安裝至具有相同名稱的核心裝置，請務必完成此步驟。
+ 若要從 AWS IoT Greengrass 主控台刪除核心裝置，請執行下列動作：
1. 導覽至 [AWS IoT Greengrass 主控台](https://console.aws.amazon.com/greengrass)。
1. 選擇**核心裝置**。
1. 選擇要刪除的核心裝置。
1. 選擇 **刪除** 。
1. 在確認模態中，選擇**刪除**。
+ 若要使用 刪除核心裝置 AWS Command Line Interface，請使用 [DeleteCoreDevice](https://docs.aws.amazon.com/greengrass/v2/APIReference/API_DeleteCoreDevice.html) 操作。執行下列命令，並以核心裝置的名稱取代 *MyGreengrassCore*。
```
aws greengrassv2 delete-core-device --core-device-thing-name MyGreengrassCore
```