准备、安装和管理 RHEL for Edge 镜像

1. 使用 RHEL 镜像构建器工具制作 RHEL rpm-ostree 镜像。您可以通过 composer-cli 工具中的命令行界面访问 RHEL 镜像构建器，或者在 RHEL web 控制台中使用图形用户界面。
2. 使用 RHEL 安装程序部署镜像。

1. 安装并注册 RHEL 系统
2. 安装 RHEL 镜像构建器
3. 使用 RHEL 镜像构建器，为 RHEL for Edge 容器镜像创建带有自定义的蓝图
4. 在 RHEL 镜像构建器中导入 RHEL for Edge 蓝图
5. 创建嵌入在 OCI 容器中的 RHEL for Edge 镜像，其中包含 webserver 可将提交部署为 OSTree 存储库
6. 下载 RHEL for Edge 容器镜像文件
7. 使用 RHEL for Edge 容器提交部署容器提供存储库
8. 使用 RHEL 镜像构建器，为 RHEL for Edge Installer 镜像创建另一个蓝图
9. 创建一个 RHEL for Edge 安装程序镜像，以便从嵌入的、使用 RHEL for Edge 容器镜像的正在运行的容器中拉取提交
10. 下载 RHEL for Edge 安装程序镜像
11. 运行安装

1. 安装并注册 RHEL 系统
2. 安装 RHEL 镜像构建器
3. 使用 RHEL 镜像构建器，为 RHEL for Edge 镜像创建蓝图
4. 在 RHEL 镜像构建器中导入 RHEL for Edge 蓝图
5. 创建 RHEL for Edge Commit (.tar)镜像
6. 下载 RHEL for Edge 镜像文件
7. 在安装了 RHEL 镜像构建器的同一系统上，安装您要为 RHEL for Edge Commit 内容提供服务的 web 服务器。具体说明请参阅 设置和配置 NGINX
8. 将 RHEL for Edge Commit (.tar)内容提取到正在运行的 web 服务器
9. 创建一个从正在运行的 web 服务器拉取 OSTree 内容的 Kickstart 文件。有关如何修改 Kickstart 来拉取 OSTree 内容的详情，请参阅 提取 RHEL for Edge 镜像提交
10. 在边缘设备上引导 RHEL 安装程序 ISO，并为它提供 Kickstart。

步骤

1. 在虚拟机上安装以下软件包：

   • osbuild-composer
   • composer-cli
   • cockpit-composer
   • bash-completion
   • firewalld

   # dnf install osbuild-composer composer-cli cockpit-composer bash-completion firewalld

   RHEL 镜像构建器安装为 RHEL web 控制台中的一个应用程序。

2. 重启虚拟机

3. 将系统防火墙配置为允许访问 Web 控制台：

   # firewall-cmd --add-service=cockpit && firewall-cmd --add-service=cockpit --permanent

4. 启用 RHEL 镜像构建器。

   # systemctl enable osbuild-composer.socket cockpit.socket --now

   osbuild-composer 和 cockpit 服务在第一次访问时自动启动。

5. 载入 shell 配置脚本，以便在不重启的情况下立即启动 composer-cli 命令的自动完成功能：

   $ source /etc/bash_completion.d/composer-cli

步骤

1. 创建一个存储库源文件，如 /root/repo.toml。例如：

   id = "k8s"
   name = "Kubernetes"
   type = "yum-baseurl"
   url = "https://server.example.com/repos/company_internal_packages/"
   check_gpg = false
   check_ssl = false
   system = false

   type 字段接受以下有效值 yum-baseurl、yum-mirrorlist 和 yum-metalink。

2. 以 TOML 格式保存文件。

3. 将新的第三方源添加到 RHEL 镜像构建器中：

   $ composer-cli sources add <file-name>.toml

验证

1. 检查新源是否已成功添加：

   $ composer-cli sources list

2. 检查新源内容：

   $ composer-cli sources info <source_id>

步骤

1. 创建一个存储库源文件，如 /root/repo.toml。例如，要指定发行版：

   check_gpg = true
   check_ssl = true
   distros = ["rhel-9"]
   id = "rh9-local"
   name = "packages for RHEL"
   system = false
   type = "yum-baseurl"
   url = "https://local/repos/rhel9/projectrepo/"

2. 以 TOML 格式保存文件。

3. 将新的第三方源添加到 RHEL 镜像构建器中：

   $ composer-cli sources add <file-name>.toml

验证

1. 检查新源是否已成功添加：

   $ composer-cli sources list

2. 检查新源内容：

   $ composer-cli sources info <source_id>

步骤

1. 访问您要创建存储库的文件夹：

   $ cd repo/

2. 运行 createrepo_c ，来从 RPM 软件包创建存储库：

   $ createrepo_c .

3. 访问 repodata 的目录：

   $ cd repodata/

4. 为 repomd.xml 文件签名：

   $ gpg -u <_gpg-key-email_> --yes --detach-sign --armor /srv/repo/example/repomd.xml

5. 要在存储库中启用 GPG 签名检查：

   1. 在存储库源中设置 check_repogpg = true。

   2. 输入您要进行检查的 gpgkey。如果您的密钥可以通过 https 使用，请使用密钥的密钥 URL 设置 gpgkeys 字段。您可以根据需要添加任意数量的 URL 密钥。

      以下是一个示例：

      check_gpg = true
      check_ssl = true
      id = "signed local packages"
      name = "repository_name"
      type = "yum-baseurl"
      url = "https://local/repos/projectrepo/"
      check_repogpg = true
      gpgkeys=["https://local/keys/repokey.pub"]

      作为替代方案，直接在 gpgkeys 字段中添加 GPG 密钥，例如：

      check_gpg = true
      check_ssl = true
      check_repogpg
      id = "custom-local"
      name = "signed local packages"
      type = "yum-baseurl"
      url = "https://local/repos/projectrepo/"
      gpgkeys=["https://remote/keys/other-repokey.pub",
      '''-----BEGIN PGP PUBLIC KEY BLOCK-----
      …​
      -----END PGP PUBLIC KEY BLOCK-----''']

      • 如果测试没有找到签名，GPG 工具会显示一个类似如下的错误：

        $ GPG verification is enabled, but GPG signature is not available.
        This may be an error or the repository does not support GPG verification:
        Status code: 404 for http://repo-server/rhel/repodata/repomd.xml.asc (IP: 192.168.1.3)

      • 如果签名无效，GPG 工具会显示一个类似如下的错误：

        repomd.xml GPG signature verification error: Bad GPG signature

步骤

1. 创建 /etc/osbuild-composer/repositories/ 目录来存储存储库覆盖：

   $ sudo mkdir -p /etc/osbuild-composer/repositories

2. 使用与 RHEL 版本相对应的名称，创建一个 JSON 文件。或者，您还可以从 /usr/share/osbuild-composer/ 中复制用于分发的文件，并修改其内容。

   对于 RHEL 9.3，请使用 /etc/osbuild-composer/repositories/rhel-93.json。

3. 将以下结构添加到 JSON 文件中。仅以字符串格式指定以下属性之一：

   • baseurl - 存储库的基本 URL。
   • metalink - 包含有效镜像存储库列表的 metalink 文件的 URL。

   • mirrorlist - 包含有效镜像存储库列表的 mirrorlist 文件的 URL。其余的字段（如 gpgkey ）和 metadata_expire 是可选的。

     例如：

     {
          "x86_64": [
             {
                 "name": "baseos",
                 "baseurl": "http://mirror.example.com/composes/released/RHEL-9/9.0/BaseOS/x86_64/os/",
                 "gpgkey": "-----BEGIN PGP PUBLIC KEY BLOCK-----\n\n (…​)",
                 "check_gpg": true
             }
         ]
     }

     或者，您可以通过将 rhel-version.json 替换为 RHEL 版本（例如：rhel-9.json）来复制您发行版的 JSON 文件。

     $  cp /usr/share/osbuild-composer/repositories/rhel-version.json /etc/osbuild-composer/repositories/

4. 可选：验证 JSON 文件：

   $ json_verify < /etc/osbuild-composer/repositories/rhel-version.json

5. 在 rhel-9.json 文件中编辑 baseurl 路径，并保存。例如：

   $ /etc/osbuild-composer/repositories/rhel-version.json

6. 重启 osbuild-composer.service ：

   $ sudo systemctl restart osbuild-composer.service

步骤

1. 从 /etc/yum.repos.d/redhat.repo 文件中获取 baseurl ：

   # cat /etc/yum.repos.d/redhat.repo
   [AppStream]
   name = AppStream mirror example
   baseurl = https://mirror.example.com/RHEL-9/9.0/AppStream/x86_64/os/
   enabled = 1
   gpgcheck = 0
   sslverify = 1
   sslcacert = /etc/pki/ca1/ca.crt
   sslclientkey = /etc/pki/ca1/client.key
   sslclientcert = /etc/pki/ca1/client.crt
   metadata_expire = 86400
   enabled_metadata = 0

2. 配置存储库覆盖以使用相同的 baseurl，并将 rhsm 设为 true：

   {
       "x86_64": [
           {
               "name": "AppStream mirror example",
               "baseurl": "https://mirror.example.com/RHEL-9/9.0/AppStream/x86_64/os/",
               "gpgkey": "-----BEGIN PGP PUBLIC KEY BLOCK-----\n\n (…​)",
               "check_gpg": true,
               "rhsm": true
           }
       ]
   }

3. 重启 osbuild-composer.service ：

   $ sudo systemctl restart osbuild-composer.service

步骤

1. 从您当前配置的存储库中找到存储库 URL：

   $ sudo yum -v repolist rhel-8-for-x86_64-baseos-rpms | grep repo-baseurl
     Repo-baseurl :

   以下输出是一个示例：

   https://satellite6.example.com/pulp/content/YourOrg/YourEnv/YourCV/content/dist/rhel8/8/x86_64/baseos/os

2. 将硬编码的存储库修改为 Satellite 服务器。

   1. 创建一个具有 0755 权限的存储库目录：

      $ sudo mkdir -pvm 0755 /etc/osbuild-composer/repositories

   2. 将 /usr/share/osbuild-composer/repositories suit.json 中的内容复制到您创建的目录：

      $ sudo cp /usr/share/osbuild-composer/repositories/*.json /etc/osbuild-composer/repositories/

   3. 通过 /content/dist configuration 行更新 Satellite URL 和文件内容：

      $ sudo sed -i -e 's|cdn.redhat.com|satellite6.example.com/pulp/content/YourOrg/YourEnv/YourCV|' /etc/osbuild-composer/repositories/*.json

   4. 验证配置是否被正确替换：

      $ sudo vi /etc/osbuild-composer/repositories/rhel-8.json

3. 重启服务：

   $ sudo systemctl restart osbuild-worker@1.service osbuild-composer.service

4. 覆盖红帽镜像构建器配置中所需的系统存储库，并将 Satellite 存储库的 URL 用作 baseurl。请参阅 覆盖系统存储库。

流程

1. 在 Satellite Web UI 中，导航到 Content > Products，选择您的 产品 ，并点您要使用的存储库。
2. 在 Published 字段中搜索安全 URL (HTTPS)，并复制它。
3. 使用您复制的 URL 作为红帽镜像构建器存储库的 baseurl。请参阅 在 RHEL 镜像构建器中添加自定义第三方存储库。

流程

1. 在 RHEL 系统中，在网页浏览器中访问 https://localhost:9090/。
2. 有关如何远程访问 RHEL 镜像构建器的更多信息，请参阅 使用 RHEL 9 web 控制台管理系统文档。
3. 使用管理用户帐户登录 Web 控制台。
4. 在 Web 控制台中，在左侧菜单中点 Apps。

5. 单击 Image Builder。

   RHEL 镜像构建器仪表盘在右侧窗格中打开。现在，您可以继续为 RHEL for Edge 镜像创建蓝图。

流程

1. 在 RHEL 镜像构建器仪表盘上，点 Create Blueprint。

   此时会打开 Create Blueprint 对话框。

2. 在 Details 页面上：

   1. 输入蓝图的名称，以及可选的描述。点 Next。

3. 可选：在 Packages 页面中：

   1. 在 Available packages 搜索中，输入软件包名称并点击 > 按钮将其移到所选择的软件包字段。搜索并包含尽可能多的软件包。点 Next。

      注意

      除非另有指定，否则这些自定义都是可选的。

4. 在 Kernel 页面中，输入内核名称和命令行参数。
5. 在 File system 页面中，选择 Use automatic partitioning。OSTree 系统不支持文件系统自定义，因为 OSTree 镜像有自己的挂载规则，如只读。点 Next。

6. 在 Services 页面上，您可以启用或禁用服务：

   1. 输入您要启用或禁用的服务名称，用逗号、空格分隔它们或按 Enter 键。点 Next。

7. 在 Firewall 页面中，设置防火墙设置：

   1. 输入 端口，以及您要启用或禁用的防火墙服务。
   2. 点 Add zone 按钮，为每个区域单独管理您的防火墙规则。点 Next。

8. 在 Users 页面中，按照以下步骤添加用户：

   1. 单击 Add user。
   2. 输入 Username、password，以及 SSH key。您还可以单击 Server administrator 复选框，将用户标记为特权用户。点 Next。

9. 在 Groups 页面中，完成以下步骤来添加组：

   1. 点 Add groups 按钮：

      1. 输入 Group name 和 Group ID。您可以添加更多组。点 Next。

10. 在 SSH keys 页面中，添加一个密钥：

    1. 点 Add key 按钮。

       1. 输入 SSH 密钥。
       2. 输入 User。点 Next。

11. 在 Timezone 页面中，设置您的时区设置：

    1. 在 Timezone 字段中输入您要添加到系统镜像的时区。例如，添加以下时区格式："US/Eastern"。

       如果您没有设置时区，系统默认使用 Universal Time, Coordinated (UTC)作为默认值。

    2. 输入 NTP 服务器。点 Next。

12. 在 Locale 页面中完成以下步骤：

    1. 在 Keyboard 搜索字段中，输入您要添加到系统镜像的软件包名称。例如： ["en_US.UTF-8"]。
    2. 在 Languages 搜索字段中，输入您要添加到系统镜像的软件包名称。例如："us"。点 Next。

13. 在 Others 页面中，完成以下步骤：

    1. 在 Hostname 字段中输入您要添加到系统镜像的主机名。如果没有添加主机名，操作系统会决定主机名。
    2. 只对 Simplifier Installer 镜像强制：在 Installation Devices 字段中输入您的系统镜像的有效节点。例如：dev/sda。点 Next。

14. 仅在构建 FIDO 镜像时才强制：在 FIDO device onboarding 页面中完成以下步骤：

    1. 在 Manufacturing server URL 字段中输入以下信息：

       1. 在 DIUN public key insecure 字段中，输入不安全的公钥。
       2. 在 DIUN public key hash 字段中，输入公钥哈希。
       3. 在 DIUN public key root certs 字段中，输入公钥根证书。点 Next。

15. 在 OpenSCAP 页面中，完成以下步骤：

    1. 在 Datastream 字段中输入您要添加到系统镜像的 datastream 补救指令。
    2. 在 Profile ID 字段中，输入您要添加到系统镜像的 profile_id 安全配置文件。点 Next。

16. 仅在构建 Ignition 镜像时才强制：在 Ignition 页面中，完成以下步骤：

    1. 在 Firstboot URL 字段中输入您要添加到系统镜像的软件包名称。
    2. 在 Embedded Data 字段中，拖动或上传您的文件。点 Next。
17. .在 Review 页面中，查看蓝图的详情。点 Create。

流程

1. 在 RHEL 镜像构建器仪表盘上，单击 Create Image。

2. 在 Image output 页面中执行以下步骤：

   1. 在 Select a blueprint 下拉菜单中选择您要使用的蓝图。
   2. 从 Image output type 下拉列表中，选择 “RHEL for Edge Commit (.tar)” 。
   3. 点 Next。

   4. 在 OSTree settings 页面中，输入：

      1. Repository URL ：指定要嵌入镜像中提交的 OSTree 存储库的 URL。例如： http://10.0.2.2:8080/repo/。
      2. Parent commit ：指定之前的提交，如果此时还没有提交，则保留为空。
      3. 在 Ref 文本框中，指定要在哪里创建提交的引用路径。默认情况下，Web 控制台指定 rhel/9/$ARCH/edge。"$ARCH" 值由主机机器决定。点 Next。

   5. 在 Review 页面中，检查自定义并点 Create。

      RHEL 镜像构建器开始为您创建的蓝图创建一个 RHEL for Edge Commit 镜像。

      注意

      镜像创建过程需要 20 分钟才能完成。

验证

1. 检查 RHEL for Edge Commit 镜像创建进度：

   1. 点 Images 选项卡。

流程

1. 在 RHEL 镜像构建器仪表盘上，单击 Create Image。
2. 在 Image output 页面中执行以下步骤：

3. 在 Select a blueprint 下拉菜单中选择您要使用的蓝图。

   1. 从 Image output type 下拉列表中，选择 “RHEL for Edge Container (.tar)” 。
   2. 点 Next。

   3. 在 OSTree 页面中，输入：

      1. Repository URL ：指定要嵌入镜像中提交的 OSTree 存储库的 URL。例如： http://10.0.2.2:8080/repo/。默认情况下，RHEL for Edge 容器镜像的存储库文件夹为 "/repo"。

         要查找要使用的正确 URL，请访问正在运行的容器并检查 nginx.conf 文件。要查找要使用哪个 URL，请访问正在运行的容器并检查 nginx.conf 文件。在 nginx.conf 文件中，找到 root 目录条目，以搜索 /repo/ 文件夹信息。请注意，如果您在使用 RHEL 镜像构建器创建 RHEL for Edge 容器镜像 (.tar) 时没有指定存储库 URL，则会在 nginx.conf 文件中创建默认的 /repo/ 条目。

      2. Parent commit ：指定之前的提交，如果此时还没有提交，则保留为空。
      3. 在 Ref 文本框中，指定要在哪里创建提交的引用路径。默认情况下，Web 控制台指定 rhel/9/$ARCH/edge。"$ARCH" 值由主机机器决定。点 Next。
   4. 在 Review 页面上，检查自定义。点 Save blueprint。

4. 点 Create。

   RHEL 镜像构建器开始为您创建的蓝图创建 RHEL for Edge 容器镜像。

   注意

   镜像创建过程需要 20 分钟才能完成。

验证

1. 检查 RHEL for Edge Container 镜像创建进度：

   1. 点 Images 选项卡。

流程

1. 在 RHEL 镜像构建器仪表盘上，单击 Create Image。

2. 在 Image output 页面中执行以下步骤：

   1. 在 Select a blueprint 下拉菜单中选择您要使用的蓝图。
   2. 从 Image output type 下拉列表中，选择 RHEL for Edge Installer (.iso) 镜像。
   3. 点 Next。

   4. 在 OSTree settings 页面中，输入：

      1. Repository URL ：指定要嵌入镜像中提交的 OSTree 存储库的 URL。例如： http://10.0.2.2:8080/repo/。
      2. 在 Ref 文本框中，指定要在哪里创建提交的引用路径。默认情况下，Web 控制台指定 rhel/9/$ARCH/edge。"$ARCH" 值由主机机器决定。点 Next。
   5. 在 Review 页面上，检查自定义。点 Save blueprint。

3. 点 Create。

   RHEL 镜像构建器开始为您创建的蓝图创建 RHEL for Edge 安装程序镜像。

   注意

   镜像创建过程需要 20 分钟才能完成。

验证

1. 检查 RHEL for Edge Installer 镜像创建进度：

   1. 点 Images 选项卡。

1. 在 More Options 菜单中点 Download。

   RHEL 镜像构建器工具将文件下载到您的默认下载位置。

1. 安装并注册 RHEL 系统
2. 安装 RHEL 镜像构建器
3. 使用 RHEL 镜像构建器，为 RHEL for Edge 容器镜像创建带有自定义的蓝图
4. 在 RHEL 镜像构建器中导入 RHEL for Edge 蓝图
5. 创建嵌入在 OCI 容器中的 RHEL for Edge 镜像，其中已准备好 web 服务器将提交部署为 OSTree 存储库
6. 为 edge-simplified-installer 镜像创建一个蓝图
7. 构建一个简化的 RHEL for Edge 镜像
8. 下载 RHEL for Edge 简化镜像
9. 使用 edge-simplified-installer virt-install 安装原始镜像

流程

1. 以 Tom’s Obvious, Minimal Language (TOML) 格式创建一个纯文本文件，其内容如下：

   name = "simplified-installer-blueprint"
   description = "blueprint for the simplified installer image"
   version = "0.0.1"
   packages = []
   modules = []
   groups = []
   distro = ""
   
   [customizations]
   installation_device = "/dev/vda"
   
   [[customizations.user]]
   name = "admin"
   password = "admin"
   groups = ["users", "wheel"]
   
   [customizations.fdo]
   manufacturing_server_url = "http://10.0.0.2:8080"
   diun_pub_key_insecure = "true"

   注意

   蓝图中的 FDO 自定义是可选的，您可以构建 RHEL for Edge Simplified Installer 镜像，且无错误。

   • name 是蓝图的名称，description 是蓝图的描述信息。
   • 0.0.1 是 Semantic Versioning 方案的版本号。
   • 模块 描述了要安装到镜像中的软件包名称和匹配版本的 glob，例如：软件包名称 = "tmux"，匹配的版本 glob 是 version = "2.9a"。请注意，目前软件包和模块之间没有区别。
   • 组是要安装到镜像中的软件包组，如 anaconda-tools 组软件包。如果您不知道模块和组，请将其留空。
   • Installation-device 是自定义的，可对您的设备进行无人值守安装。
   • manufacturing_server_url 是执行初始设备凭证交换的 URL。
   • name 是要登录到镜像的用户名。
   • password 是您选择的密码。
   • groups 是任何用户组，如 "widget"。

2. 将蓝图推送（导入）到 RHEL 镜像构建器服务器：

   # composer-cli blueprints push blueprint-name.toml

3. 列出现有的蓝图，以检查创建的蓝图是否已成功推送并存在。

   # composer-cli blueprints show blueprint-name

4. 检查蓝图中列出的组件和版本是否有效：

   # composer-cli blueprints depsolve blueprint-name

流程

1. 创建可引导 ISO 镜像。

   # composer-cli compose start-ostree \
   blueprint-name \
   edge-simplified-installer \
   --ref rhel/9/x86_64/edge \
   --url URL-OSTree-repository \

   其中,

   • blueprint-name 是 RHEL for Edge 蓝图名称。
   • edge-simplified-installer 是镜像类型。
   • --ref 指定创建您的提交的位置的引用。

   • --url 是要嵌入到镜像中的提交的 OSTree 存储库的 URL。例如： http://10.0.2.2:8080/repo/。您可以启动一个 RHEL for Edge Container，或设置 web 服务器。请参阅为非基于网络的部署创建 RHEL for Edge 容器镜像，以及设置 web 服务器来安装 RHEL for Edge 镜像。

     这时将显示一个确认已添加到队列中的 composer 进程。它还显示创建的镜像的通用唯一标识符 (UUID) 号。使用 UUID 号来跟踪构建。另外，记录 UUID 号以易于执行进一步的任务。

2. 检查镜像 compose 状态。

   # composer-cli compose status

   输出以以下格式显示状态：

   <UUID> RUNNING date blueprint-name blueprint-version image-type

   注意

   镜像创建过程可能需要最多十分钟才能完成。

   要中断镜像创建过程，请运行：

   # composer-cli compose cancel <UUID>

   要删除现有镜像，请运行：

   # composer-cli compose delete <UUID>

流程

1. 查看 RHEL for Edge 镜像状态。

   # composer-cli compose status

   输出必须显示以下内容：

   $ <UUID> FINISHED date blueprint-name blueprint-version image-type

2. 下载镜像。

   # composer-cli compose image <UUID>

   RHEL 镜像构建器将镜像作为 .iso 文件下载到您运行命令的当前目录路径。

   UUID 号和镜像大小会同时显示。

   $ <UUID>-simplified-installer.iso: size MB

流程

1. 点 RHEL 镜像构建器应用程序右上角中的 Create Blueprint。

   此时会打开一个对话框向导，其中包含蓝图名称和描述字段。

2. 在 Details 页面上：

   1. 输入蓝图的名称，以及可选的描述。点 Next。

3. 可选：在 Packages 页面中，完成以下步骤：

   1. 在 Available packages 搜索中，输入软件包名称并点击 > 按钮将其移到所选的软件包字段。搜索并包含尽可能多的软件包。点 Next。

      注意

      除非另有指定，否则自定义都是可选的。

4. 可选：在 Kernel 页面中，输入内核名称和命令行参数。
5. 可选：在 File system 页面中，选择 Use automatic partitioning。OSTree 系统不支持文件系统自定义，因为 OSTree 镜像有自己的挂载规则，如只读。点 Next。

6. 可选：在 Services 页面上，您可以启用或禁用服务：

   1. 输入您要启用或禁用的服务名称，用逗号、空格分隔它们或按 Enter 键。点 Next。

7. 可选：在 Firewall 页面中，设置防火墙设置：

   1. 输入 端口，以及您要启用或禁用的防火墙服务。
   2. 点 Add zone 按钮，为每个区域单独管理您的防火墙规则。点 Next。

8. 在 Users 页面中，按照以下步骤添加用户：

   1. 单击 Add user。

   2. 输入 Username、password，以及 SSH key。您还可以单击 Server administrator 复选框，将用户标记为特权用户。

      注意

      当您在蓝图自定义中指定用户，然后从该蓝图创建镜像时，蓝图会在安装过程中在 /usr/lib/passwd 目录下创建用户，在 /usr/etc/shadow 下创建密码。您可以使用您为蓝图创建的用户名和密码登录到设备。访问系统后，您必须创建用户，例如，使用 useradd 命令。

      点 Next。

9. 可选：在 Groups 页面中，完成以下步骤来添加组：

   1. 点 Add groups 按钮：

      1. 输入 Group name 和 Group ID。您可以添加更多组。点 Next。

10. 可选：在 SSH keys 页面中，添加一个密钥：

    1. 点 Add key 按钮。

       1. 输入 SSH 密钥。
       2. 输入 User。点 Next。

11. 可选：在 Timezone 页面中，设置您的时区设置：

    1. 在 Timezone 字段中输入您要添加到系统镜像的时区。例如，添加以下时区格式："US/Eastern"。

       如果您没有设置时区，系统默认使用 Universal Time, Coordinated (UTC)作为默认值。

    2. 输入 NTP 服务器。点 Next。

12. 可选：在 Locale 页面中完成以下步骤：

    1. 在 Keyboard 搜索字段中，输入您要添加到系统镜像的软件包名称。例如： ["en_US.UTF-8"]。
    2. 在 Languages 搜索字段中，输入您要添加到系统镜像的软件包名称。例如："us"。点 Next。

13. 必选：在 Others 页面中，完成以下步骤：

    1. 在 Hostname 字段中输入您要添加到系统镜像的主机名。如果没有添加主机名，操作系统会决定主机名。
    2. 必选：在 Installation Devices 字段中输入您的系统镜像的有效节点，以为您的设备启用无人值守安装。例如：dev/sda1。点 Next。

14. 可选：在 FIDO device onboarding 页面中完成以下步骤：

    1. 在 Manufacturing server URL 字段中，输入 制造服务器 URL ，以执行初始设备凭据交换，例如："http://10.0.0.2:8080"。蓝图中的 FDO 自定义是可选的，您可以构建 RHEL for Edge Simplified Installer 镜像，且无错误。
    2. 在 DIUN public key insecure 字段中，输入认证公钥哈希来执行初始设备凭证交换。此字段接受 "true" 值，这意味着这是与制造服务器的不安全连接。例如：manufacturing_server_url="http://${FDO_SERVER}:8080" diun_pub_key_insecure="true"。您必须只使用以下三个选项之一："key insecure"、"key hash"和"key root certs"。

    3. 在 DIUN public key hash 字段中，输入您的公钥的哈希版本。例如：17BD05952222C421D6F1BB1256E0C925310CED4CE1C4FFD6E5CB968F4B73BF73.您可以根据制造服务器的证书生成密钥来获取密钥哈希。要生成密钥哈希，请运行以下命令：

       # openssl x509 -fingerprint -sha256 -noout -in /etc/fdo/aio/keys/diun_cert.pem | cut -d"=" -f2 | sed 's/://g'

       /etc/fdo/aio/keys/diun_cert.pem 是存储在制造服务器中的证书。

    4. 在 DIUN public key root certs 字段中，输入公钥根证书。此字段接受存储在制造服务器中的认证文件的内容。要获取证书文件的内容，请运行以下命令：

       $ cat /etc/fdo/aio/keys/diun_cert.pem.

15. 点 Next。
16. 在 Review 页面中，查看蓝图的详情。点 Create。

流程

1. 访问 mage 构建器仪表盘。
2. 在蓝图表中，找到您要为其构建镜像的蓝图。
3. 导航到 Images 选项卡，再点 Create Image。Create image 向导将打开。

4. 在 Image 输出页面中完成以下步骤：

   1. 从 Select a blueprint 列表中，选择您为 RHEL for Edge Simplified 镜像创建的蓝图。
   2. 从 Image output type 列表中，选择 RHEL for Edge Simplified Installer (.iso)。
   3. 在 Image Size 字段中输入镜像大小。Simplified Installer 镜像所需的最小镜像大小为：
5. 点 Next。

6. 在 OSTree settings 页面中，完成以下步骤：

   1. 在 Repository URL 字段中，输入从中拉取父 OSTree 提交的存储库 URL。
   2. 在 Ref 字段中，输入 ref 分支名称路径。如果没有输入 ref，则使用 distro 的默认 ref。
7. 在 Review 页面中，查看镜像自定义并点 Create。

流程

1. 访问 RHEL 镜像构建器仪表盘。蓝图列表仪表盘将打开。
2. 在蓝图表中，找到您为 RHEL for Edge Simplified Installer 镜像构建的蓝图。
3. 导航到 Images 选项卡。

4. 选择其中一个选项：

   • 下载镜像。
   • 下载镜像的日志以检查元素，并验证是否发现了任何问题。

流程

1. 将 ISO 镜像挂载到您选择的目录：

   # mkdir /mnt/rhel9-install/
   # mount -o loop,ro -t iso9660 /path_directory/installer.iso /mnt/rhel9-install/

   使用 RHEL for Edge 可引导 ISO 镜像的路径替换 /path_directory/installer.iso。

2. 将挂载镜像中的文件复制到 HTTP 服务器 root 中。这个命令创建包含镜像内容的 /var/www/html/rhel9-install/ 目录。

   # mkdir /var/www/html/httpboot/
   # cp -R /mnt/rhel9-install/* /var/www/html/httpboot/
   # chmod -R +r /var/www/html/httpboot/*

   注意

   某些复制方法可以跳过 .treeinfo 文件（一个有效的安装源需要这个文体） 。对于整个目录运行 cp 命令，如此过程所示，可正确复制 .treeinfo。

3. 更新 /var/www/html/EFI/BOOT/grub.cfg 文件：

   1. coreos.inst.install_dev=/dev/sda with coreos.inst.install_dev=/dev/vda
   2. 使用 linuxefi /images/pxeboot/vmlinuz 替换 linux /images/pxeboot/vmlinuz
   3. 使用 initrdefi /images/pxeboot/initrd.img 替换 initrd /images/pxeboot/initrd.img

   4. 使用 coreos.inst.image_url=http://{IP-ADDRESS}/disk.img.xz 替换 coreos.inst.image_file=/run/media/iso/disk.img.xz。

      IP-ADDRESS 是该计算机的 ip 地址，它将充当 http 引导服务器。

4. 启动 httpd 服务：

   # systemctl start httpd.service

   因此，在设置 UEFI HTTP 引导服务器后，您可以使用 UEFI HTTP 引导安装 RHEL for Edge 设备。

流程

1. 设置网络配置以支持 UEFI HTTP 引导。请参阅使用 libvirt 设置 UEFI HTTP 引导。

2. 使用 virt-install 命令从 UEFI HTTP 引导创建 RHEL for Edge 虚拟机。

   # virt-install \
       --name edge-install-image \
       --disk path=”  “, ,format=qcow2
       --ram 3072 \
       --memory 4096 \
       --vcpus 2 \
       --network network=integration,mac=mac_address \
       --os-type linux
       --os-variant rhel9 \
       --cdrom "/var/lib/libvirt/images/”ISO_FILENAME"
       --boot uefi,loader_ro=yes,loader_type=pflash,nvram_template=/usr/share/edk2/ovmf/OVMF_VARS.fd,loader_secure=no
       --virt-type kvm \
       --graphics none \
        --wait=-1
        --noreboot

流程

1. 将 ISO 镜像文件复制到 USB 闪存驱动器中。
2. 将 USB 闪存连接到您要引导的计算机的端口。

3. 从 USB 闪存驱动器引导 ISO 镜像。引导菜单显示以下选项：

   Install Red Hat Enterprise Linux 9
   Test this media & install Red Hat Enterprise Linux 9

4. 选择安装 Red Hat Enterprise Linux 9。这将启动系统安装。

流程

1. 使用以下内容，创建一个 Tom's Obvious, Minimal Language (TOML)格式的纯文本文件：

   name = "system-fips-mode-enabled"
   description = "blueprint with FIPS enabled "
   version = "0.0.1"
   
   [ostree]
   ref= "example/edge"
   url= "http://example.com/repo"
   
   [customizations]
   installation_device = "/dev/vda"
   fips = true
   
   [[customizations.user]]
   name = "admin"
   password = "admin"
   groups = ["users", "wheel"]
   
   [customizations.fdo]
   manufacturing_server_url = "https://fdo.example.com"
   diun_pub_key_insecure = true

2. 将蓝图导入到 RHEL 镜像构建器服务器中：

   # composer-cli blueprints push <blueprint-name>.toml

3. 列出现有的蓝图，以检查创建的蓝图是否已成功导入且存在：

   # composer-cli blueprints show <blueprint-name>

4. 检查蓝图中列出的组件和版本是否有效：

   # composer-cli blueprints depsolve <blueprint-name>

5. 提供要嵌入到镜像中的提交的 OSTree 存储库，例如 http://10.0.2.2:8080/repo。如需更多信息，请参阅 建立一个 UEFI HTTP 引导服务器。

6. 创建可引导的 ISO 镜像：

   # composer-cli compose start-ostree \ <blueprint-name> \ edge-simplified-installer \ --ref rhel/8/x86_64/edge \ --url <URL-OSTree-repository> \

7. 查看 RHEL for Edge 镜像状态：

   # composer-cli compose status
   …
   $ <UUID> FINISHED <date> <blueprint-name> <blueprint-version> <image-type>
   …

8. 下载镜像：

   # composer-cli compose image <UUID>

   RHEL 镜像构建器将镜像作为 .iso 文件下载到当前目录路径。UUID 号和镜像大小会同时显示：

   $ <UUID>-simplified-installer.iso: <size> MB

9. 从 UEFI HTTP Boot 服务器创建 RHEL for Edge 虚拟机，例如：

   # virt-install \ --name edge-device --disk path="/var/lib/libvirt/images/edge-device.qcow2",size=5,format=qcow2 \ --memory 4096 \ --vcpus 2 \ --network network=default \ --os-type linux \ --os-variant rhel8.9 \ --cdrom /var/lib/libvirt/images/<UUID>-simplified-installer.iso \ --boot uefi,loader.secure=false \ --virt-type kvm \ --graphics none \ --wait=-1 \ --noreboot

验证

1. 使用您在蓝图中配置的用户名和密码登录到创建的虚拟机。

2. 检查是否启用了 FIPS 设置：

   $ cat /proc/sys/crypto/fips_enabled
   1

1. 安装并注册 RHEL 系统
2. 安装 RHEL 镜像构建器
3. 使用 RHEL 镜像构建器，使用 RHEL for Edge Minimal Raw 镜像自定义创建一个蓝图
4. 在 RHEL 镜像构建器中导入 RHEL for Edge 蓝图
5. 创建一个 RHEL for Edge Minimal Raw 镜像
6. 下载并解压缩 RHEL for Edge Minimal Raw 镜像
7. 从解压缩的 Raw 镜像创建可引导 USB 驱动器
8. 部署 RHEL for Edge Minimal Raw 镜像

流程

1. 以 Tom’s Obvious, Minimal Language (TOML) 格式创建一个纯文本文件，其内容如下：

   name = "minimal-raw-blueprint"
   description = "blueprint for the Minimal Raw image"
   version = "0.0.1"
   packages = []
   modules = []
   groups = []
   distro = ""
   
   [[customizations.user]]
   name = "admin"
   password = "admin"
   groups = ["users", "wheel"]

   • name 是蓝图的名称，description 是蓝图的描述。
   • 0.0.1 是遵循 Semantic Versioning 方案的版本号。
   • 模块描述要安装到镜像中的软件包名称和匹配版本 glob，例如：软件包 name = "tmux"，匹配的版本 glob 是 version = "2.9a"。目前软件包和模块之间没有区别。
   • 组是要安装到镜像中的软件包组，如 anaconda-tools 组软件包。如果您不知道模块和组，请将其留空。

   • 在 customizations.user 下：

     • name 是登录到镜像的用户名
     • 密码是 您选择的密码
     • 组是 任何用户组，如 "widget"

2. 将蓝图导入到 RHEL 镜像构建器服务器中：

   # composer-cli blueprints push <blueprint_name>.toml

3. 检查系统上是否有蓝图：

   # composer-cli blueprints list

4. 检查蓝图中组件、版本及其依赖项的有效性：

   # composer-cli blueprints depsolve <blueprint_name>

流程

1. 构建镜像。

   # composer-cli compose start <blueprint_name> minimal-raw

   • <blueprint_name > 是 RHEL for Edge 蓝图名称
   • minimal-raw 是镜像类型

2. 检查镜像 compose 状态。

   # composer-cli compose status

   输出以以下格式显示状态：

   # <UUID> RUNNING date <blueprint_name> blueprint-version minimal-raw

流程

1. 查看 RHEL for Edge Minimal Raw image compose 状态。

   # composer-cli compose status

   输出必须显示以下详情：

   $ <UUID> FINISHED date <blueprint_name> <blueprint_version> minimal-raw

2. 下载镜像：

   # composer-cli compose image <UUID>

   镜像构建器将镜像下载到您的工作目录中。以下输出是一个示例：

   3f9223c1-6ddb-4915-92fe-9e0869b8e209-raw.img.xz

3. 解压缩镜像：

   $ xz -d <UUID>-raw.img.xz

流程

1. 将 USB 闪存驱动器连接到要引导自定义镜像的计算机。
2. 打开系统。

3. 从 USB 闪存驱动器引导 RHEL for Edge Minimal Raw 镜像。引导菜单显示以下选项：

   Install Red Hat Enterprise Linux 9
   Test this media & install Red Hat Enterprise Linux 9

4. 选择Install Red Hat Enterprise Linux 9。这将启动系统安装。

验证

1. 使用您在蓝图中配置的用户名和密码引导到镜像。

   1. 检查发行版本：

      $ cat /etc/os-release

   2. 列出系统中的块设备：

      $ lsblk

流程

1. 为 rhel-edge-container 镜像类型创建一个蓝图，例如：

   name = "rhel-edge-container-no-users"
   description = ""
   version = "0.0.1"

2. 构建 rhel-edge-container 镜像：

   # composer-cli compose start-ostree <rhel-edge-container-no-users> rhel-edge-container

3. 检查镜像是否已就绪：

   # composer-cli compose status

4. 将 rhel-edge-container 镜像下载为一个 .tar 文件：

   # composer-cli compose image <UUID>

5. 将 RHEL for Edge 容器导入到 Podman 中：

   $ skopeo copy oci-archive:_<UUID>_-container.tar \
   containers-storage:localhost/rfe-93-mirror:latest

6. 启动容器并使用端口 8080 使其可用：

   $ podman run -d --rm --name <rfe-93-mirror> -p 8080:8080 localhost/<rfe-93-mirror>

7. 为 edge-raw-image 镜像类型创建一个蓝图，例如：

   name = "<edge-raw>"
   description = ""
   version = "0.0.1"
   [[customizations.user]]
   name = "admin"
   password = "admin"
   groups = ["wheel"]

8. 通过提供 RHEL Edge 容器来构建 RHEL for Edge Raw 镜像：

   # composer-cli compose start-ostree edge-raw edge-raw-image \
   --url http://10.88.0.1:8080/repo

9. 将 RHEL for Edge Raw 镜像下载为 .raw 文件：

   # composer-cli compose image <UUID>

10. 解压缩 RHEL for Edge Raw 镜像：

    # xz --decompress <UUID>>-image.raw.xz

流程

1. 创建一个 Butane Config 文件，并将它保存为 .bu 格式。对于 RHEL for Edge 镜像，您必须将 variant 条目指定为 r4e，将 version 条目指定为 1.0.0。版本 1.0.0 上的 butane r4e 变体以 Ignition spec 版本 3.3.0 为目标。以下是 Butane Config YAML 文件的一个示例：

   variant: r4e
   version: 1.0.0
   ignition:
     config:
       merge:
         - source: http://192.168.122.1:8000/sample.ign
   passwd:
     users:
       - name: core
         groups:
           - wheel
         password_hash: password_hash_here
         ssh_authorized_keys:
           - ssh-ed25519 some-ssh-key-here
   storage:
     files:
       - path: /etc/NetworkManager/system-connections/enp1s0.nmconnection
         contents:
           inline: |
             [connection]
             id=enp1s0
             type=ethernet
             interface-name=enp1s0
             [ipv4]
             address1=192.168.122.42/24,192.168.122.1
             dns=8.8.8.8;
             dns-search=
             may-fail=false
             method=manual
         mode: 0600
       - path: /usr/local/bin/startup.sh
         contents:
           inline: |
             #!/bin/bash
             echo "Hello, World!"
         mode: 0755
   systemd:
     units:
       - name: hello.service
         contents: |
           [Unit]
           Description=A hello world
           [Install]
           WantedBy=multi-user.target
         enabled: true
       - name: fdo-client-linuxapp.service
         dropins:
           - name: log_trace.conf
             contents: |
               [Service]
               Environment=LOG_LEVEL=trace

2. 运行以下命令以使用 Butane Config YAML 文件，并生成一个 JSON 格式的 Ignition 配置：

   $ ./path/butane example.bu
   {"ignition":{"config":{"merge":[{"source":"http://192.168.122.1:8000/sample.ign"}]},"timeouts":{"httpTotal":30},"version":"3.3.0"},"passwd":{"users":[{"groups":["wheel"],"name":"core","passwordHash":"password_hash_here","sshAuthorizedKeys":["ssh-ed25519 some-ssh-key-here"]}]},"storage":{"files":[{"path":"/etc/NetworkManager/system-connections/enp1s0.nmconnection","contents":{"compression":"gzip","source":"data:;base64,H4sIAAAAAAAC/0yKUcrCMBAG3/csf/ObUKQie5LShyX5SgPNNiSr0NuLgiDzNMPM8VBFtHzoQjkxtPp+ITsrGLahKYyyGtoqEYNKwfeZc32OC0lKDb179rfg/HVyPgQ3hv8w/v0WT0k7T+7D/S1Dh7S4MRU5h1XyzqvsHVRg25G4iD5kp1cAAAD//6Cvq2ihAAAA"},"mode":384},{"path":"/usr/local/bin/startup.sh","contents":{"source":"data:;base64,IyEvYmluL2Jhc2gKZWNobyAiSGVsbG8sIFdvcmxkISIK"},"mode":493}]},"systemd":{"units":[{"contents":"[Unit]\nDescription=A hello world\n[Install]\nWantedBy=multi-user.target","enabled":true,"name":"hello.service"},{"dropins":[{"contents":"[Service]\nEnvironment=LOG_LEVEL=trace\n","name":"log_trace.conf"}],"name":"fdo-client-linuxapp.service"}]}}

   运行 Butane Config YAML 文件以检查并生成 Ignition Config JSON 文件后，在使用不支持的字段时（如分区）时可能会收到警告。您可以修复这些字段并重新运行检查。

流程

1. 点右上角的 Create Blueprint。

   此时会打开一个对话框向导，其中包含蓝图名称和描述字段。

   • 在 Details 页面上：

     • 输入蓝图的名称，以及可选的描述。点 Next。

   • 在 Ignition 页面中，完成以下步骤：

     • 在 Firstboot URL 字段中，输入指向要在第一次引导期间获取的 Ignition 配置的 URL。
     • 在 Embedded Data 字段中，拖放或上传 base64 编码的 Ignition Configuration 文件。点 Next。
   • 检查镜像详情并点 Create。

流程

1. 以 Tom’s Obvious, Minimal Language (TOML) 格式创建一个纯文本文件，其内容如下：

   name = "simplified-installer-blueprint"
   description = "Blueprint with Ignition for the simplified installer image"
   version = "0.0.1"
   packages = []
   modules = []
   groups = []
   distro = ""
   
   [customizations.ignition.embedded]
   config = "eyJ --- BASE64 STRING TRIMMED --- 19fQo="

   其中：

   • name 是蓝图的名称，description 是蓝图的描述。
   • version 是根据语义版本控制方案的版本号。
   • modules 和 packages 描述了要安装到镜像中的软件包名称和匹配版本 glob。例如，软件包 name = "tmux" ，匹配版本 glob 是 version = "3.3a" 。请注意，目前软件包和模块之间没有区别。

   • groups 是要安装到镜像中的软件包组。例如 groups = "anaconda-tools" 组软件包。如果您不知道模块和组，请将其留空。

     警告

     如果要使用 Ignition 创建用户，则无法同时使用 FDO 自定义创建用户。您可以使用 Ignition 创建用户，并使用 FDO 复制配置文件。但是，如果您要创建用户，请使用 Ignition 或 FDO 创建他们，但不能同时创建它们。

2. 将蓝图推送（导入）到镜像构建器服务器：

   # composer-cli blueprints push blueprint-name.toml

3. 列出现有的蓝图，以检查创建的蓝图是否已成功推送并存在。

   # composer-cli blueprints show blueprint-name

4. 检查蓝图中列出的组件和版本是否有效：

   # composer-cli blueprints depsolve blueprint-name

流程

1. 使用以下内容，创建一个 Tom 的 Obvious, Minimal Language (TOML)格式的蓝图：

   name = "vmdk-image"
   description = "Blueprint with Ignition for the vmdk image"
   version = "0.0.1"
   packages = ["open-vm-tools"]
   modules = []
   groups = []
   distro = ""
   
   [[customizations.user]]
   name = "admin"
   password = "admin"
   groups = ["wheel"]
   
   [customizations.ignition.firstboot]
   url = http://<IP_address>:8080/config.ig

   其中：

   • name 是蓝图的名称，description 是蓝图的描述。
   • version 是根据语义版本控制方案的版本号。
   • modules 和 packages 描述了要安装到镜像中的软件包名称和匹配版本 glob。例如，软件包 name = "open-vm-tools" 。请注意，目前软件包和模块之间没有区别。
   • groups 是要安装到镜像中的软件包组。例如 groups = "anaconda-tools" 组软件包。如果您不知道模块和组，请将其留空。
   • customizations.user 创建一个用户名和密码来登录到虚拟机。

   • customizations.ignition.firstboot 包含提供 Ignition 配置文件的 URL。

     注意

     默认情况下，open-vm-tools 软件包不包含在 edge-vsphere 镜像中。如果需要这个软件包，则必须将其包含在蓝图自定义中。

2. 将蓝图导入到镜像构建器服务器中：

   # composer-cli blueprints push <blueprint-name>.toml

3. 列出现有的蓝图，以检查创建的蓝图是否已成功推送并存在：

   # composer-cli blueprints show <blueprint-name>

4. 检查蓝图中列出的组件和版本是否有效：

   # composer-cli blueprints depsolve <blueprint-name>

流程

1. 启动 .vmdk 镜像的 compose：

   # composer-cli compose start start-ostree <blueprint-name> edge-vsphere --<url>

   -- <url> 是存储库的 URL，例如：http://10.88.0.1:8080/repo。

   这时将显示一个确认已添加到队列中的 composer 进程。它还显示创建的镜像的通用唯一标识符 (UUID) 号。使用 UUID 号来跟踪构建。另外，为将来的任务保留 UUID 号。

2. 检查镜像的 compose 状态：

   # composer-cli compose status

   输出以以下格式显示状态：

   $ <UUID> RUNNING date <blueprint-name>  <blueprint-version> edge-vsphere

3. compose 过程完成后，下载生成的镜像文件：

   # composer-cli compose image <UUID>

流程

1. 导航到您下载 .vmdk 镜像的目录。

2. 通过执行以下步骤在 vSphere 上启动镜像：

   1. 将 .vmdk 镜像导入到 vSphere ：

      $ govc import.vmdk ./composer-api.vmdk foldername

   2. 在 vSphere 中创建虚拟机而不开机：

      govc vm.create \
      -net="VM Network" -net.adapter=vmxnet3 \
      -disk.controller=pvscsi -on=false \
      -m=4096 -c=2 -g=rhel9_64Guest \
      -firmware=efi vm_name govc vm.disk.attach \
      -disk=”foldername/composer-api.vmdk” govc vm.power -on\
      -vm vm_name -link=false \
       vm_name

   3. 打开虚拟机：

      govc vm.power -on vmname

   4. 检索虚拟机 IP 地址：

      HOST=$(govc vm.ip vmname)

   5. 使用您在蓝图中指定的用户名和密码，使用 SSH 登录到虚拟机：

      $ ssh admin@HOST

流程

1. 使用以下内容，创建一个 Tom 的 Obvious, Minimal Language (TOML)格式的蓝图：

   name = "ami-edge-image"
   description = "Blueprint for Edge AMI image"
   version = "0.0.1"
   packages = ["cloud-init"]
   modules = []
   groups = []
   distro = ""
   
   [[customizations.user]]
   name = "admin"
   password = "admin"
   groups = ["wheel"]
   
   [customizations.ignition.firstboot]
   url = http://<IP_address>:8080/config.ig

   其中：

   • name 是蓝图的名称，description 是蓝图的描述。
   • version 是根据语义版本控制方案的版本号。
   • modules 和 packages 描述了要安装到镜像中的软件包名称和匹配版本 glob。例如，软件包 name = "open-vm-tools" 。请注意，目前软件包和模块之间没有区别。
   • groups 是要安装到镜像中的软件包组。例如 groups = "wheel" 。如果您不知道模块和组，请将其留空。
   • customizations.user 创建一个用户名和密码来登录到虚拟机。

   • customizations.ignition.firstboot 包含提供 Ignition 配置文件的 URL。

     注意

     默认情况下，open-vm-tools 软件包不包含在 edge-vsphere 镜像中。如果需要这个软件包，则必须将其包含在蓝图自定义中。

2. 将蓝图导入到镜像构建器服务器中：

   # composer-cli blueprints push <blueprint-name>.toml

3. 列出现有的蓝图，以检查创建的蓝图是否已成功推送并存在：

   # composer-cli blueprints show <blueprint-name>

4. 检查蓝图中列出的组件和版本是否有效：

   # composer-cli blueprints depsolve <blueprint-name>

流程

1. 启动 edge-ami 镜像的 compose：

   # composer-cli compose start-ostree <blueprint-name> edge-ami –ref rhel/9/x86_64/edge --url <ostree repo url>

   --<ostree repo url> 是您的 repo 的 URL，例如：http://10.88.0.1:8080/{<blueprint-name>}/repo。

   这时将显示一个确认已添加到队列中的 composer 进程。它还显示创建的镜像的通用唯一标识符 (UUID) 号。使用 UUID 号来跟踪构建。另外，为将来的任务保留 UUID 号。

2. 检查镜像的 compose 状态：

   # composer-cli compose status

   输出以以下格式显示状态：

   $ <UUID> RUNNING date <blueprint-name> <blueprint-version> edge-ami

3. compose 过程完成后，下载生成的镜像文件：

   # composer-cli compose image <UUID>

流程

1. 配置 aws-cli 工具：

   $ aws configure

   1. 配置您的配置文件。运行命令并输入您的 Access key ID 凭证、Secret access key、Default region name 和 default output 名称：

      $ aws configure --profile

2. 列出现有存储桶：

   $ aws s3 ls

3. 将您的镜像上传到 S3:

   $ aws s3 cp <path_to_image/image> s3://<your_bucket_name>

4. 列出 S3 存储桶中的镜像：

   $ aws s3 ls s3://<your_bucket_name>

5. 创建一个 container-simple.json 文件。将 "URL" 内容替换为 S3 存储桶。例如：s3://rhel-edge-ami-us-west-2/2ba3c125-cc58-4cc0-861a-4cc78e892df6-image.raw。

   {
     "Description": "RHEL for Edge image",
     "Format": "edge-ami",
     "Url": "s3://rhel-edge-ami-us-west-2/UUID-image.raw"
   }

6. 将 edge.ami 镜像作为 EC2 快照导入到 S3 存储桶。

   注意

   EC2 镜像必须位于与您创建的 S3 存储桶一样的区域。

   $ aws ec2 import-snapshot --description "RHEL edge" \ --disk-container file://container-simple.json --region us-west-2

   以下 .json ：是命令输出的一个示例：

   {
     "Description": "RHEL for Edge image",
     "Format": "edge-ami",
     "Url": "s3://rhel-edge-ami-us-west-2/UUID-image.raw"
   }

7. 记录来自 .json 文件的 "ImportTaskId" 值。使用它来检查导入状态。在本例中，"ImportTaskId"是 import-snap-0f3055c4b7a454c85。

8. 使用上一步中的输出 .json 文件中的 "ImportTaskId" 值来检查快照的导入状态：

   $ aws ec2 describe-import-snapshot-tasks \
   --import-task-ids import-snap-0f3055c4b7a454c85
   {
       "ImportSnapshotTasks": [
           {
               "Description": "RHEL edge",
               "ImportTaskId": "import-snap-0f3055c4b7a454c85",
               "SnapshotTaskDetail": {
                   "Description": "RHEL edge",
                   "DiskImageSize": 10737418240.0,
                   "Format": "RAW",
                   "SnapshotId": "snap-001b267e752039eab",
                   "Status": "completed",
                   "Url": "s3://rhel-edge-ami-us-west-2/2ba3c125-cc58-4cc0-861a-4cc78e892df6-image.raw",
                   "UserBucket": {
                       "S3Bucket": "rhel-edge-ami-us-west-2",
                       "S3Key": "2ba3c125-cc58-4cc0-861a-4cc78e892df6-image.raw"
                   }
               },
               "Tags": []
           }
       ]
   }

   运行这个命令，直到 "Status" 标记为"completed"。之后，您可以访问 EC2 ，来从快照创建 AMI 镜像，并启动它。

1. 访问菜单中的 EC2，并在 AWS 控制台中选择正确的区域。镜像必须具有 available 状态，以表示它已被成功上传。

2. 在仪表盘上，选择镜像并点 Launch。

   在启动新实例时，您必须选择 UEFI 作为引导模式，并为 EC2 镜像选择至少 4GB RAM。

3. 您可以使用通过 Ignition 配置创建的用户名和密码登录到 AWS 上的 edge-ami。

1. 设备联系制造服务器
2. 制造服务器为该设备生成一个所有权凭证和设备凭证。
3. 所有权凭证被传到所有者加入服务器。

4. 所有者加入服务器将所有权凭据传给 Rendezvous 服务器，这将创建一个所有权凭证到所有者的映射。
5. 设备客户端读取设备凭据。
6. 设备客户端连接到网络。
7. 连接到网络后，设备客户端会联系 Rendezvous 服务器。
8. Rendezvous 服务器将所有者端点 URL 发送给设备客户端 ，并注册该设备。
9. 设备客户端连接到 Rendezvous 服务器共享的所有者加入服务器。
10. 设备通过使用设备密钥签名语句来证明它是正确的设备。
11. 所有者加入服务器通过使用所有者凭证的最后密钥签署声明来证明自己是正确的。
12. 所有者加入服务器将设备的信息传给 Service Info API 服务器。
13. Service info API 服务器发送设备的配置。
14. 设备已加入。

1. 安装并注册 RHEL 系统
2. 安装 RHEL 镜像构建器

3. 通过使用 RHEL 镜像构建器，为 rhel-edge-container 镜像类型创建一个带有 RHEL 自定义的蓝图。

   name = "rhel-edge-container"
   description = "Minimal RHEL for Edge Container blueprint"
   version = "0.0.1"

4. 在 RHEL 镜像构建器中导入 RHEL for Edge 容器蓝图
5. 创建 RHEL for Edge 容器镜像
6. 使用 RHEL for Edge 容器镜像提供 OSTree 提交，其稍后在构建 RHEL for Edge Simplified Installer 镜像类型时使用

7. 使用存储设备路径的自定义和 FDO 自定义为 edge-simplified-installer 镜像类型创建一个蓝图

   name = "rhel-edge-simplified-installer-with-fdo"
   description = "Minimal RHEL for Edge Simplified Installer with FDO blueprint"
   version = "0.0.1"
   packages = []
   modules = []
   groups = []
   distro = ""
   
   [customizations]
   installation_device = "/dev/vda"
   
   [customizations.fdo]
   manufacturing_server_url = "http://10.0.0.2:8080"
   diun_pub_key_insecure = "true"

8. 构建简化的安装程序 RHEL for Edge 镜像
9. 下载 RHEL for Edge 简化的安装程序镜像
10. 此时，FDO 服务器基础架构应该已启动并运行，并配置了由 service-info API 服务器处理的特定的加入详情，这是所有者基础架构的一部分。
11. 将简化的安装程序 ISO 镜像安装到设备。FDO 客户端在简化的安装程序 ISO 上运行，并且 UEFI 目录结构使镜像可启动。
12. 网络配置可让设备连接到制造服务器，以执行初始设备凭据交换。
13. 系统到达端点后，会为该设备创建设备凭据。
14. 该设备使用设备凭证访问 Rendezvous 服务器，它会根据 Rendezvous 服务器具有的凭证来检查加密凭证，然后 Rendezvous 服务器将设备重定向到所有者服务器。
15. 设备联系所有者服务器。它们建立一个相互信任，并根据 Service-info API 服务器的配置进行加入的最终步骤。例如，它会在设备中安装 SSH 密钥，传输文件，创建用户，运行命令，加密文件系统等。

流程

1. 在 /etc/fdo 目录中生成密钥和证书：

   $ for i in "diun" "manufacturer" "device-ca" "owner"; do fdo-admin-tool generate-key-and-cert $i; done
   $ ls keys
   device_ca_cert.pem device_ca_key.der diun_cert.pem diun_key.der manufacturer_cert.pem manufacturer_key.der owner_cert.pem owner_key.der

2. 检查在 /etc/fdo/keys 目录中创建的密钥和证书：

   $ tree keys

   您可以看到以下输出：

   – device_ca_cert.pem
   – device_ca_key.der
   – diun_cert.pem
   – diun_key.dre
   – manufacturer_cert.pem
   – manufacturer_key.der
   – owner_cert.pem
   – owner_key.pem

流程

1. 安装 fdo-admin-cli 软件包：

   # dnf install -y fdo-admin-cli

2. 检查是否安装了 fdo-manufacturing-server RPM 软件包：

   $ rpm -qa | grep fdo-manufacturing-server --refresh

3. 检查是否已正确安装了这些文件：

   $ ls /usr/share/doc/fdo

   您可以看到以下输出：

   Output:
   manufacturing-server.yml
   owner-onboarding-server.yml
   rendezvous-info.yml
   rendezvous-server.yml
   serviceinfo-api-server.yml

4. 可选：检查每个文件的内容，例如：

   $ cat /usr/share/doc/fdo/manufacturing-server.yml

5. 配置制造服务器。您必须提供以下信息：

   • 制造服务器 URL
   • Rendezvous 服务器的 IP 地址或 DNS 名称

   • 您生成的密钥和证书的路径。请参阅 生成密钥和证书。

     您可以在 /usr/share/doc/fdo/manufacturing-server.yml 目录中找到制造服务器配置文件的示例。以下是创建并保存在 /etc/fdo 目录中的一个 manufacturing server.yml 示例。它包含您创建的目录、证书、密钥的路径，会合服务器 IP 地址和默认端口。

     session_store_driver:
       Directory:
         path: /etc/fdo/stores/manufacturing_sessions/
     ownership_voucher_store_driver:
       Directory:
         path: /etc/fdo/stores/owner_vouchers
     public_key_store_driver:
       Directory:
         path: /etc/fdo/stores/manufacturer_keys
     bind: "0.0.0.0:8080"
     protocols:
       plain_di: false
       diun:
         mfg_string_type: SerialNumber
         key_type: SECP384R1
         allowed_key_storage_types:
           - Tpm
           - FileSystem
         key_path: /etc/fdo/keys/diun_key.der
         cert_path: /etc/fdo/keys/diun_cert.pem
     rendezvous_info:
       - deviceport: 8082
         ip_address: 192.168.122.99
         ownerport: 8082
         protocol: http
     manufacturing:
       manufacturer_cert_path: /etc/fdo/keys/manufacturer_cert.pem
       device_cert_ca_private_key: /etc/fdo/keys/device_ca_key.der
       device_cert_ca_chain: /etc/fdo/keys/device_ca_cert.pem
       owner_cert_path: /etc/fdo/keys/owner_cert.pem
       manufacturer_private_key: /etc/fdo/keys/manufacturer_key.der

6. 启动制造服务器。

   1. 检查 systemd 单元文件是否在服务器中：

      # systemctl list-unit-files | grep fdo | grep manufacturing
      fdo-manufacturing-server.service disabled disabled

   2. 启用并启动制造服务器。

      # systemctl enable --now fdo-manufacturing-server.service

   3. 在防火墙中打开默认端口：

      # firewall-cmd --add-port=8080/tcp --permanent
      # systemctl restart firewalld

   4. 确保该服务正在侦听端口 8080:

      # ss -ltn

7. 使用简化的安装程序将 RHEL for Edge 安装到您的系统上。请参阅 构建简化的安装程序镜像以提供 RHEL for Edge 镜像。

流程

1. 安装 fdo-rendezvous-server RPM 软件包：

   # dnf install -y fdo-rendezvous-server

2. 创建 rendezvous-server.yml 配置文件，包括制造商证书的路径。您可以在 /usr/share/doc/fdo/rendezvous-server.yml 中找到示例。以下示例显示了保存在 /etc/fdo/rendezvous-server.yml 中的配置文件。

   storage_driver:
     Directory:
       path: /etc/fdo/stores/rendezvous_registered
   session_store_driver:
     Directory:
       path: /etc/fdo/stores/rendezvous_sessions
   trusted_manufacturer_keys_path: /etc/fdo/keys/manufacturer_cert.pem
   max_wait_seconds: ~
   bind: "0.0.0.0:8082"

3. 检查 Rendezvous 服务器服务状态：

   # systemctl list-unit-files | grep fdo | grep rende
   fdo-rendezvous-server.service disabled disabled

   1. 如果停止并禁用该服务，请启用并启动它：

      # systemctl enable --now fdo-rendezvous-server.service

4. 检查服务器是否在侦听默认配置的端口 8082 ：

   # ss -ltn

5. 如果在这个服务器上配置了防火墙，请打开端口：

   # firewall-cmd --add-port=8082/tcp --permanent
   # systemctl restart firewalld

流程

1. 在这个服务器中安装所需的 RPM：

   # dnf install -y fdo-owner-cli fdo-owner-onboarding-server

2. 准备 owner-onboarding-server.yml 配置文件，并将其保存到 /etc/fdo/ 目录中。包括您已复制的证书的路径，以及有关此文件中发布所有者服务器服务的信息。

   以下是 /usr/share/doc/fdo/owner-onboarding-server.yml 中的一个示例。您可以查找对服务信息 API 的引用，如 URL 或身份验证令牌。

   ---
   ownership_voucher_store_driver:
     Directory:
       path: /etc/fdo/stores/owner_vouchers
   session_store_driver:
     Directory:
       path: /etc/fdo/stores/owner_onboarding_sessions
   trusted_device_keys_path: /etc/fdo/keys/device_ca_cert.pem
   owner_private_key_path: /etc/fdo/keys/owner_key.der
   owner_public_key_path: /etc/fdo/keys/owner_cert.pem
   bind: "0.0.0.0:8081"
   service_info_api_url: "http://localhost:8083/device_info"
   service_info_api_authentication:
     BearerToken:
       token: Kpt5P/5flBkaiNSvDYS3cEdBQXJn2Zv9n1D50431/lo=
   owner_addresses:
     - transport: http
       addresses:
         - ip_address: 192.168.122.149

3. 创建和配置服务信息 API。

   1. 为加入添加自动信息，如要用户创建、要复制或创建的文件、要执行的命令、要加密的磁盘等。使用 /usr/share/doc/fdo/serviceinfo-api-server.yml 中的服务信息 API 配置文件示例作为模板，来在 /etc/fdo/ 下创建配置文件。

      ---
      service_info:
        initial_user:
          username: admin
          sshkeys:
          - "ssh-rsa AAAA...."
        files:
        - path: /root/resolv.conf
          source_path: /etc/resolv.conf
        commands:
        - command: touch
          args:
          - /root/test
          return_stdout: true
          return_stderr: true
        diskencryption_clevis:
        - disk_label: /dev/vda4
          binding:
            pin: tpm2
            config: "{}"
          reencrypt: true
        additional_serviceinfo: ~
      bind: "0.0.0.0:8083"
      device_specific_store_driver:
        Directory:
          path: /etc/fdo/stores/serviceinfo_api_devices
      service_info_auth_token: Kpt5P/5flBkaiNSvDYS3cEdBQXJn2Zv9n1D50431/lo=
      admin_auth_token: zJNoErq7aa0RusJ1w0tkTjdITdMCWYkndzVv7F0V42Q=

4. 检查 systemd 单元的状态：

   # systemctl list-unit-files | grep fdo
   fdo-owner-onboarding-server.service        disabled        disabled
   fdo-serviceinfo-api-server.service         disabled        disabled

   1. 如果停止并禁用该服务，请启用并启动它：

      # systemctl enable --now fdo-owner-onboarding-server.service
      # systemctl enable --now fdo-serviceinfo-api-server.service

      注意

      每次更改配置文件时，都必须重启 systemd 服务。

5. 检查服务器是否在侦听默认配置的端口 8083 ：

   # ss -ltn

6. 如果在这个服务器上配置了防火墙，请打开端口：

   # firewall-cmd --add-port=8081/tcp --permanent
   # firewall-cmd --add-port=8083/tcp --permanent
   # systemctl restart firewalld

流程

1. 通过在设备上引导 RHEL for Edge Simplified installer 镜像来启动安装过程。您可以使用 CD-ROM 或 USB 闪存驱动器安装它，例如：

2. 通过终端验证设备是否已达到制造服务，以执行初始设备凭据交换，并且生成所有权凭证。

   您可以在由 manufacturing-sever.yml 文件中的 ownership_voucher_store_driver: 参数配置的存储位置找到所有权凭证。

   目录应有一个 ownership_voucher 文件，其名称为 GUID 格式，这表示正确的设备凭据已添加到设备中。

   onboarding 服务器使用设备凭据对服务器进行身份验证。然后，它会将配置传递给设备。设备从 onboarding 服务器接收配置后，它会接收 SSH 密钥并在设备上安装操作系统。最后，系统会自动重启，使用存储在 TPM 中的强大密钥对其进行加密。

流程

1. 安装以下软件包：

   $ dnf  install -y sqlite sqlite-devel libpq libpq-devel

2. 访问 /usr/share/doc/fdo/migrations/* 目录。它包含您需要在安装完制造、rendezvous 和所有者服务器的 RPM 后，为每个服务器和类型组合创建数据库的 .sql 文件。

3. 初始化数据库内容。您可以使用 SQL 数据库（如 SQLite 或 PostgreSQL）或 diesel 工具来为您运行 SQL。

   • 如果您使用 SQL 数据库，使用例如，用户创建、访问管理来配置数据库服务器。配置完数据库服务器后，您可以运行数据库。
   • 如果您不想在数据库系统中运行 .sql 文件，您可以使用 diesel 工具为您运行 sql。如果您使用 diesel 工具，在配置了数据库后，请使用 diesel migration run 命令来创建数据库：

4. 配置 DB 系统后，您可以使用安装在 /usr/share/doc/fdo/migrations/* 处的 .sql 文件来为每个服务器类型创建数据库。

   您必须使用与您要初始化的服务器类型和数据库类型匹配的 .sql 文件。例如，当在 PostgreSQL 数据库中初始化 Owner Onboarding Server 时，您必须使用 /usr/share/doc/fdo/migrations/migrations_owner_onboarding_server_postgres/up.sql 文件夹。迁移文件夹中的 up.sql 文件创建数据库，down.sql 文件销毁数据库。

5. 创建数据库后，更改特定服务器的配置文件，以使其使用数据库。

   每台服务器都有一个存储配置部分。

   • 制造商服务器：ownership_voucher_store_driver
   • 所有者服务器：ownership_voucher_store_driver

   • Rendezvous 服务器：storage_driver

     1. 对于 manufacturing-server.yml 文件，在编辑器中打开它，并更改存储数据库：

        $ sudo editor manufacturing-server.yml

     2. 在 Directory 部分下更改 ownership_voucher_store_driver 配置：

        $ /home/rhel/fido-device-onboard-rs/aio-dir/stores/owner_vouchers

     3. 指定以下详情：
   • 您正在使用的数据库类型：SQLite 或 PostgreSQL

   • 服务器类型：例如，在使用 PostgreSQL 时设置以下配置：

     ownership_voucher_store_driver:
       Postgres:
         Manufacturer

     1. 重复步骤来配置所有者服务器和 Rendezvous 服务器。

6. 运行 FDO 加入服务。如需了解更多详细信息，请参阅自动提供和加入带有 FDO 的 RHEL for Edge 设备运行制造服务器来启动 FDO 加入过程设备初始化：

   $ sudo LOG-LEVEL=debug SQLITE_MANUFACTURER-DATABASE_URL=./manufacturer-db.sqlite ./usr/libexec/fdo/fdo-manufacturing-server

   加入过程在两个阶段发生：

   • 通常发生在制造站点中的设备初始化阶段。

   • 发生在设备的最终目的地的设备加入过程。

     因此，存储在制造服务器的数据库中的所有者凭证必须导出，并传到最终的所有者数据库。

7. 要从 manufacturing-vouchers 数据库文件导出所有权凭证，请将 Owner Voucher 复制到所有者，以继续 FDO 加入协议。

   1. 创建一个文件夹 export ：

      $ mkdir export

   2. 通过提供命令所需的所有变量，导出制造数据库中存在的所有者凭证。

      $ fdo-owner-tool export-manufacturer-vouchers DB_TYPE DB_URL PATH [GUID]

      DB_TYPE

      保存所有者凭证的制造 DB 的类型：sqlite、postgres

      DB_URL

      数据库连接 URL 或数据库文件的路径

      PATH

      将导出所有者凭证的目录的路径

      GUID

      要导出的所有者凭证的 GUID。如果没有提供 GUID，则将导出所有的所有者凭证。

8. OV 必须传送到最终的所有者的数据库。为此，请使用 fdo-owner-tool 来导入所有者凭证。改为所有者数据库。通过运行以下命令来导入所有权凭证：

   $ fdo-owner-tool import-ownership-vouchers DB_TYPE DB_URL SOURCE_PATH

   DB_TYPE

   导入 OV 的所有者 DB 的类型。可能的值：sqlite、postgres

   DB_URL

   DB 连接 URL 或 DB 文件的路径

   SOURCE_PATH

   要导入的 OV 的路径，或要导入的所有 OV 所在的目录的路径

流程

1. 提取下载的镜像 .tar 文件：

   # tar xvf <UUID>-commit.tar

2. 转到已提取 .tar 文件的目录。

   它有一个 compose.json 文件和一个 OSTree 目录。compose.json 文件有提交号，OSTree 目录有 RPM 软件包。

3. 打开 compose.json 文件，再记下提交 ID 号。当您继续设置 Web 服务器时，您需要这个数字。

   如果您安装了 jq JSON 处理程序，您还可以通过使用 jq 工具来检索提交 ID：

   # jq '.["ostree-commit"]' < compose.json

4. 列出提交中的 RPM 软件包。

   # rpm-ostree db list rhel/9/x86_64/edge --repo=repo

5. 使用 Kickstart 文件运行 RHEL 安装程序。另外，您可以使用任何现有的文件，或使用 Kickstart Generator 工具创建一个文件。

   在 Kickstart 文件中，确保包含有关如何置备文件系统、创建用户以及如何获取和部署 RHEL for Edge 镜像的详细信息。RHEL 安装程序在安装过程中使用此信息。

   以下是 Kickstart 文件示例：

   lang en_US.UTF-8
   keyboard us
   timezone Etc/UTC --isUtc
   text
   zerombr
   clearpart --all --initlabel
   autopart
   reboot
   user --name=core --group=wheel
   sshkey --username=core "ssh-rsa AAAA3Nza…​."
   rootpw --lock
   network --bootproto=dhcp
   
   ostreesetup --nogpg --osname=rhel --remote=edge --url=https://mirror.example.com/repo/ --ref=rhel/9/x86_64/edge

   基于 OStree 的安装使用 ostreesetup 命令来设置配置。它使用以下标记获取 OSTree 提交：

   • --nogpg - 禁用 GNU Privacy Guard (GPG)密钥验证。
   • --osname - 操作系统安装的管理根。
   • --remote - 操作系统安装的管理根
   • --url - 要从中安装的存储库的 URL。
   • --ref - 安装使用的存储库中的分支名称。

   • --url=http://mirror.example.com/repo/ - 是您提取边缘提交，并通过 nginx 提供它的主机系统的地址。您可以使用该地址从客户机计算机访问主机系统。

     例如，如果您在 /var/www/html 目录中提取提交镜像，并在主机名为 www.example.com 的计算机上通过 nginx 提供提交，则 --url 参数的值为 http://www.example.com/repo 。

     注意

     使用 http 协议启动一个服务来提供提交，因为 Apache HTTP 服务器上没有启用 https。

流程

1. 使用以下步骤创建 nginx 配置文件：

   events {
   
   }
   
   http {
       server{
           listen 8080;
           root /usr/share/nginx/html;
                   }
            }
   
   pid /run/nginx.pid;
   daemon off;

2. 使用以下说明创建 Dockerfile：

   FROM registry.access.redhat.com/ubi8/ubi
   RUN dnf -y install nginx && dnf clean all
   COPY kickstart.ks /usr/share/nginx/html/
   COPY repo /usr/share/nginx/html/
   COPY nginx /etc/nginx.conf
   EXPOSE 8080
   CMD ["/usr/sbin/nginx", "-c", "/etc/nginx.conf"]
   ARG commit
   ADD ${commit} /usr/share/nginx/html/

   其中,

   • Kickstart.ks 是 RHEL for Edge 镜像的 Kickstart 文件的名称。Kickstart 文件包含指令信息。为了帮助您稍后管理镜像，建议包含用于 greenboot 检查的检查和设置。因此，您可以更新 Kickstart 文件以含以下设置：

     lang en_US.UTF-8
     keyboard us
     timezone Etc/UTC --isUtc
     text
     zerombr
     clearpart --all --initlabel
     autopart
     reboot
     user --name=core --group=wheel
     sshkey --username=core "ssh-rsa AAAA3Nza…​."
     
     ostreesetup --nogpg --osname=rhel --remote=edge
     --url=https://mirror.example.com/repo/
     --ref=rhel/9/x86_64/edge
     
     %post
     cat << EOF > /etc/greenboot/check/required.d/check-dns.sh
     #!/bin/bash
     
     DNS_SERVER=$(grep nameserver /etc/resolv.conf | cut -f2 -d" ")
     COUNT=0
     
     # check DNS server is available
     ping -c1 $DNS_SERVER
     while [ $? != '0' ] && [ $COUNT -lt 10 ]; do
     
     							
     							
     							
     							
     							
     							COUNT++
     echo "Checking for DNS: Attempt $COUNT ."
     sleep 10
     ping -c 1 $DNS_SERVER
     done
     EOF
     %end

     任何 HTTP 服务都可以托管 OSTree 存储库，而使用容器的示例只是如何执行此操作的一个选项。Dockerfile 执行以下任务：

     1. 使用最新的通用基础镜像(UBI)
     2. 安装 Web 服务器(nginx)
     3. 向服务器添加 Kickstart 文件
     4. 将 RHEL for Edge 镜像提交添加到服务器

3. 构建 Docker 容器

   # podman build -t name-of-container-image --build-arg commit=uuid-commit.tar .

4. 运行容器

   # podman run --rm -d -p port:8080 localhost/name-of-container-image

   因此，服务器建立好了，可以通过使用 commit.tar 存储库和 Kickstart 文件来准备启动 RHEL 安装程序。

流程

1. 创建一个 Kickstart 文件。以下是一个示例，在此示例中，ostreesetup 指令指示 Anaconda 安装程序获取并部署提交。此外，它还创建了一个用户和密码。

   lang en_US.UTF-8
   keyboard us
   timezone UTC
   zerombr
   clearpart --all --initlabel
   autopart --type=plain --fstype=xfs --nohome
   reboot
   text
   network --bootproto=dhcp
   user --name=core --groups=wheel --password=edge
   services --enabled=ostree-remount
   ostreesetup --nogpg --url=http://edge_device_ip:port/repo/ --osname=rhel --remote=edge --ref=rhel/9/x86_64/edge

2. 使用 libvirt virt-install 工具运行 RHEL Anaconda 安装程序，来创建一个具有 RHEL 操作系统的虚拟机(VM)。在有人值守安装中使用 .qcow2 磁盘镜像作为目标磁盘：

   virt-install \
   --name rhel-edge-test-1 \
   --memory 2048 \
   --vcpus 2 \
   --disk path=prepared_disk_image.qcow2,format=qcow2,size=8 \
   --os-variant rhel9 \
   --cdrom /home/username/Downloads/rhel-9-x86_64-boot.iso

3. 在安装屏幕中：

   图 13.1. Red Hat Enterprise Linux 引导菜单

   

   1. 按 e 键添加额外的内核参数：

      inst.ks=http://web-server_device_ip:port/kickstart.ks

      kernel 参数指定您要使用 Kickstart 文件而不是 RHEL 安装程序中包含的 RHEL 镜像来安装 RHEL。

   2. 添加内核参数后，按 Ctrl+X 使用 Kickstart 文件引导 RHEL 安装。

      RHEL 安装程序启动、从服务器 (HTTP) 端点获取 Kickstart 文件并执行命令，包括从 HTTP 端点安装 RHEL for Edge 镜像提交的 命令。安装完成后，RHEL 安装程序会提示您登录详情。

验证

1. 在登录屏幕中，输入您的用户帐户凭证并点 Enter。

2. 验证 RHEL for Edge 镜像是否已成功安装。

   $ rpm-ostree status

   命令输出提供镜像提交 ID，并显示安装成功。

   以下是输出示例：

   State: idle
   Deployments:
   * ostree://edge:rhel/9/x86_64/edge
   		  Timestamp: 2020-09-18T20:06:54Z
   			Commit: 836e637095554e0b634a0a48ea05c75280519dd6576a392635e6fa7d4d5e96

流程

1. 运行 RHEL for Edge 容器镜像以启动 web 服务器。服务器获取 RHEL for Edge 容器镜像中的提交，并变为可用且正在运行。

2. 使用 libvirt virt-install 运行 RHEL Anaconda 安装程序，传递自定义的 .qcow2 磁盘镜像：

   virt-install \
   --name rhel-edge-test-1 \
   --memory 2048 \
   --vcpus 2 \
   --disk path=prepared_disk_image.qcow2,format=qcow2,size=8 \
   --os-variant rhel9 \
   --cdrom /home/username/Downloads/rhel-9-x86_64-boot.iso

3. 在安装屏幕中：

   图 13.2. Red Hat Enterprise Linux 引导菜单

   

   1. 按 TAB 键，并添加 Kickstart 内核参数：

      inst.ks=http://web-server_device_ip:port/kickstart.ks

      kernel 参数指定您要使用 Kickstart 文件而不是 RHEL 安装程序中包含的 RHEL 镜像来安装 RHEL。

   2. 添加内核参数后，按 Ctrl+X 使用 Kickstart 文件引导 RHEL 安装。

      RHEL 安装程序启动，从服务器(HTTP)端点获取 Kickstart 文件，并执行命令，包括从 HTTP 端点安装 RHEL for Edge 镜像提交的命令。安装完成后，RHEL 安装程序会提示您登录详情。

验证

1. 在登录屏幕中，输入您的用户帐户凭证并点 Enter。

2. 验证 RHEL for Edge 镜像是否已成功安装。

   $ rpm-ostree status

   命令输出提供镜像提交 ID，并显示安装成功。

   以下是一个输出示例：

   State: idle
   Deployments:
   * ostree://edge:rhel/9/x86_64/edge
   		  Timestamp: 2020-09-18T20:06:54Z
   			Commit: 836e637095554e0b634a0a48ea05c75280519dd6576a392635e6fa7d4d5e96

流程

1. 进入您下载了 RHEL for Edge Container OSTree 提交的目录。

2. 将 RHEL for Edge 容器 OSTree 提交加载到 Podman 中。

   $ sudo podman load -i UUID-container.tar

   命令输出提供了镜像 ID，例如 ：@8e0d51f061ff1a51d157804362bc875b649b27f2ae1e66566a15e7e6530cec63

3. 使用上一步中生成的镜像 ID，标记新的 RHEL for Edge 容器镜像。

   $ sudo podman tag image-ID localhost/edge-container

   podman tag 命令为本地镜像分配额外名称。

4. 运行名为 edge-container 的容器。

   $ sudo podman run -d --name=edge-container -p 8080:8080 localhost/edge-container

   podman run -d --name=edge-container 命令根据 localhost/edge-container 镜像将名称分配给容器。

5. 列出容器：

   $ sudo podman ps -a
   CONTAINER ID  IMAGE                               	COMMAND	CREATED    	STATUS                	PORTS   NAMES
   2988198c4c4b  …./localhost/edge-container   /bin/bash  3 seconds ago  Up 2 seconds ago      	edge-container

流程

1. 开始创建 RHEL for Edge Installer 镜像。

   # composer-cli compose start-ostree --ref rhel/9/x86_64/edge --url URL-OSTree-repository blueprint-name image-type

   其中,

   • ref 与客户用来构建 OSTree 存储库的值相同
   • URL-OSTree-repository 是要嵌入到镜像中的提交 OSTree 存储库的 URL。例如： http://10.0.2.2:8080/repo/。请参阅为非基于网络的部署创建 RHEL for Edge 容器镜像。
   • blueprint-name 是 RHEL for Edge Installer 蓝图名称。

   • image-type 是 edge-installer。

     这时将显示一个确认已添加到队列中的 composer 进程。它还显示创建的镜像的通用唯一标识符 (UUID) 号。使用 UUID 号来跟踪构建。另外，记录 UUID 号以易于执行进一步的任务。

2. 检查镜像 compose 状态。

   # composer-cli compose status

   命令输出以以下格式显示状态：

   <UUID> RUNNING date blueprint-name blueprint-version image-type

   注意

   完成镜像创建过程需要几分钟时间。

   要中断镜像创建过程，请运行：

   # composer-cli compose cancel <UUID>

   要删除现有镜像，请运行：

   # composer-cli compose delete <UUID>

   RHEL 镜像构建器在镜像构建期间拉取由正在运行的容器提供的提交。

   镜像构建完成后，您可以下载生成的 ISO 镜像。

3. 下载镜像。请参阅下载 RHEL for Edge 镜像。

   镜像就绪后，您可以将它用于非网络部署。请参阅为非基于网络的部署安装 RHEL for Edge 镜像。

流程

1. 创建一个 qcow VM 磁盘文件来安装(.iso)镜像。这是虚拟机(VM)的硬盘镜像。例如：

   $ qemu-img create -f qcow2 diskfile.qcow2 20G

2. 使用 virt-install 命令，将磁盘用作驱动器，将安装程序 ISO 镜像用作 CD-ROM 来引导虚拟机。例如：

   $ virt-install \
   --boot uefi \
   --name VM_NAME
   --memory 2048 \
   --vcpus 2 \
   --disk path=diskfile.qcow2
   --cdrom /var/lib/libvirt/images/UUID-installer.iso \
   --os-variant rhel9.0

   这个命令指示 virt-install 进行：

   • 指示虚拟机使用 UEFI 引导，而不是 BIOS。
   • 挂载安装 ISO。

   • 使用在第一步中创建的硬盘镜像。

     它为您提供 Anaconda 安装程序。RHEL 安装程序启动，从 ISO 中加载 Kickstart 文件并执行命令，包括安装 RHEL for Edge 镜像提交的命令。安装完成后，RHEL 安装程序会提示输入登录详情。

     注意

     Anaconda 已预先配置为在安装过程中使用容器提交。但是，您需要在分区之间设置系统配置，如磁盘分区、时区等。

3. 使用 virt-viewer 连接到 Anaconda GUI 来设置系统配置：

   $ virt-viewer --connect qemu:///system --wait VM_NAME

4. 重启系统以完成安装。
5. 在登录屏幕中，指定您的用户帐户凭证并点 Enter。

验证

1. 验证 RHEL for Edge 镜像是否已成功安装。

   $  rpm-ostree status

流程

1. 从镜像构建器下载容器镜像：

   $ composer-cli compose image _<UUID>

2. 将容器导入到 Podman ：

   $ skopeo copy oci-archive:_<UUID>_-container.tar containers-storage:localhost/ostree

3. 启动容器并使用端口 8080 使其可用：

   $ podman run -rm -p 8080:8080 ostree

流程

1. 创建一个空蓝图，对其定制为使用 "rhel-92" 作为发行版：

   name = "minimal-rhel92"
   description = "minimal blueprint for ostree commit"
   version = "1.0.0"
   modules = []
   groups = []
   distro = "rhel-92"

2. 将蓝图推送到服务器：

   # composer-cli blueprints push minimal-rhel92.toml

3. 从您创建的蓝图中构建 RHEL for Edge Commit (.tar)镜像：

   # composer-cli compose start-ostree minimal-rhel92 edge-commit

4. 检索 .tar criule ，并将其解压缩到磁盘：

   # composer-cli compose image _<rhel-92-uuid>
   $ tar -xf <rhel-92-uuid>.tar -C /usr/share/nginx/html/

   磁盘上的 /usr/share/nginx/html/repo 位置将成为所有 refs 和 commit 的一个 OSTree 存储库。

5. 创建另一个空蓝图，对其定制为使用 "rhel-87" 作为 发行版：

   name = "minimal-rhel87"
   description = "minimal blueprint for ostree commit"
   version = "1.0.0"
   modules = []
   groups = []
   distro = "rhel-87"

6. 推送蓝图，并创建另一个 RHEL for Edge Commit (.tar)镜像：

   # composer-cli blueprints push minimal-rhel87.toml
   # composer-cli compose start-ostree minimal-rhel87 edge-commit

7. 检索 .tar criule ，并将其解压缩到磁盘：

   # composer-cli compose image <rhel-87-uuid>
   $ tar -xf <rhel-87-uuid>.tar

8. 将提交拉取到本地存储库。通过使用 ostree pull-local，您可以将提交数据从一个本地存储库复制到另一个本地存储库。

   # ostree --repo=/usr/share/nginx/html/repo pull-local repo

9. 可选：检查 OSTree 存储库的状态。以下是一个输出示例：

   $ ostree --repo=/usr/share/nginx/html/repo refs
   
   rhel/8/x86_64/edge
   rhel/9/x86_64/edge
   
   $ ostree --repo=/usr/share/nginx/html/repo show rhel/8/x86_64/edge
   commit f7d4d95465fbd875f6358141f39d0c573df6a321627bafde68c73850667e5443
   ContentChecksum:  41bf2f8b442a770e9bf03e096a46a286f5836e0a0702b7c3516ef4e0acec2dea
   Date:  2023-09-15 16:17:04 +0000
   Version: 8.7
   (no subject)
   
   $ ostree --repo=/usr/share/nginx/html/repo show rhel/9/x86_64/edge
   commit 89290dbfd6f749700c77cbc434c121432defb0c1c367532368eee170d9e53ea9
   ContentChecksum:  70235bfb9cae82c53f856183750e809becf0b9b076122b19c40fec92fc6d74c1
   Date:  2023-09-15 15:30:24 +0000
   Version: 9.2
   (no subject)

10. 更新 RHEL 9.2 蓝图，以使其包含新软件包并构建新提交，例如：

    name = "minimal-rhel92"
    description = "minimal blueprint for ostree commit"
    version = "1.1.0"
    modules = []
    groups = []
    distro = "rhel-92"
    
    [[packages]]
    name = "strace"
    version = "*"

11. 推送更新的蓝图并创建一个新的 RHEL for Edge Commit (.tar)镜像，将 compose 指向现有的 OSTree 存储库：

    # composer-cli blueprints push minimal-rhel92.toml
    # composer-cli compose start-ostree minimal-rhel92 edge-commit --url http://localhost/repo --ref rhel/9/x86_64/edge

12. 检索 .tar 文件，并将其解压缩到磁盘上：

    # rm -rf repo
    # composer-cli compose image <rhel-92-uuid>
    # tar -xf <rhel-92-uuid>.tar

13. 将提交拉取到存储库：

    # ostree --repo=/usr/share/nginx/html/repo pull-local repo

14. 可选：再次检查 OSTree 存储库状态：

    $ ostree --repo=/usr/share/nginx/html/repo refs
    rhel/8/x86_64/edge
    rhel/9/x86_64/edge
    
    $ ostree --repo=/usr/share/nginx/html/repo show rhel/8/x86_64/edge
    commit f7d4d95465fbd875f6358141f39d0c573df6a321627bafde68c73850667e5443
    ContentChecksum:  41bf2f8b442a770e9bf03e096a46a286f5836e0a0702b7c3516ef4e0acec2dea
    Date:  2023-09-15 16:17:04 +0000
    Version: 8.7
    (no subject)
    
    $ ostree --repo=/usr/share/nginx/html/repo show rhel/9/x86_64/edge
    commit a35c3b1a9e731622f32396bb1aa84c73b16bd9b9b423e09d72efaca11b0411c9
    Parent:  89290dbfd6f749700c77cbc434c121432defb0c1c367532368eee170d9e53ea9
    ContentChecksum:  2335930df6551bf7808e49f8b35c45e3aa2a11a6c84d988623fd3f36df42a1f1
    Date:  2023-09-15 18:21:31 +0000
    Version: 9.2
    (no subject)
    
    $ ostree --repo=/usr/share/nginx/html/repo log rhel/9/x86_64/edge
    commit a35c3b1a9e731622f32396bb1aa84c73b16bd9b9b423e09d72efaca11b0411c9
    Parent:  89290dbfd6f749700c77cbc434c121432defb0c1c367532368eee170d9e53ea9
    ContentChecksum:  2335930df6551bf7808e49f8b35c45e3aa2a11a6c84d988623fd3f36df42a1f1
    Date:  2023-09-15 18:21:31 +0000
    Version: 9.2
    (no subject)
    
    commit 89290dbfd6f749700c77cbc434c121432defb0c1c367532368eee170d9e53ea9
    ContentChecksum:  70235bfb9cae82c53f856183750e809becf0b9b076122b19c40fec92fc6d74c1
    Date:  2023-09-15 15:30:24 +0000
    Version: 9.2
    (no subject)
    
    $ rpm-ostree db diff --repo=/usr/share/nginx/html/repo 89290dbfd6f749700c77cbc434c121432defb0c1c367532368eee170d9e53ea9 a35c3b1a9e731622f32396bb1aa84c73b16bd9b9b423e09d72efaca11b0411c9
    ostree diff commit from: 89290dbfd6f749700c77cbc434c121432defb0c1c367532368eee170d9e53ea9
    ostree diff commit to:   a35c3b1a9e731622f32396bb1aa84c73b16bd9b9b423e09d72efaca11b0411c9
    Added:
      elfutils-default-yama-scope-0.188-3.el9.noarch
      elfutils-libs-0.188-3.el9.x86_64
      strace-5.18-2.el9.x86_64