跳至主要內容

创建自定义 RHEL 系统镜像

大约 82 分钟

创建自定义 RHEL 系统镜像

来源：官方文档 原始多页入口：创建自定义 RHEL 系统镜像 内容规模：约 68,241 字符，103 个章节标题，176 个命令/代码块，40 条提示框

阅读提要

  • 副标题：在 RHEL 10.0 上使用 RHEL 镜像构建器创建自定义系统镜像
  • 摘要：RHEL 镜像构建器是一个创建部署就绪的自定义系统镜像的工具：安装磁盘、虚拟机、特定于云提供商的镜像等。通过使用 RHEL 镜像构建器，与手动过程相比，您可以更快地创建这些镜像，因为它消除了每种输出类型所需的特定配置。
  • 主要章节：在 RHEL 10.0 上使用 RHEL 镜像构建器创建自定义系统镜像；对红帽文档提供反馈；第 1 章 RHEL 镜像构建器描述；第 2 章 安装 RHEL 镜像构建器；第 3 章 配置 RHEL 镜像构建器存储库；第 4 章 使用 RHEL 镜像构建器 CLI 创建系统镜像；第 5 章 支持的镜像自定义；第 6 章 使用 RHEL 镜像构建器 web 控制台界面创建系统镜像；第 7 章 使用 RHEL 镜像构建器创建一个引导 ISO 安装程序镜像；第 8 章 使用 RHEL 镜像构建器创建网络安装程序镜像；第 9 章 使用 RHEL 镜像构建器 OpenSCAP 集成创建预强化的镜像；第 10 章 使用 RHEL 镜像构建器启用 FIPS 模式
  • 推荐阅读顺序：先看“阅读提要”和目录，再按章节查看“关键点/命令/注意”；需要原文细节时点击来源链接。

章节笔记

概览

  • 该章节主要为下一级主题的入口。

在 RHEL 10.0 上使用 RHEL 镜像构建器创建自定义系统镜像

  • 要点：摘要

对红帽文档提供反馈

  • 要点：我们致力于为您提供高质量的文档，您的反馈将对我们有很大帮助。为帮助我们改进，您可以通过 Red Hat Jira 跟踪系统提交建议或报告错误。
  • 要点：流程
  • 列表：登录到 Jira 网站。 如果您还没有帐户，请创建一个。
  • 列表：单击顶部导航栏中的 Create。
  • 列表：在 Summary 字段中输入描述性标题。
  • 列表：在 Description 字段中输入您对改进的建议。包括文档相关部分的链接。
  • 列表：点窗口底部的 Create。

第 1 章 RHEL 镜像构建器描述

  • 要点：您可以使用 RHEL 镜像构建器创建自定义 RHEL 系统镜像，包括云平台。它自动处理每个输出类型的设置细节，使图像创建比手动方法更快。您可以使用 image-builder CLI 或 RHEL web 控制台来访问它。
  • 要点：image-builder 工具具有以下特征：
  • 列表：它提供更简单的安装和环境配置。
  • 列表：您可以使用容器友好的无守护进程模型，从而消除客户端/服务器架构的复杂性。
  • 列表：您可以使用 image-builder 工具自动管道和基于容器的构建。
  • 列表：您可以创建容器镜像以用作可移植的环境，以构建其他镜像。
  • 注意：重要 image-builder 工具只是一个技术预览功能。技术预览功能不受红帽产品服务等级协议（SLA）支持，且功能可能并不完整。不要在生产环境中使用它们。这些技术预览功能可以使用户提早试用新的功能，并有机会在开发阶段提供反馈意见。

1.1. RHEL 镜像构建器术语

  • 要点：RHEL 镜像构建器对其核心概念使用特定的术语。
  • 要点：Blueprint 是自定义系统镜像的描述。它列出了将成为系统一部分的软件包和自定义。您可以使用自定义编辑蓝图，并将其保存为特定版本。当从蓝图创建系统镜像时，镜像与 RHEL 镜像构建器界面中的蓝图相关联。

1.2. RHEL 镜像构建器输出格式

  • 要点：RHEL 镜像构建器可以以多种输出格式创建镜像，如表中所示。
  • 要点：要检查支持的类型，请运行以下命令：
  • 命令/配置摘录：
# image-builder list
  • 表格样本（共 13 行）：
    • 描述 | CLI 名称 | 文件扩展名 | 架构
    • Amazon Web Services | ami | .ami | aarch64, x86_64
    • 磁盘归档 | tar | .tar | aarch64, x86_64, ppc64le, s390x
    • Google Cloud | gce | .tar.gz | x86_64

1.3. 支持的用于镜像构建的构架

  • 要点：RHEL 镜像构建器支持为多个架构构建镜像。
  • 要点：支持的构架包括：
  • 列表：AMD 和 Intel 64 位(x86_64)
  • 列表：ARM64 (aarch64)
  • 列表：IBM Z (s390x)
  • 列表：IBM POWER 系统(ppc64)

1.4. 其他资源

  • 列表：RHEL 镜像构建器额外的文档索引

第 2 章 安装 RHEL 镜像构建器

  • 要点：RHEL 镜像构建器是一个创建自定义系统镜像的工具。在使用 RHEL 镜像构建器前，您必须安装它。

2.1. RHEL 镜像构建器系统要求

  • 要点：运行 RHEL 镜像构建器的主机必须满足最低系统要求。
  • 要点：其他资源
  • 列表：配置 RHEL 镜像构建器存储库
  • 列表：使用 Red Hat Image Builder 镜像置备
  • 注意：注意 如果您没有互联网连接，请在隔离网络中使用 RHEL 镜像构建器。为此，您必须覆盖默认存储库以指向本地存储库，来不连接到 Red Hat Content Delivery Network (CDN)。确保您的内容在内部镜像了或使用 Red Hat Satellite。
  • 表格样本（共 7 行）：
    • 参数 | 最低要求值
    • 系统类型 | 一个专用的主机或虚拟机。容器不支持 RHEL 镜像构建器，包括 Red Hat Universal Base Images (UBI)。
    • 处理器 | 2 个内核
    • 内存 | 4 GiB

2.2. 安装 RHEL 镜像构建器

  • 要点：安装 RHEL 镜像构建器，以访问所有 image-builder 软件包功能。
  • 要点：先决条件
  • 列表：您已登录到要在其上安装 RHEL 镜像构建器的 Red Hat Enterprise Linux 主机。
  • 列表：Red Hat Enterprise Linux 主机已订阅了 Red Hat Subscription Manager (RHSM)或 Red Hat Satellite。
  • 列表：您已启用了 BaseOS 和 AppStream 存储库，以便能安装 RHEL 镜像构建器软件包。
  • 列表：安装 RHEL 镜像构建器和其他必要的软件包： # dnf install image-builder cockpit-image-builder image-builder 是用于构建自定义 RHEL 操作系统镜像的服务，并支持访问 CLI 接口。 cockpit-image-builder 是一个用于启用 Web UI 界面访问的软件包。Web 控制台作为 cockpit-image-builder 软件包的依赖项安装。
  • 列表：image-builder 是用于构建自定义 RHEL 操作系统镜像的服务，并支持访问 CLI 接口。
  • 列表：cockpit-image-builder 是一个用于启用 Web UI 界面访问的软件包。Web 控制台作为 cockpit-image-builder 软件包的依赖项安装。
  • 命令/配置摘录：
# dnf install image-builder cockpit-image-builder
# systemctl enable --now cockpit.socket

第 3 章 配置 RHEL 镜像构建器存储库

  • 要点：您可以添加软件仓库或覆盖默认基本软件仓库。
  • 要点：您可以在 RHEL 镜像构建器中使用以下类型的存储库：

3.1. 在 RHEL 镜像构建器中添加附加软件仓库

  • 要点：您可以使用 image-builder-cli 工具在镜像构建过程中将自定义存储库添加到镜像中。
  • 要点：根据您的存储库要求，使用以下选项之一：
  • 列表：--extra-repo：用于标准的、未经身份验证的自定义软件仓库。
  • 列表：--force-repo-dir：使用本地目录中的自定义仓库配置来完全覆盖内置仓库，如 Satellite 或 EUS 存储库。构建过程使用这些存储库来下载软件包，且不会在最终的输出工件中配置或包含它们。 注意 如果使用 -force-repo-dir，则镜像构建器只能使用自定义存储库目录中定义的特定发行版本。如果覆盖基本软件仓库，您必须在配置文件中显式定义 BaseOS 和 AppStream 软件仓库，否则镜像构建会失败。
  • 列表：有自定义存储库的 URL。
  • 列表：可选：如果使用 --force-repo-dir 选项，则必须有一个本地目录，它包含一个 JSON 配置文件，且该文件名必须与正在构建的发行版版本名称完全一致。例如，RHEL 9.8 的 rhel-98.json。
  • 列表：使用以下选项之一构建镜像，并将其他软件仓库包含到 RHEL 镜像构建器： 使用 --extra-repo 添加标准软件仓库： $ image-builder build <image-type> \ --extra-repo=https://server.example.com/<your-repo>/_ \ 存储库内容在镜像构建期间可用，依赖解析器会从该仓库中获取软件包。例如，如果仓库包含具有更高版本的 libc 或 kernel，则通过默认软件仓库选择其内容。 使用 --force-repo-dir 覆盖基本软件仓库： 使用这个选项来完全覆盖默认配置，比如使用延长更新支持(EUS)存储库或自定义 Satellite 配置构建镜…
  • 列表：使用 --extra-repo 添加标准软件仓库： $ image-builder build <image-type> \ --extra-repo=https://server.example.com/<your-repo>/_ \ 存储库内容在镜像构建期间可用，依赖解析器会从该仓库中获取软件包。例如，如果仓库包含具有更高版本的 libc 或 kernel，则通过默认软件仓库选择其内容。
  • 命令/配置摘录：
$ image-builder build <image-type> \ --extra-repo=https://server.example.com/<your-repo>/_ \
{  "x86_64": [  {  "name": "baseos",  "metalink": "",  "baseurl": "https://cdn.redhat.com/content/dist/rhel10/10/x86_64/baseos/os/",  "mirrorlist": "",  "gpgkey": "file:///etc/pki/rpm-gpg/RPM-GPG-KEY-redhat-release",  "check_gpg": true,  "metadata_expire": "",  "rhsm": true  },  {  "name": "appstream",  "metalink": "",  "baseurl": "https://cdn.redhat.com/content/dist/rhel10/10/x86_64/appstream/os/",  "mirrorlist": "",  "gpgkey": "file:///etc/pki/rpm-gpg/RPM-GPG-KEY-redhat-release",  "check_gpg": true,  "metadata_expire": "",  "rhsm": true  },  {  "name": "kernel-rt",  "baseurl": "https://cdn.redhat.com/content/dist/rhel10/10/x86_64/rt/os",  …
  • 注意：注意 如果使用 -force-repo-dir，则镜像构建器只能使用自定义存储库目录中定义的特定发行版本。如果覆盖基本软件仓库，您必须在配置文件中显式定义 BaseOS 和 AppStream 软件仓库，否则镜像构建会失败。

3.2. 将带有特定发行版的第三方存储库添加到 RHEL 镜像构建器中

  • 要点：您可以使用 image-builder 工具和 --extra-repo 标志来添加自定义软件仓库并在镜像中指定发布。
  • 要点：先决条件
  • 列表：有自定义存储库的 URL。
  • 列表：构建镜像，并将额外的存储库源和所选的分发系统添加到 RHEL 镜像构建器中： $ image-builder build <image-type> \ --extra-repo https://server.example.com/<your-repo>/_ \ --distro rhel-10.0
  • 命令/配置摘录：
$ image-builder build <image-type> \ --extra-repo https://server.example.com/<your-repo>/_ \ --distro rhel-10.0

3.3. 在镜像构建过程中覆盖系统存储库

  • 要点：在镜像构建过程中覆盖默认基本存储库。
  • 要点：先决条件
  • 列表：您有一个可从主机系统访问的自定义存储库。
  • 列表：构建镜像，并在 RHEL 镜像构建器中添加额外存储库： $ image-builder build <image-type> \ --force-repo=https://server.example.com/<your-repo>/_ \ 警告 RHEL 镜像构建器工具使用您定义的存储库来解决所有依赖项，这可能会导致您的系统出现问题。
  • 命令/配置摘录：
$ image-builder build <image-type> \ --force-repo=https://server.example.com/<your-repo>/_ \
  • 注意：警告 RHEL 镜像构建器工具使用您定义的存储库来解决所有依赖项，这可能会导致您的系统出现问题。

3.4. 配置 Satellite CV ，并将其用作内容源

  • 要点：您可以使用 Satellite 的内容视图(CV)作为自定义存储库，以使用 RHEL 镜像构建器构建镜像。使用自定义软件仓库，您可以配置 Satellite 注册的主机从本地 Satellite 存储库而不是 Red Hat Content Delivery Network (CDN)拉取软件包。
  • 要点：先决条件
  • 列表：您已安装了 RHEL 镜像构建器。请参阅 安装 RHEL 镜像构建器。
  • 列表：运行 RHEL 镜像构建器的主机注册到 Red Hat Satellite，并可访问所需的内容视图。请参阅 将主机注册到 Satellite。
  • 列表：您已下载或找到您的 Satellite 组织用来签署软件包的 GPG 公钥，这通常可通过使用 Satellite 服务器的 Web 界面或 /etc/pki/rpm-gpg/RPM-GPG-KEY-redhat-release 提供。
  • 列表：通过登录 Red Hat Satellite Web UI 或检查主机的存储库配置，为您的内容视图查找 Satellite 存储库基本 URL。您需要 BaseOS 和 AppStream URL。 BaseOS 存储库 URL 示例 https://satellite6.example.com/pulp/content/<your_org>/<your_env>/<your_cv>/content/dist/rhel10/10/x86_64/baseos/os AppStream 存储库 URL 示例 https://satellite6.example.com/pulp/content/<your_org>/<your_env…
  • 列表：BaseOS 存储库 URL 示例 https://satellite6.example.com/pulp/content/<your_org>/<your_env>/<your_cv>/content/dist/rhel10/10/x86_64/baseos/os
  • 列表：AppStream 存储库 URL 示例 https://satellite6.example.com/pulp/content/<your_org>/<your_env>/<your_cv>/content/dist/rhel10/10/x86_64/appstream/os
  • 命令/配置摘录：
https://satellite6.example.com/pulp/content/<your_org>/<your_env>/<your_cv>/content/dist/rhel10/10/x86_64/baseos/os
https://satellite6.example.com/pulp/content/<your_org>/<your_env>/<your_cv>/content/dist/rhel10/10/x86_64/appstream/os

3.5. 使用 Satellite CV 作为存储库，来在 RHEL 镜像构建器中构建镜像

  • 要点：配置 RHEL 镜像构建器，以使用 Satellite 的内容视图(CV)作为存储库来构建您的自定义镜像。
  • 要点：先决条件
  • 列表：您已将 Satellite 与 RHEL web 控制台集成。请参阅 在 Satellite 上启用 RHEL web 控制台。
  • 列表：在 Satellite Web UI 中，导航到 Content，找到 Products，选择您的 Product，然后单击您要使用的存储库。
  • 列表：在 Published 字段中搜索安全 URL (HTTPS)并复制它。
  • 列表：使用您复制作为红帽镜像构建器存储库的基本 URL 的 URL。请参阅 在 RHEL 镜像构建器中添加自定义第三方存储库。
  • 列表：构建镜像。请参阅 在 web 控制台界面中使用 RHEL 镜像构建器创建系统镜像。

第 4 章 使用 RHEL 镜像构建器 CLI 创建系统镜像

  • 要点：RHEL 镜像构建器是一个创建自定义系统镜像的工具。要控制 RHEL 镜像构建器并创建自定义系统镜像，您可以使用命令行(CLI)或 Web 控制台界面。

4.1. RHEL 镜像构建器命令行界面简介

  • 要点：通过运行带有合适的选项和子命令的 image-builder 命令，您可以使用 RHEL 镜像构建器命令行界面(CLI)创建蓝图。
  • 要点：默认情况下，您必须以 root 用户身份运行 image-builder 命令。
  • 列表：创建蓝图，或将现有蓝图定义导出到纯文本文件中。
  • 列表：可选：在文本编辑器中编辑此文件。
  • 列表：将蓝图文本文件导入镜像构建器。
  • 列表：运行 compose 操作从蓝图构建镜像。
  • 列表：导出镜像文件以下载它。

4.2. RHEL 镜像构建器蓝图格式

  • 要点：在 RHEL 镜像构建器中，您可以使用 .toml 和 .json 格式的蓝图。
  • 要点：典型的蓝图文件包括以下元素：
  • 列表：Mandatory（必需）
  • 列表：Default（默认）
  • 列表：选填 group-name 是组的名称，如 anaconda-tools、widget、wheel 或 users。蓝图安装必需的和默认的软件包。没有选择可选软件包的机制。
  • 列表：对于特定版本，请使用确切的版本号，如 8.7.0。
  • 列表：对于最新可用版本，请使用星号 *。
  • 列表：对于最新的次版本，请使用类似 8.* 的格式。 为每个要包括的软件包重复这个块。 注意 RHEL 镜像构建器工具中的软件包和模块之间没有区别。RHEL 镜像构建器同时将 RPM 软件包管理器(RPM)软件包依赖项视为。
  • 命令/配置摘录：
name = "<blueprint_name>" description = "<long_form_description_text>" version = "<version>"
[[groups]] name = "<group_name>"
  • 注意：注意 RHEL 镜像构建器工具中的软件包和模块之间没有区别。RHEL 镜像构建器同时将 RPM 软件包管理器(RPM)软件包依赖项视为。

4.3. 使用命令行创建蓝图

  • 要点：您可以使用命令行(CLI)创建新蓝图。蓝图描述了最终的镜像及其自定义，如软件包和内核自定义。
  • 要点：先决条件
  • 列表：您以 root 用户身份登录，或者是 weldr 组成员的用户身份登录
  • 列表：创建一个包含以下内容的纯文本文件： name = "<blueprint_name>" description = "<long_form_description>" version = "<0.0.1>" modules = [] groups = [] 将 <blueprint_name 和 <long_form_description> 替换为您的蓝图的名称和描述。 根据 Semantic Versioning 规范，将 <0.0.1> 替换为版本号。
  • 列表：对于您要包含在蓝图中的每个软件包，请在文件中添加以下行： [[packages]] name = "<package_name>" version = "<package_version>" 将 <package_name> 替换为软件包的名称，如 httpd、gdb-doc 或 coreutils。 （可选）将 <package_version> 替换为要使用的版本。此字段支持 dnf 版本规范： 对于特定版本，请使用确切的版本号，如 9.6.0。 对于最新可用版本，请使用星号 * 对于最新的次版本，请使用。类似 9.* 的格式。
  • 列表：对于特定版本，请使用确切的版本号，如 9.6.0。
  • 列表：对于最新可用版本，请使用星号 *
  • 列表：对于最新的次版本，请使用。类似 9.* 的格式。
  • 命令/配置摘录：
name = "<blueprint_name>" description = "<long_form_description>" version = "<0.0.1>" modules = [] groups = []
[[packages]] name = "<package_name>" version = "<package_version>"

4.4. 在命令行上使用 RHEL 镜像构建器创建系统镜像

  • 要点：要使用 RHEL 镜像构建器命令行界面构建自定义的 RHEL 镜像，您必须指定蓝图和镜像类型。可选，您还可以指定一个发行版。
  • 要点：如果没有指定发行版，它将使用与主机系统相同的发行版和版本。架构也与主机上的架构一样。
  • 列表：您已为镜像准备了蓝图。
  • 列表：可选：列出您可以创建的镜像格式： # image-builder list
  • 列表：启动 compose： # image-builder build <image_type> --blueprint <blueprint_name> 将 <blueprint_name> 替换为蓝图的名称，将 <image_type> 替换为镜像的类型。 如果没有指定 distro，image-builder 将使用与主机系统相同的分发和版本。
  • 列表：将 <blueprint_name> 替换为蓝图的名称，将 <image_type> 替换为镜像的类型。
  • 列表：如果没有指定 distro，image-builder 将使用与主机系统相同的分发和版本。
  • 命令/配置摘录：
# image-builder list
# image-builder build <image_type> --blueprint <blueprint_name>

4.5. 基本 RHEL 镜像构建器命令行命令

  • 要点：使用 RHEL 镜像构建器命令行界面运行这些基本 image-builder 命令。
  • 要点：<image-type> 是 RHEL 镜像构建器支持的镜像类型，如 qcow2、wsl 等等。
  • 命令/配置摘录：
# image-builder list
# image-builder list-images --filter "rhel"
  • 注意：注意 --filter 参数不支持单个表达式中的多个 key:value 对。要组合多个过滤器并缩小结果，请使用单独的 --filter 标志单独传递每个过滤器。

4.6. 在自定义镜像中启用服务

  • 要点：当使用 RHEL 镜像构建器将自定义镜像配置为 RHEL 版本，镜像类型决定了镜像使用的默认服务。
  • 要点：例如，使用 ami 镜像类型启用默认的 sshd、chronyd 和 cloud-init 服务。如果没有启用这些服务，则自定义镜像不会引导。
  • 列表：支持的镜像自定义
  • 注意：注意 您可以自定义在系统引导过程中要启用的服务。但是，自定义不会覆盖上述镜像类型默认启用的服务。
  • 表格样本（共 7 行）：
    • 镜像类型 | 默认启用的服务
    • ami | sshd, cloud-init, cloud-init-local, cloud-config, cloud-final
    • openstack | sshd, cloud-init, cloud-init-local, cloud-config, cloud-final
    • qcow2 | cloud-init

第 5 章 支持的镜像自定义

  • 要点：您可以通过在蓝图中添加自定义来自定义镜像，如添加额外的 RPM 软件包、启用服务或自定义内核命令行参数。
  • 要点：您可以在蓝图中使用多个镜像自定义。通过使用自定义，您可以将软件包和组添加到在默认软件包中不可用的镜像中。要使用这些选项，请在蓝图中配置自定义，并将它导入到 RHEL 镜像构建器。

5.1. 选择一个发行版

  • 要点：您可以使用 distro 字段指定在制作镜像或在蓝图中解决依赖项时要使用的发行版。
  • 要点：如果将 distro 字段留空，蓝图将使用主机的发行版本。使用存储库覆盖从自定义镜像而不是 Red Hat Content Delivery Network (CDN)下载基本系统 RPM。这会禁用默认软件仓库，因此您的自定义镜像必须包含所有必要的软件包。
  • 列表：您已创建了蓝图。
  • 列表：自定义带有 RHEL 发行版本的蓝图，以始终构建指定的 RHEL 镜像： name = "blueprint_name" description = "blueprint_version" version = "0.1" distro = "different_minor_version" 例如： name = "tmux" description = "tmux image with openssh" version = "1.2.16" distro = "rhel-9.6" 替换 "different_minor_version" 以构建不同的次版本，例如，如果要构建 RHEL 9.6 镜像，请使用 distro = "rh…
  • 命令/配置摘录：
name = "blueprint_name" description = "blueprint_version" version = "0.1" distro = "different_minor_version"
name = "tmux" description = "tmux image with openssh" version = "1.2.16" distro = "rhel-9.6"
  • 注意：重要 您无法构建一个与 RHEL 镜像构建器主机不同的操作系统镜像。例如，您无法使用 RHEL 系统构建 Fedora 或 CentOS 镜像。

5.2. 选择一个软件包组

  • 要点：自定义带有软件包组的蓝图。groups 列表描述了您要安装到镜像中的软件包组。
  • 要点：软件包组在存储库元数据中定义，每个组具有一个描述性名称和 ID。使用 ID 列出组。组将软件包归类为强制、默认或可选软件包。蓝图只安装强制和默认软件包，您无法选择可选软件包。
  • 列表：您已创建了蓝图。
  • 列表：使用软件包组自定义您的蓝图： [[groups]] name = "<group_name>" 使用组名称替换 group_name。例如： [[groups]] name = "anaconda-tools"
  • 命令/配置摘录：
[[groups]] name = "<group_name>"
[[groups]] name = "anaconda-tools"
  • 注意：注意 目前，软件包和模块之间没有区别。两者都被视为 RPM 软件包依赖项来处理。

5.3. 选择一个软件包

  • 要点：自定义带有软件包和模块的蓝图。
  • 要点：当您将虚拟供应商用作软件包名称时，版本 glob 必须是 *。因此，您无法冻结蓝图，因为该虚拟提供者会展开为多个具有各自名称和版本的软件包。
  • 列表：name 属性是必需的字符串，可以完全匹配，也可以是使用 * 通配符的文件系统 glob ，以及用于字符匹配的 ? 。
  • 列表：可选的 version 属性支持指定精确版本，也支持使用通配符模式，如 * 表示匹配任意数量的字符，? 表示匹配单个字符。如果没有输入版本，系统将使用存储库中的最新版本。
  • 列表：您已创建了蓝图。
  • 列表：自定义带有软件包的蓝图： [[packages]] name = "<package_name>" 使用软件包名称替换 package_name。例如： tmux-2.9a 和 openssh-server-8.* 软件包。 [[packages]] name = "tmux" version = "2.9a" [[packages]] name = "openssh-server" version = "8.*"
  • 命令/配置摘录：
[[packages]] name = "<package_name>"
[[packages]] name = "tmux" version = "2.9a" [[packages]] name = "openssh-server" version = "8.*"
  • 注意：注意 目前，软件包和模块之间没有区别。RHEL 镜像构建器将两者都视为 RPM 软件包依赖项。

5.4. 嵌入容器

  • 要点：您可以自定义蓝图来嵌入最新的 RHEL 容器。容器列表包含带有源的对象，以及可选的 tls-verify 属性。
  • 要点：容器列表条目描述要嵌入到镜像中的容器镜像。
  • 列表：source - 必需的字段。对注册表中的容器镜像的引用。这个示例使用 registry.access.redhat.com 注册中心。您可以指定标签版本。默认标签版本是最新的。
  • 列表：name - 本地注册中心中容器的名称。
  • 列表：tls-verify - 布尔值字段。tls-verify 布尔值字段控制传输层安全性。默认值为 true。
  • 列表：您已创建了蓝图。
  • 列表：要从 registry.access.redhat.com/ubi10/ubi:latest 和主机中的容器嵌入容器，请在蓝图中添加以下自定义： [[containers]] source = "registry.access.redhat.com/ubi10/ubi:latest" name = local_name tls-verify = true [[containers]] source = "localhost/test:latest" local-storage = true 您可以使用 containers-auth.json 文件访问受保护的容器资源。请参阅 容器注册中心凭证。
  • 命令/配置摘录：
[[containers]] source = "registry.access.redhat.com/ubi10/ubi:latest" name = local_name tls-verify = true [[containers]] source = "localhost/test:latest" local-storage = true

5.5. 设置镜像主机名

  • 要点：customizations.hostname 是一个可选字符串，您可以用来配置最终镜像主机名。此自定义是可选的，如果您未设置它，则蓝图使用默认主机名。
  • 要点：先决条件
  • 列表：您已创建了蓝图。
  • 列表：自定义蓝图以配置主机名： [customizations] hostname = "<base_image>"
  • 命令/配置摘录：
[customizations] hostname = "<base_image>"

5.6. 指定其他用户

  • 要点：将用户添加到镜像中，并可选择设置其 SSH 密钥。本节的所有字段都是可选的，但 name 除外。
  • 要点：先决条件
  • 列表：您已创建了蓝图。
  • 列表：自定义蓝图来将用户添加到镜像中： [[customizations.user]] name = "<user_name>" description = "<user_description>" password = "<password_hash>" key = "<public_ssh_key>" home = "/home/<user_name>/" shell = "/usr/bin/bash" groups = ["users", "wheel"] uid = <uid_number> gid = <gid_number> [[customizations.user]] name = "admin" description…
  • 命令/配置摘录：
[[customizations.user]] name = "<user_name>" description = "<user_description>" password = "<password_hash>" key = "<public_ssh_key>" home = "/home/<user_name>/" shell = "/usr/bin/bash" groups = ["users", "wheel"] uid = <uid_number> gid = <gid_number>
[[customizations.user]] name = "admin" description = "Administrator account" password = "$6$CHO2$3rN8eviE2t50lmVyBYihTgVRHcaecmeCk31L..." key = "PUBLIC SSH KEY" home = "/srv/widget/" shell = "/usr/bin/bash" groups = ["widget", "users", "wheel"] uid = 1200 gid = 1200 expiredate = 12345

5.7. 指定附加组

  • 要点：为生成的系统镜像指定一个组。name 和 gid 属性都是必需的。
  • 要点：先决条件
  • 列表：您已创建了蓝图。
  • 列表：自定义带有组的蓝图： [[customizations.group]] name = "<group_name>" gid = <number> 为每个组重复此块。例如： [[customizations.group]] name = "widget" gid = 1130
  • 命令/配置摘录：
[[customizations.group]] name = "<group_name>" gid = <number>
[[customizations.group]] name = "widget" gid = 1130

5.8. 为现有用户设置 SSH 密钥

  • 要点：您可以使用 [[customizations.sshkey]] 为最终镜像中的现有用户设置 SSH 密钥。user 和 key 属性是必需的。
  • 要点：先决条件
  • 列表：您已创建了蓝图。
  • 列表：通过为现有用户设置 SSH 密钥来自定义蓝图： [[customizations.sshkey]] user = "root" key = "PUBLIC-SSH-KEY" 例如： [[customizations.sshkey]] user = "root" key = "SSH key for root"
  • 命令/配置摘录：
[[customizations.sshkey]] user = "root" key = "PUBLIC-SSH-KEY"
[[customizations.sshkey]] user = "root" key = "SSH key for root"

5.9. 附加一个内核参数

  • 要点：您可以向引导装载程序内核命令行中附加参数。默认情况下，RHEL 镜像构建器将默认内核构建到镜像中。但是，您可以通过在蓝图中配置它来自定义内核。
  • 要点：先决条件
  • 列表：您已创建了蓝图。
  • 列表：在默认值中附加内核引导选项： [customizations.kernel] append = "<kernel_option>" 例如： [customizations.kernel] name = "kernel-debug" append = "nosmt=force"
  • 命令/配置摘录：
[customizations.kernel] append = "<kernel_option>"
[customizations.kernel] name = "kernel-debug" append = "nosmt=force"

5.10. 使用实时内核构建 RHEL 镜像

  • 要点：使用实时内核(kernel-rt)构建 RHEL 镜像。使用 /usr/share/image-builder/repositories/ 目录中的 .json 来覆盖存储库，以构建选择 kernel-rt 作为默认内核的镜像。将镜像部署到系统，并使用实时内核功能。
  • 要点：先决条件
  • 列表：您的系统已注册，RHEL 已附加到 RHEL for Real Time 订阅。
  • 列表：创建一个 kernel.json 文件，使其包含 RT 内核存储库： { "name": "kernel-rt", "baseurl": "https://cdn.redhat.com/content/dist/rhel10/10/x86_64/rt/os", "gpgkey": "-----BEGIN PGP PUBLIC KEY BLOCK-----\n\nmQINBEr………fg==\n=UZd/\n-----END PGP PUBLIC KEY BLOCK-----\n", "rhsm": true, "check_gpg": true },
  • 列表：创建一个蓝图。在蓝图中，添加 "[customizations.kernel]" 自定义。以下是蓝图中包含 "[customizations.kernel]" 的一个示例： name = "rt-kernel-image" description = "" version = "2.0.0" modules = [] groups = [] distro = "rhel-10.0" [[customizations.user]] name = "admin" password = "admin" groups = ["users", "wheel"] [customizations.kernel] name = "kernel-r…
  • 列表：从您创建的蓝图中构建镜像。以下示例构建 .qcow2 镜像： # image-builder build qcow2 -- blueprint rt-kernel-image --data-dir kernel.json
  • 列表：将已构建的镜像部署到目标系统，以便使用实时内核功能。
  • 列表：从镜像引导虚拟机后，验证镜像是否已正确选择了 kernel-rt 作为默认内核。 $ cat /proc/cmdline BOOT_IMAGE=(hd0,got3)/vmlinuz-6.12.0-0.el10_0_.x86_64+rt...
  • 命令/配置摘录：
{  "name": "kernel-rt",  "baseurl": "https://cdn.redhat.com/content/dist/rhel10/10/x86_64/rt/os",  "gpgkey": "-----BEGIN PGP PUBLIC KEY BLOCK-----\n\nmQINBEr………fg==\n=UZd/\n-----END PGP PUBLIC KEY BLOCK-----\n",  "rhsm": true,  "check_gpg": true  },
name = "rt-kernel-image" description = "" version = "2.0.0" modules = [] groups = [] distro = "rhel-10.0" [[customizations.user]] name = "admin" password = "admin" groups = ["users", "wheel"] [customizations.kernel] name = "kernel-rt" append = ""
  • 注意：注意 实时内核在经过认证可运行 Red Hat Enterprise Linux 的 AMD64 和 Intel 64 服务器平台上运行。

5.11. 设置时区和 NTP

  • 要点：您可以自定义蓝图来配置时区和网络时间协议(NTP)。
  • 要点：timezone 和 ntpservers 属性是可选字符串。如果您没有自定义时区，系统将使用 Universal Time Coordinated (UTC)。如果您没有设置 NTP 服务器，系统将使用默认发行版。
  • 列表：您已创建了蓝图。
  • 列表：自定义带有您想要的 timezone 和 ntpservers 的蓝图： [customizations.timezone] timezone = "TIMEZONE" ntpservers = "NTP_SERVER" 例如： [customizations.timezone] timezone = "US/Eastern" ntpservers = ["0.north-america.pool.ntp.org", "1.north-america.pool.ntp.org"] 注意 有些镜像类型，如 Google Cloud，已经配置了 NTP 服务器。您无法覆盖它，因为镜像需要 NTP 服务器来在所选环境中引导。但是，您可以…
  • 命令/配置摘录：
[customizations.timezone] timezone = "TIMEZONE" ntpservers = "NTP_SERVER"
[customizations.timezone] timezone = "US/Eastern" ntpservers = ["0.north-america.pool.ntp.org", "1.north-america.pool.ntp.org"]
  • 注意：注意 有些镜像类型，如 Google Cloud，已经配置了 NTP 服务器。您无法覆盖它，因为镜像需要 NTP 服务器来在所选环境中引导。但是，您可以在蓝图中自定义时区。

5.12. 自定义区域设置

  • 要点：您可以为生成的系统镜像自定义区域设置。language 和 keyboard 属性都是强制的。您添加的第一个语言是主要语言，其余语言为次要语言。
  • 要点：先决条件
  • 列表：您已创建了蓝图。
  • 列表：设置区域设置： [customizations.locale] languages = ["<language>"] keyboard = "<keyboard>" 例如： [customizations.locale] languages = ["en_US.UTF-8"] keyboard = "us"
  • 列表：列出 language 支持的取值： $ localectl list-locales
  • 列表：列出 keyboard 支持的取值： $ localectl list-keymaps
  • 命令/配置摘录：
[customizations.locale] languages = ["<language>"] keyboard = "<keyboard>"
[customizations.locale] languages = ["en_US.UTF-8"] keyboard = "us"

5.13. 自定义防火墙

  • 要点：为生成的系统镜像设置防火墙。默认情况下，防火墙会阻止进入的连接，但显式启用的端口的服务除外，如 sshd。
  • 要点：如果您不想使用 [customizations.firewall] 或 [customizations.firewall.services]，可以删除属性，或者将它们设置为空列表 []。如果您只想使用默认的防火墙设置，您可以从蓝图中省略自定义。
  • 列表：您已创建了蓝图。
  • 列表：使用以下设置自定义蓝图，以打开其他端口和服务： [customizations.firewall] ports = ["<ports>"] 其中 ports 是包含要打开的端口或一系列端口和协议的可选字符串列表。您可以使用 port:protocol 格式配置端口，或者您可以使用 portA-portB:protocol 格式配置端口范围。例如： [customizations.firewall] ports = ["22:tcp", "80:tcp", "imap:tcp", "53:tcp", "53:udp", "30000-32767:tcp", "30000-32767:udp"] 您可以使用 /etc/services…
  • 列表：在 customizations.firewall.service 部分中指定要启用或禁用哪个防火墙服务： [customizations.firewall.services] enabled = ["<services>"] disabled = ["<services>"]
  • 列表：您可以检查可用的防火墙服务： $ firewall-cmd --get-services 例如： [customizations.firewall.services] enabled = ["ftp", "ntp", "dhcp"] disabled = ["telnet"] 注意 firewall.services 中列出的服务与 /etc/services 文件中提供的 service-names 不同。
  • 命令/配置摘录：
[customizations.firewall] ports = ["<ports>"]
[customizations.firewall] ports = ["22:tcp", "80:tcp", "imap:tcp", "53:tcp", "53:udp", "30000-32767:tcp", "30000-32767:udp"]
  • 注意：注意 Google 模板针对其环境明确禁用了防火墙。您无法通过设置蓝图来覆盖此行为。
  • 注意：注意 firewall.services 中列出的服务与 /etc/services 文件中提供的 service-names 不同。

5.14. 启用或禁用服务

  • 要点：您可以控制在引导时要启用的服务。有些镜像类型已预设置无法覆盖的服务以确保镜像正常工作。
  • 要点：[customizations.services] 设置添加到镜像模板中的现有服务，但不会替换它们。
  • 列表：您已创建了蓝图。
  • 列表：自定义在引导时要启用的服务： [customizations.services] enabled = ["services"] disabled = ["services"] 例如： [customizations.services] enabled = ["sshd", "cockpit.socket", "httpd"] disabled = ["postfix", "telnetd"]
  • 命令/配置摘录：
[customizations.services] enabled = ["services"] disabled = ["services"]
[customizations.services] enabled = ["sshd", "cockpit.socket", "httpd"] disabled = ["postfix", "telnetd"]

5.15. ISO 镜像中的 Kickstart 文件注入

  • 要点：您可以使用 [customizations.installer] 自定义配置将 Kickstart 文件添加到 ISO 安装程序构建中，例如用于裸机部署的 mage installer。
  • 要点：您可以选择以下选项来添加自己的 Kickstart 文件：
  • 列表：在安装过程中设置所有值。
  • 列表：在 Kickstart 中启用 unattended = true 字段，并使用默认值获得完全无人值守的安装。
  • 列表：使用 Kickstart 字段注入您自己的 Kickstart。如果您指定了所有必填字段，则会进行完全无人值守的安装。否则，安装程序会提示您输入缺少的字段。 Anaconda 安装程序 ISO 镜像类型支持以下蓝图自定义： [customizations.installer] unattended = true sudo-nopasswd = ["user", "%wheel"] unattended：创建一个完全自动化安装的 Kickstart 文件。这包括默认设置以下选项：
  • 列表：文本显示模式
  • 列表：en_US.UTF-8 语言和区域设置
  • 列表：us 键盘布局
  • 命令/配置摘录：
[customizations.installer] unattended = true sudo-nopasswd = ["user", "%wheel"]
liveimg --url file:///run/install/repo/liveimg.tar.gz lang en_US.UTF-8 keyboard us timezone UTC zerombr clearpart --all --initlabel text autopart --type=plain --fstype=xfs --nohome reboot --eject network --device=link --bootproto=dhcp --onboot=on --activate
  • 注意：警告 使用现有操作系统或数据在计算机上引导 ISO 可能会造成破坏性，因为它将 Kickstart 配置为自动重新格式化系统中的第一个磁盘。

5.16. 指定分区模式

  • 要点：使用 partitioning_mode 变量选择如何对您要构建的磁盘镜像进行分区。
  • 要点：您可以使用以下支持的模式自定义镜像：
  • 列表：auto-lvm：它使用原始分区模式，除非存在一个或多个文件系统自定义配置。在这种情况下，它使用 LVM 分区模式。
  • 列表：lvm：它总是使用 LVM 分区模式，即使没有额外的挂载点。
  • 列表：raw：即使有一个或多个挂载点，也会使用原始分区。
  • 列表：您已创建了蓝图。
  • 列表：您可以使用以下自定义，使用 partitioning_mode 变量自定义蓝图： [customizations] partitioning_mode = "lvm"
  • 命令/配置摘录：
[customizations] partitioning_mode = "lvm"

5.17. 自定义文件系统配置规格

  • 要点：您可以在蓝图中指定自定义文件系统配置，因此可以创建具有特定磁盘布局，而不是默认布局配置的镜像。
  • 要点：通过使用蓝图中的非默认布局配置，您可以受益于：
  • 列表：安全基准合规性
  • 列表：防止磁盘不足错误
  • 列表：提高的性能
  • 列表：与现有设置的一致性
  • 列表：tar
  • 列表：container
  • 注意：注意 OSTree 系统不支持文件系统自定义，因为 OSTree 镜像有自己的挂载规则，如只读。不支持以下镜像类型： image-installer
  • 注意：警告 将文件自定义与其他蓝图自定义相结合可能会影响其功能或覆盖文件自定义。

5.17.1. 蓝图中的自定义文件规格

  • 要点：使用 [[customizations.files]] 蓝图自定义配置，您可以创建新文本文件或修改现有的文件。这可以覆盖现有的内容。
  • 要点：您无法创建或替换以下文件：
  • 列表：为您要创建的文件设置用户和组所有权。
  • 列表：以八进制格式设置模式权限。
  • 列表：/etc/fstab
  • 列表：/etc/shadow
  • 列表：/etc/passwd
  • 列表：/etc/group
  • 注意：警告 如果您使用 customizations.directories，且目录路径已存在于已设置 mode、user 或 group 的镜像中，则镜像构建无法防止更改现有目录的所有权或权限。

5.17.2. 蓝图中的自定义目录规格

  • 要点：您可以使用 [[customizations.directories]] 蓝图自定义来创建或修改目录。
  • 要点：使用自定义，您可以：
  • 列表：创建新目录。
  • 列表：为您要创建的目录设置用户和组所有权。
  • 列表：以八进制格式设置目录模式权限。
  • 列表：确保根据需要创建父目录。
  • 列表：创建新文本文件。
  • 列表：修改现有文件。这可以覆盖现有的内容。
  • 命令/配置摘录：
[[customizations.filesystem]] mountpoint = "MOUNTPOINT" minsize = MINIMUM-PARTITION-SIZE
[[customizations.filesystem]] mountpoint = "/var" minsize = 1073741824
  • 注意：注意 您无法创建或替换以下文件： /etc/fstab /etc/shadow /etc/passwd /etc/group

5.18. 蓝图中的卷组和逻辑卷命名规格

  • 要点：您可以指定蓝图中的卷组和逻辑卷的名称。
  • 要点：您可以对以下操作使用 RHEL 镜像构建器：
  • 列表：使用高级分区布局创建 RHEL 磁盘镜像。您可以使用自定义挂载点、基于 LVM 的分区和基于 LVM 的 SWAP 创建磁盘镜像。例如，使用 config.toml 文件更改 / 和 /boot 目录的大小。
  • 列表：选择要使用哪个文件系统。您可以在 ext4 和 xfs 之间进行选择。
  • 列表：添加 swap 分区和 LV。磁盘镜像可以包含基于 LV 的 SWAP。
  • 列表：更改 LVM 实体的名称。镜像中的逻辑卷(LV)和卷组(VG)可以有自定义名称。
  • 列表：一个镜像中的多个 PV 或 VG。
  • 列表：SWAP 文件
  • 命令/配置摘录：
[[customizations.disk.partitions]] type = "plain" label = "data" mountpoint = "/data" fs_type = "ext4" minsize = "50 GiB" [[customizations.disk.partitions]] type = "lvm" name = "mainvg" minsize = "20 GiB" [[customizations.disk.partitions.logical_volumes]] name = "rootlv" mountpoint = "/" label = "root" fs_type = "ext4" minsize = "2 GiB" [[customizations.disk.partitions.logical_volumes]] name = "homelv" mountpoint = "/home" label = "home" fs_type = "ext4" minsize = "2 GiB" [[customizations.disk.partitions.logical_volumes]] name = "swaplv" fs_type = "swap" minsize = "1 GiB"

第 6 章 使用 RHEL 镜像构建器 web 控制台界面创建系统镜像

  • 要点：RHEL 镜像构建器是一个创建自定义系统镜像的工具。要控制 RHEL 镜像构建器并创建自定义系统镜像，您可以使用 Web 控制台界面。

6.1. 在 RHEL web 控制台中访问 RHEL 镜像构建器仪表盘

  • 要点：使用 RHEL web 控制台的 cockpit-image-builder 插件，您可以使用图形界面管理镜像构建器蓝图和 compose。
  • 要点：先决条件
  • 列表：您必须有对系统的 root 权限。
  • 列表：您已安装了 RHEL 镜像构建器。
  • 列表：您已安装了 cockpit-image-builder 软件包。
  • 列表：在主机上，在 Web 浏览器中打开 https://localhost:9090/。
  • 列表：以 root 用户身份登录 Web 控制台。
  • 列表：要显示 RHEL 镜像构建器控制，请单击窗口左上角的 Image Builder 按钮。 RHEL 镜像构建器仪表盘打开，列出现有的蓝图（若有的话）。

6.2. 在 web 控制台界面中创建一个蓝图

  • 要点：在创建自定义 RHEL 系统镜像前，您必须创建一个蓝图。所有自定义都是可选的。
  • 要点：先决条件
  • 列表：在浏览器中，您从 Web 控制台打开了 RHEL 镜像构建器应用程序。请参阅 在 RHEL web 控制台中访问 RHEL 镜像构建器 GUI。
  • 列表：在 RHEL 镜像构建器仪表盘上，点 Create image blueprint。 在 Image output 页面中，从以下选项中选择，然后点 Next。 发行版本 架构 选择目标环境
  • 列表：在 Image output 页面中，从以下选项中选择，然后点 Next。 发行版本 架构 选择目标环境
  • 列表：发行版本
  • 列表：架构
  • 列表：选择目标环境

6.3. 在 RHEL 镜像构建器 web 控制台界面中导入蓝图

  • 要点：您可以导入并使用已存在的蓝图。系统会自动解决所有依赖项。
  • 要点：先决条件
  • 列表：您已在浏览器中从 web 控制台打开了 RHEL 镜像构建器应用程序。
  • 列表：您有一个要导入到 RHEL 镜像构建器 web 控制台界面中使用的蓝图。
  • 列表：在 RHEL 镜像构建器仪表盘上，点 Import blueprint。此时会打开 Import blueprint 向导。
  • 列表：在 Upload 字段中，拖放或上传现有的蓝图。此蓝图可以是 TOML 或 JSON 格式。
  • 列表：点 Import。仪表盘列出了您导入的蓝图。
  • 列表：要验证已为导入蓝图选择的软件包，请导航到 Packages 选项卡。 要列出所有软件包依赖项，请单击 All。列表是可搜索的，并可排序。

6.4. 从 RHEL 镜像构建器 web 控制台界面导出蓝图

  • 要点：您可以导出蓝图以便在另一个系统中使用自定义。您可以使用 TOML 或 JSON 格式导出蓝图。这两个格式在 CLI 和 API 接口中都可以工作。
  • 要点：先决条件
  • 列表：您已在浏览器中从 web 控制台打开了 RHEL 镜像构建器应用程序。
  • 列表：您有一个要导出的蓝图。
  • 列表：在镜像构建器仪表盘上，选择您要导出的蓝图。
  • 列表：点 Export blueprint。此时会打开 Export blueprint 向导。
  • 列表：点 Export 按钮将蓝图下载为一个文件，或者点击 Copy 按钮将蓝图复制到剪贴板。 可选：点击 Copy 按钮来复制蓝图。
  • 列表：可选：点击 Copy 按钮来复制蓝图。

6.5. 在 web 控制台界面中使用 RHEL 镜像构建器创建系统镜像

  • 要点：您可以通过完成以下步骤，从自定义蓝图创建自定义 RHEL 系统镜像。
  • 要点：先决条件
  • 列表：在浏览器中从 web 控制台打开 RHEL 镜像构建器应用程序。
  • 列表：您创建了蓝图。
  • 列表：在 RHEL 镜像构建器仪表盘中，点 blueprint 标签页。
  • 列表：在蓝图表中，找到您要构建镜像的蓝图。
  • 列表：在所选蓝图的右侧，点 Create Image。Create image 对话框向导将打开。
  • 列表：在 Image 输出页面中完成以下步骤： 从 Select a blueprint 列表中，选择您想要的镜像类型。 从 Image output type 列表中，选择您想要的镜像输出类型。 根据您选择的镜像类型，您需要添加更多详细信息。

第 7 章 使用 RHEL 镜像构建器创建一个引导 ISO 安装程序镜像

  • 要点：您可以使用 RHEL 镜像构建器创建可引导的 ISO 安装程序镜像。这些镜像由一个带有根文件系统的 .tar 文件组成。您可以使用可引导的 ISO 镜像将文件系统安装到裸机服务器。
  • 要点：RHEL 镜像构建器构建一个清单，该清单创建一个包含根文件系统的引导 ISO。要创建 ISO 镜像，请选择映像类型 image-installer。RHEL 镜像构建器构建一个具有以下内容的 .tar 文件：
  • 列表：一个标准 Anaconda 安装程序 ISO
  • 列表：一个嵌入式 RHEL 系统 tar 文件
  • 列表：一个默认的 Kickstart 文件，用于按照最小默认配置安装该提交生成的系统。

7.1. 使用 RHEL 镜像构建器 CLI 创建一个引导 ISO 安装程序镜像

  • 要点：您可以使用 RHEL 镜像构建器命令行界面创建一个自定义的引导 ISO 安装程序镜像。生成的镜像是一个 .iso 文件，其中包含一个 .tar 文件，您可以在操作系统上安装。
  • 要点：该 .iso 文件配置为启动 Anaconda 安装程序，并利用 .tar 文件中的内容完成系统配置和安装。您可以使用在硬盘上创建的 ISO 镜像文件，或者在虚拟机中引导，如 HTTP 引导或 USB 安装。
  • 列表：您已为镜像创建了一个蓝图，使用包含的用户自定义了它，并将其推送回 RHEL 镜像构建器。请参阅 支持的镜像自定义。
  • 列表：创建 ISO 镜像： # image-builder build iso --blueprint <blueprint_name> <blueprint_name > 带有您创建的蓝图的名称 <image_installer > 是镜像类型 创建进程启动，可能需要几分钟时间。 RHEL 镜像构建器构建一个包含 .tar 文件的 .iso 文件。.tar 文件是为操作系统安装的镜像。.iso 配置为引导 Anaconda 并安装 .tar 文件来配置系统。
  • 列表：<blueprint_name > 带有您创建的蓝图的名称
  • 列表：<image_installer > 是镜像类型 创建进程启动，可能需要几分钟时间。 RHEL 镜像构建器构建一个包含 .tar 文件的 .iso 文件。.tar 文件是为操作系统安装的镜像。.iso 配置为引导 Anaconda 并安装 .tar 文件来配置系统。
  • 列表：找到您构建的 .iso 镜像。
  • 列表：挂载 ISO 镜像。 $ mount -o ro <path_to_iso> /mnt 您可以在 /mnt/liveimg.tar.gz 目录中找到 .tar 文件。
  • 命令/配置摘录：
# image-builder build iso --blueprint <blueprint_name>
$ mount -o ro <path_to_iso> /mnt
  • 注意：警告 安装(.iso)镜像类型不接受分区自定义。如果您尝试手动配置文件系统自定义，则它不会应用到由(.iso)镜像构建的任何系统。使用文件系统自定义构建的 ISO 镜像可能会导致 Kickstart 错误，安装不会自动重启。如需更多信息，请参阅 自动化镜像构建器生成的 RHEL ISO 安装。

7.2. 在 GUI 中使用 RHEL 镜像构建器创建一个引导 ISO 安装程序镜像

  • 要点：您可以使用 RHEL 镜像构建器 GUI 构建一个自定义引导 ISO 安装程序镜像。您可以使用硬盘上生成的 ISO 镜像文件，或者在虚拟机中引导它。例如，在 Hypertext Transfer Protocol (HTTP)引导或通用串行总线(USB)安装中。
  • 要点：先决条件
  • 列表：您已在浏览器中从 web 控制台打开了 RHEL 镜像构建器应用程序。
  • 列表：您已为镜像创建了一个蓝图。请参阅 在 web 控制台界面中创建一个 RHEL 镜像构建器蓝图。
  • 列表：在 RHEL 镜像构建器仪表盘上，找到您要用来构建镜像的蓝图。（可选）在左上角的搜索框中输入蓝图名称或部分名称，然后点 Enter。
  • 列表：在蓝图的右侧，点对应的 Create Image 按钮。 Create image 对话框向导将打开。
  • 列表：在 Create image 对话框向导中： 在 Image Type 列表中，选择 "RHEL Installer (.iso) "。 点击 Next。 在 Review 选项卡上，点 Create。 构建过程完成后，您可以看到镜像构建完成状态。
  • 列表：在 Image Type 列表中，选择 "RHEL Installer (.iso) "。
  • 命令/配置摘录：
$ tar -xf <content>.tar
  • 注意：警告 安装(.iso)镜像类型不接受分区自定义。如果手动配置文件系统自定义选项，这些自定义配置不会应用于任何通过该安装镜像安装的系统。挂载使用 RHEL 镜像构建器文件系统自定义构建的 ISO 镜像会在 Kickstart 中导致一个错误，且安装不会自动重启。如需更多信息，请参阅 自动化镜像构建器生成的 RHEL ISO 安装。

7.3. 将可引导 ISO 安装到介质并引导它

  • 要点：在裸机系统上安装使用 RHEL 镜像构建器创建的可引导 ISO 镜像。
  • 要点：先决条件
  • 列表：您已使用 RHEL 镜像构建器创建了可引导 ISO 镜像。
  • 列表：您已下载了可引导 ISO 镜像。
  • 列表：已安装 dd 工具。
  • 列表：您有一个有足够容量的 USB 闪存驱动器 ISO 镜像。所需的大小因您在蓝图中选择的软件包而异，但最小大小为 8 GB。
  • 列表：使用 dd 工具将可引导 ISO 镜像直接写入 USB 驱动器。例如： dd if=installer.iso of=/dev/sdX 其中 installer.iso 是 ISO 镜像文件名，/dev/sdX 是您的 USB 闪存驱动器设备路径。
  • 列表：将闪存驱动器插入到您要引导的计算机的 USB 端口中。
  • 命令/配置摘录：
dd if=installer.iso of=/dev/sdX

第 8 章 使用 RHEL 镜像构建器创建网络安装程序镜像

  • 要点：使用 RHEL 镜像构建器自动注册和部署，以创建 Anaconda 网络安装程序 ISO 镜像。通过嵌入激活码，您可以生成预先配置的、自助注册为每日构建和特定环境量身定制的镜像。

8.1. 网络安装程序镜像的好处

  • 要点：在跨机构部署新系统时，您可以生成带有嵌入式配置的自定义网络安装程序镜像，以确保自动合规、安全性和一致的注册。

8.2. RHEL 镜像构建器中的 ISO 镜像类型概述

  • 要点：要评估可用 ISO 镜像类型之间的区别，请查看下表为您的网络带宽和自定义需求选择最佳安装方法。
  • 表格样本（共 3 行）：
    • 镜像类型 | 描述 | 使用案例
    • 镜像安装程序(image-installer) | 包含预定义的系统镜像的可引导 ISO 文件。它将特定的有效负载直接安装到磁盘。 | 在安装过程中，使用最小配置快速、可重复的基础镜像部署。
    • 网络安装程序(network-installer) | 包含 Anaconda 安装程序的轻量级可引导 ISO 文件，但在安装过程中从存储库下载软件包。 | 高度自定义安装，其中必须在部署时选择软件包或使用激活码。

8.3. 使用 image-builder cli 创建网络安装程序镜像

  • 要点：使用 image-builder CLI 构建自定义 Anaconda 网络安装程序镜像，直接从命令行生成轻量级、可重复的引导镜像。
  • 要点：先决条件
  • 列表：已安装 image-builder 软件包。
  • 列表：主机系统具有有效的红帽订阅。
  • 列表：可选： 您有一个激活码用于在安装过程中启用自动注册。
  • 列表：以 TOML (Tom 的 Obvious, Minimal Language)格式创建一个蓝图文件，并定义蓝图名称、描述和所需的自定义： name = "network-installer-example" description = "A customized RHEL 10 network installer" version = "0.0.1"
  • 列表：将文件保存为 <blueprint_name>.toml，并关闭文本编辑器。
  • 列表：启动镜像构建过程，将 network-installer 指定为镜像类型： # image-builder build --distro rhel-10.2 network-installer --blueprint network-installer-example 完成构建过程需要一些时间。镜像构建完成后，生成的镜像将保存在当前创建目录中，您可以直接使用。
  • 命令/配置摘录：
name = "network-installer-example" description = "A customized RHEL 10 network installer" version = "0.0.1"
# image-builder build --distro rhel-10.2 network-installer --blueprint network-installer-example

8.4. 使用 Web 控制台创建网络安装程序镜像

  • 要点：在通过图形界面管理操作系统部署时，您可以使用 RHEL web 控制台构建自定义的 Anaconda 网络安装程序镜像，在您的环境中置备轻量级、订阅就绪的系统。
  • 要点：先决条件
  • 列表：已安装并启用 web 控制台的 RHEL 系统。如需更多信息，请参阅安装 RHEL 镜像构建器。
  • 列表：您有有效的红帽订阅凭证或激活码和机构 ID。
  • 列表：Red Hat Enterprise Linux 主机已订阅了 Red Hat Subscription Manager (RHSM)或 Red Hat Satellite。
  • 列表：在主机上，登录到 RHEL web 控制台。 https://localhost:9090
  • 列表：以 root 用户身份登录 Web 控制台，然后在导航菜单中选择 Image builder。
  • 列表：点 Create blueprint。
  • 命令/配置摘录：
https://localhost:9090
$ sudo bootc status

第 9 章 使用 RHEL 镜像构建器 OpenSCAP 集成创建预强化的镜像

  • 要点：内部 RHEL 镜像构建器支持 OpenSCAP 集成。这个集成启用了预强化的 RHEL 镜像的生产。
  • 要点：通过配置蓝图，您可以执行以下操作：
  • 列表：使用一组预定义的安全配置文件对其进行自定义
  • 列表：添加一组软件包或附加文件
  • 列表：构建一个可部署到所选平台的自定义 RHEL 镜像，使其更符合您的环境需求。

9.1. OpenSCAP 蓝图自定义

  • 要点：通过使用 OpenSCAP 蓝图自定义，您可以从 scap-security-guide 中为特定的安全配置集生成蓝图，并构建预先强化的镜像。
  • 要点：使用 OpenSCAP 创建自定义蓝图涉及以下高级别步骤：
  • 列表：修改挂载点，并根据具体要求配置文件系统布局。
  • 列表：在蓝图中，选择 OpenSCAP 配置集。这会在镜像构建过程中，根据所选的配置文件触发补救。另外，在镜像构建过程中，OpenSCAP 会应用 pre-first-boot 补救。
  • 列表：datastream 补救指令的数据流路径。scap-security-guide 软件包中的数据流文件位于 /usr/share/xml/scap/ssg/content/ 目录中。
  • 列表：所需的安全配置集的 profile_id。profile_id 字段接受长和简短形式，如 cis 或 xccdf_org.ssgproject.content_profile_cis。如需了解更多详细信息，请参阅 RHEL 10 中支持的 SCAP 安全指南配置集。
  • 列表：openscap-scanner 是 OpenSCAP 工具。
  • 列表：scap-security-guide 是包含补救和评估指令的软件包。 补救阶段将 scap-security-guide 软件包用于 datastream，因为这个软件包默认安装在镜像中。如果要使用不同的数据流，将必要的软件包添加到蓝图中，并在 oscap 配置中指定到数据流的路径。
  • 命令/配置摘录：
[customizations.openscap] # If you want to use the data stream from the 'scap-security-guide' package # the 'datastream' key could be omitted. # datastream = "/usr/share/xml/scap/ssg/content/ssg-rhel10-ds.xml" profile_id = "xccdf_org.ssgproject.content_profile_cis"
# oscap info /usr/share/xml/scap/ssg/content/ssg-rhel10-ds.xml
  • 注意：注意 不要将此完全一样的蓝图片段用于镜像强化。它没有反映一个完整的配置文件。当红帽持续更新并优化 scap-security-guide 软件包中每个配置集的安全要求时，始终使用为您的系统提供的最新版本的数据流，始终可以重新生成初始模板。

9.2. 使用 RHEL 镜像构建器创建一个预强化的镜像

  • 要点：在内部使用 RHEL 镜像构建器来创建预先强化的 RHEL 镜像，并支持 OpenSCAP 集成。
  • 要点：通过配置蓝图，您可以执行以下操作：
  • 列表：创建预先强化并与特定配置集兼容的镜像
  • 列表：在虚拟机(VM)或裸机环境中部署预先强化的镜像，例如：
  • 列表：您以 root 用户身份登录，或者以是 weldr 组成员的用户身份登录。
  • 列表：openscap 和 scap-security-guide 软件包已安装。
  • 列表：使用 OpenSCAP 工具和 scap-security-guide 内容，以 Tom's Obvious Minimal Language (TOML)格式创建一个强化蓝图，并在需要时修改它： # oscap xccdf generate fix --profile=<profileID> --fix-type=<blueprint> /usr/share/xml/scap/ssg/content/ssg-rhel10-ds.xml > cis.toml 将 <profileID> 替换为系统需要遵循的配置集 ID，例如 cis。
  • 列表：启动强化镜像的构建： # image-builder build <image_type> --blueprint <blueprint_name> 将 <image_type> 替换为任何镜像类型，如 qcow2。 镜像构建就绪后，您可以在部署中使用预先强化的镜像。请参阅 从基于内核的虚拟机(KVM)客户机镜像创建虚拟机。
  • 命令/配置摘录：
# oscap xccdf generate fix --profile=<profileID> --fix-type=<blueprint> /usr/share/xml/scap/ssg/content/ssg-rhel10-ds.xml > cis.toml
# image-builder build <image_type> --blueprint <blueprint_name>
  • 注意：重要 执行配置合规性扫描不能保证系统是合规的。如需更多信息，请参阅配置合规性扫描。

9.3. 使用 RHEL 镜像构建器自定义预先强化的镜像

  • 要点：您可以通过更改规则来自定义安全配置文件，如密码长度、删除或选择实施内部策略的规则。您不能通过自定义配置文件来定义新规则。
  • 要点：从蓝图构建镜像会创建定制文件，并使用新的定制配置集 ID 将其保存到 /usr/share/xml/oscap-tailoring/tailoring.xml。新配置集 ID 将 tailoring 作为后缀附加到基础配置集。例如，如果您使用互联网安全中心(CIS)基础配置文件（cis），则配置文件 ID 是 xccdf_org.ssgproject.content_profile_cis_tailoring。
  • 列表：您以 root 用户身份登录，或者以是 weldr 组成员的用户身份登录。
  • 列表：openscap 和 scap-security-guide 软件包已安装。
  • 列表：从所选配置文件创建 TOML 格式的强化蓝图。例如： # oscap xccdf generate fix --profile=<profileID> --fix-type=blueprint /usr/share/xml/scap/ssg/content/ssg-rhel10-ds.xml > <profileID>tailored.toml
  • 列表：将带有自定义规则集的定制部分附加到蓝图中。定制自定义仅影响基本配置集中的规则的默认选择或未选择状态，而不更改其他规则的状态。 # Blueprint for CIS Red Hat Enterprise Linux 10.0 Benchmark for Level 2 - Server # ... [customizations.openscap.tailoring] selected = [ "xccdf_org.ssgproject.content_bind_crypto_policy" ] unselected = [ "grub2_password" ]
  • 列表：启动强化型镜像的构建： # *image-builder build <image_type> --blueprint <blueprintProfileID> * 将 <image_type> 替换为任何镜像类型，如 qcow2。 镜像构建就绪后，对部署使用预先强化的镜像。
  • 列表：扫描系统以了解配置合规性和漏洞
  • 命令/配置摘录：
# oscap xccdf generate fix --profile=<profileID> --fix-type=blueprint /usr/share/xml/scap/ssg/content/ssg-rhel10-ds.xml > <profileID>tailored.toml
# Blueprint for CIS Red Hat Enterprise Linux 10.0 Benchmark for Level 2 - Server # ... [customizations.openscap.tailoring] selected = [ "xccdf_org.ssgproject.content_bind_crypto_policy" ] unselected = [ "grub2_password" ]
  • 注意：重要 执行配置合规性扫描不能保证系统是合规的。如需更多信息，请参阅配置合规性扫描。

第 10 章 使用 RHEL 镜像构建器启用 FIPS 模式

  • 要点：您可以创建一个自定义镜像，并引导启用了 FIPS 的 RHEL 镜像。在制作镜像前，您必须更改蓝图中 fips 指令的值。
  • 要点：先决条件
  • 列表：您以 root 用户身份登录，或者以是 weldr 组成员的用户身份登录。
  • 列表：使用以下内容，创建一个 Tom's Obvious, Minimal Language (TOML)格式的纯文本文件： name = "system-fips-mode-enabled" description = "blueprint with FIPS enabled" version = "0.0.1" [customizations] fips = true [[customizations.user]] name = "admin" password = "admin" groups = ["users", "wheel"]
  • 列表：构建自定义的 RHEL 镜像： # image-builder build image-type --blueprint blueprint-name
  • 列表：使用您在蓝图中配置的用户名和密码登录到系统镜像。
  • 列表：检查是否启用了 FIPS 模式： $ cat /proc/sys/crypto/fips_enabled 1
  • 命令/配置摘录：
name = "system-fips-mode-enabled" description = "blueprint with FIPS enabled" version = "0.0.1" [customizations] fips = true [[customizations.user]] name = "admin" password = "admin" groups = ["users", "wheel"]
# image-builder build image-type --blueprint blueprint-name

第 11 章 使用 RHEL 镜像构建器生成 WSL 2 镜像

  • 要点：您可以使用 RHEL 镜像构建器为 Linux (WSL)创建 Windows 子系统。以 .wsl 格式构建镜像后，您可以通过双击该镜像在本地部署它。
  • 要点：Windows Subsystem for Linux（WSL）允许您在 Windows 环境中运行 Linux 发行版。WSL 镜像支持以下镜像自定义：
  • 列表：cloud-init
  • 列表：distro
  • 列表：软件包
  • 列表：modules
  • 列表：groups
  • 列表：minimal
  • 命令/配置摘录：
# image-builder build wsl --blueprint <blueprint-name>
# image-builder image <UUID>

第 12 章 使用 RHEL 镜像构建器准备并部署 KVM 客户机镜像

  • 要点：使用 RHEL 镜像构建器创建一个 .qcow2 镜像，您可以在基于 KVM 的虚拟机监控程序上进行部署。
  • 要点：创建自定义 KVM 客户机镜像涉及以下高级别步骤：
  • 列表：为 .qcow2 镜像创建一个蓝图。
  • 列表：使用 RHEL 镜像构建器创建一个 .qcow2 镜像。
  • 列表：从 KVM 客户机镜像创建一个虚拟机。

12.1. 使用 RHEL 镜像构建器创建自定义 KVM 客户机镜像

  • 要点：您可以使用 GUI RHEL 镜像构建器创建自定义 .qcow2 基于内核的虚拟机(KVM)客户机镜像。
  • 要点：先决条件
  • 列表：您必须位于 root 或 weldr 组中，以访问系统。
  • 列表：cockpit-image-builder 软件包已安装。
  • 列表：在 RHEL 系统上，您已打开了 web 控制台的 RHEL 镜像构建器仪表盘。
  • 列表：您已创建了蓝图。请参阅在 web 控制台界面中创建一个蓝图。
  • 列表：点您创建的蓝图名称。
  • 列表：选择 Images 选项卡。

12.2. 从 KVM 客户机镜像创建虚拟机

  • 要点：使用您使用 RHEL 镜像构建器创建的 .qcow2 镜像从 KVM 客户机镜像创建新虚拟机。自定义镜像已安装并启用了 cloud-init。
  • 要点：先决条件
  • 列表：您已使用 RHEL 镜像构建器创建了一个 .qcow2 镜像。
  • 列表：您已在系统上安装了 qemu-kvm 软件包。您可以检查系统上是否有 /dev/kvm 设备，以及在固件中是否启用了虚拟化功能。
  • 列表：在您的系统上已安装了 libvirt 和 virt-install 软件包。
  • 列表：您已将由 xorriso 软件包提供的 genisoimage 工具安装在您的系统上。
  • 列表：将您使用 RHEL 镜像构建器创建的 .qcow2 镜像移到 /var/lib/libvirt/images/ 目录中。
  • 列表：创建一个目录，如 cloudinitiso，并导航到这个新创建的目录： $ mkdir cloudinitiso $ cd cloudinitiso
  • 命令/配置摘录：
$ mkdir cloudinitiso $ cd cloudinitiso
instance-id: citest local-hostname: vmname

第 13 章 使用 RHEL 镜像构建器创建 Vagrant 框

  • 要点：使用 RHEL 镜像构建器，您可以选择 vagrant-libvirt 或 vagrant-virtualbox 镜像类型来创建 Vagrant 框。
  • 要点：RHEL 镜像构建器生成为不同虚拟机监控程序优化的预配置镜像：
  • 列表：vagrant-libvirt 为 libvirt 创建一个基于 QCOW2 的镜像
  • 列表：Vagrant-virtualbox 为 VirtualBox 创建基于 VMDK 的镜像

13.1. 为 libvirt 和 VirtualBox 后端构建 Vagrant 镜像

  • 要点：您可以使用 vagrant-libvirt 和 vagrant-virtualbox 镜像类型为不同的提供程序创建自定义 Vagrant 框。
  • 要点：您可以使用蓝图自定义来自定义镜像类型。
  • 列表：vagrant-libvirt 镜像类型会创建一个基于 QCOW2的框，用于 libvirt 提供程序。
  • 列表：vagrant-virtualbox 镜像类型会创建一个与 VirtualBox 提供程序兼容的框。
  • 列表：RHEL 镜像构建器已安装并运行。
  • 列表：您有一个蓝图文件可供构建。
  • 列表：对于 libvirt box：安装了 libvirt 监控程序的主机系统已安装并运行。
  • 列表：对于 VirtualBox 框：安装了 VirtualBox 的主机系统。
  • 命令/配置摘录：
$ sudo image-builder build --distro rhel-10.0 vagrant-libvirt
$ sudo image-builder build - -distro <distro-name> vagrant-virtualbox

第 14 章 使用 RHEL 镜像构建器创建无状态镜像

  • 要点：使用 RHEL 镜像构建器创建无状态镜像。以 pxe-tar-xz 格式构建镜像后，您可以在 PXE 或 UEFI HTTP 网络引导环境中使用生成的无状态 PXE 镜像输出。如需更多信息，请参阅生成的 tarball 文件中的 README。

14.1. 使用镜像构建器 CLI 构建 PXE 引导的 RHEL 镜像

  • 要点：使用 RHEL 映像构建器 CLI 和自定义蓝图为 PXE 部署创建 RHEL 映像。tar 文件包括 kernel、initrd 和 root 文件系统组件。无状态 PXE 镜像可用于 64 位 ARM 和 64 位 x86 架构，并支持一些自定义。
  • 要点：先决条件
  • 列表：现有的自定义蓝图。
  • 列表：构建自定义的 RHEL 镜像： $ image-builder build pxe-tar-xz --blueprint <blueprint-name> RHEL 镜像构建器在当前目录路径中创建镜像： <os>-pxe-tar-xz-<architecture>.tar.xz
  • 列表：将镜像组件提取到引导服务器。找到 tar 文件。如果工具创建了目录，请输入该目录来查找 .tar.xz 文件。然后，将其展开到 TFTP root 目录下： $ sudo tar -xJf <image-name>.tar.xz -C /var/lib/tftpboot/rhel-pxe/
  • 命令/配置摘录：
$ image-builder build pxe-tar-xz --blueprint <blueprint-name>
<os>-pxe-tar-xz-<architecture>.tar.xz

14.2. 使用 HTTP 服务器在 PXE 引导环境中引导无状态镜像

  • 要点：通过 HTTP 提供 rootfs.img 镜像，以获得比仅使用 TFTP 更快且更可靠的传输性能。
  • 要点：先决条件
  • 列表：存在 <os>-pxe-tar-xz-<architecture>.tar.xz 镜像。
  • 列表：目标系统有足够的内存来同时保存内核、initrd 和 rootfs。
  • 列表：对于小型镜像，建议提供 2 GiB 的存储容量，但实际需求取决于工作负载。 警告 内存不足可能会导致在引导过程中出现内核崩溃。
  • 列表：通过将 vmlinuz、initrd.img 和 rootfs.img 文件放在 TFTP 服务器的根目录中来准备 TFTP 服务器。
  • 列表：修改 grub.cfg 配置，将 HTTP-SERVER 占位符替换为 HTTP 服务器的实际 URL。
  • 列表：在包含 rootfs.img 文件的目录中使用 HTTP 提供 rootfs.img ： $ python3 -m http.server 8000
  • 命令/配置摘录：
$ python3 -m http.server 8000
  • 注意：警告 内存不足可能会导致在引导过程中出现内核崩溃。

14.3. 使用组合镜像在 PXE 引导环境中引导无状态镜像

  • 要点：通过将根文件系统合并到初始 ramdisk 中，消除了对单独 HTTP 服务器的需要。
  • 要点：先决条件
  • 列表：有一个 PXE 无状态镜像。
  • 列表：目标系统有足够的内存来同时保存内核、initrd 和 rootfs。
  • 列表：对于小型镜像，建议提供 2 GiB 的存储容量，但实际需求取决于工作负载。 警告 内存不足可能会导致在引导过程中出现内核崩溃。
  • 列表：创建 rootfs CPIO 归档： $ echo rootfs.img | cpio -c --quiet -L -o > rootfs.cpio
  • 列表：连接 initrd.img 和 rootfs.cpio 镜像： $ cat initrd.img rootfs.cpio > combined.img
  • 列表：使用生成的 combined.img 文件作为您的 PXE 配置中的 initrd 来引导系统。 注意 使用组合镜像会显著增加初始网络负载。由于整个根文件系统在 PXE 阶段传输，因此请确保您的网络带宽可以处理增加的流量，特别是在同时引导多个系统时。
  • 命令/配置摘录：
$ echo rootfs.img | cpio -c --quiet -L -o > rootfs.cpio
$ cat initrd.img rootfs.cpio > combined.img
  • 注意：警告 内存不足可能会导致在引导过程中出现内核崩溃。
  • 注意：注意 使用组合镜像会显著增加初始网络负载。由于整个根文件系统在 PXE 阶段传输，因此请确保您的网络带宽可以处理增加的流量，特别是在同时引导多个系统时。

第 15 章 将容器推送到 registry 中并将其嵌入到镜像中

  • 要点：通过 RHEL 镜像构建器，您可以使用 OpenSCAP 工具构建安全强化的镜像。您可以利用对蓝图中容器自定义的支持来创建一个容器，并将其直接嵌入到您创建的镜像中。

15.1. 自定义蓝图，将容器嵌入到镜像中

  • 要点：通过在蓝图中添加容器自定义，从 registry.access.redhat.com 中嵌入容器。RHEL 镜像构建器在镜像构建期间拉取容器，并将容器存储在镜像中。
  • 要点：默认本地容器存储位置取决于镜像类型，因此所有支持的 container-tools （如 Podman）都可以使用它。
  • 列表：您已创建了蓝图。
  • 列表：使用容器自定义蓝图：
  • 列表：source - 必需的字段。它是对 registry 中的容器镜像的引用。这个示例使用 registry.access.redhat.com 注册中心。您可以指定标签版本。默认标签版本 是最新的。
  • 列表：name - 本地注册中心中容器的名称。
  • 列表：tls-verify - 布尔值字段。tls-verify 布尔值字段控制传输层安全性。默认值为 true。 要访问受保护的容器资源，您可以使用 containers-auth.json 文件。
  • 命令/配置摘录：
[[containers]] source = "registry.access.redhat.com/ubi10/ubi:latest" name = "_<local_name>_" tls-verify = true

15.2. 将容器工件直接推送到容器 registry

  • 要点：在使用 RHEL 镜像构建器 CLI 构建后，您可以将容器工件直接推送到容器注册中心。
  • 要点：先决条件
  • 列表：访问 quay.io registry。本例使用 quay.io 容器 registry 作为目标 registry，但您可以使用您选择的容器 registry。
  • 列表：配置 registry-config.toml 文件以选择容器提供程序。凭证是可选的。 provider = "<container_provider>" [settings] tls_verify = false username = "<admin>" password = "<your_password>"
  • 列表：使用 .toml 格式创建蓝图。这是您在蓝图中安装 nginx 软件包的容器蓝图。 name = "simple-container" description = "Simple RHEL container" version = "0.0.1" [[packages]] name = "nginx" version = "*"
  • 列表：通过将注册表和存储库作为参数传递到 image-builder 工具来构建容器镜像。 # image-builder build --blueprint <simple-container> --extra-repo "quay.io:8080/<namespace>/<repository>" --extra-repo registry-config.toml 注意 构建容器镜像需要一些时间，因为需要解析自定义软件包的依赖项。
  • 列表：在镜像构建完成后，您创建的容器将出现在 quay.io 中。
  • 列表：打开 quay.io，再单击 Repository Tags。您可以查看您创建的容器的详情，例如： 最后修改 镜像大小 您可以复制到剪贴板中的 manifest ID。
  • 命令/配置摘录：
provider = "<container_provider>" [settings] tls_verify = false username = "<admin>" password = "<your_password>"
name = "simple-container" description = "Simple RHEL container" version = "0.0.1" [[packages]] name = "nginx" version = "*"
  • 注意：注意 构建容器镜像需要一些时间，因为需要解析自定义软件包的依赖项。

15.3. 构建镜像并将容器提取到镜像中

  • 要点：创建容器镜像后，构建自定义镜像并将容器镜像提取到其中。在蓝图中使用容器自定义规格和最终镜像的容器名称。它获取容器镜像并将其添加到本地 Podman 容器存储中。
  • 要点：先决条件
  • 列表：您创建了容器镜像并将其推送到本地 quay.io 容器 registry 实例。请参阅 将容器工件直接推送到容器注册中心。
  • 列表：您可以访问 registry.access.redhat.com。
  • 列表：您有一个容器 清单 ID。
  • 列表：已安装 qemu-kvm 和 qemu-img 软件包。
  • 列表：创建蓝图来构建 qcow2 镜像。蓝图必须包含 [[containers]] 自定义。 name = "image" description = "A qcow2 image with a container" version = "0.0.1" distro = "rhel-10" [[packages]] name = "podman" version = "*" [[containers]] source = "registry.access.redhat.com/ubi10:8080/image/container/container-image@sha256:manifest-ID-from-Repository-tag…
  • 列表：构建容器镜像： # image-builder build qcow2 --blueprint <blueprint> 注意 构建镜像需要一些时间，因为它将检查 quay.io registry 上的容器。 您可以使用您创建和下载的 qcow2 镜像来创建虚拟机。
  • 命令/配置摘录：
name = "image" description = "A qcow2 image with a container" version = "0.0.1" distro = "rhel-10" [[packages]] name = "podman" version = "*" [[containers]] source = "registry.access.redhat.com/ubi10:8080/image/container/container-image@sha256:manifest-ID-from-Repository-tag: tag-version" name = "source" tls-verify = true
# image-builder build qcow2 --blueprint <blueprint>
  • 注意：注意 构建镜像需要一些时间，因为它将检查 quay.io registry 上的容器。

第 16 章 使用 RHEL 镜像构建器准备并上传云镜像

  • 要点：RHEL 镜像构建器可以创建准备在各种云平台上使用的自定义系统镜像。要在云环境中使用自定义的 RHEL 系统镜像，请使用 RHEL 镜像构建器创建镜像，选择输出类型，配置您的系统，并将镜像上传到您的云帐户。
  • 要点：您可以使用 RHEL web 控制台中的 Image Builder 应用程序来推送自定义镜像云，用于 RHEL 镜像构建器支持的服务提供商的子集，如 AWS 和 Microsoft Azure 云。

第 17 章 准备 AMI 镜像并将其上传到 AWS

  • 要点：您可以使用 RHEL 镜像构建器在 AWS 云上手动创建或自动更新这些镜像。

17.1. 准备手动上传 AWS AMI 镜像

  • 要点：在将 Amazon Machine Image (AMI)上传到 Amazon Web Services (AWS)之前，您必须配置系统来上传镜像。
  • 要点：先决条件
  • 列表：准备好可写的 S3 存储桶。
  • 列表：使用以下方法之一配置的 AWS 身份验证： 静态凭证：在 AWS IAM 帐户管理器中配置的 Access Key ID 和 Secret Access Key。您必须在 AWS IAM account manager 中配置了一个 Access Key ID。 动态凭证：使用 AWS IAM Identity Center (SSO)管理的短期有效凭证。
  • 列表：静态凭证：在 AWS IAM 帐户管理器中配置的 Access Key ID 和 Secret Access Key。您必须在 AWS IAM account manager 中配置了一个 Access Key ID。
  • 列表：动态凭证：使用 AWS IAM Identity Center (SSO)管理的短期有效凭证。
  • 列表：安装 Python 3 和 pip 工具： # dnf install python3 python3-pip
  • 列表：使用 pip 安装 AWS 命令行工具 ： $ pip3 install awscli
  • 命令/配置摘录：
# dnf install python3 python3-pip
$ pip3 install awscli
  • 注意：重要 Image-builder 将 AWS SDK 用于 Go v2，它本身不支持动态凭证。如果您只使用上述配置集上传，则凭证会被静默忽略，从而导致以下错误： "Getting: operation error S3: CreateMultipartUpload, get identity: get credentials: failed to refresh cache credentials, no EC2 IMDS role found…​" 要绕开这个限制，请设置您的 [default] 配置文件或其他指定的配置文件使用 credential_process。 更自然的技术翻译：这会将动态会话令牌映射到 image-builder 可以读取的静态风格的凭证。在 ~/.aws/config 文件中添加以下内容：

17.2. 使用 CLI 手动将 AMI 镜像上传到 AWS

  • 要点：您可以使用 RHEL 镜像构建器构建 AMI 镜像，并使用 CLI 手动将它们上传到 Amazon AWS Cloud 服务提供商。
  • 要点：先决条件
  • 列表：已使用本地系统中配置的 credential_process 临时解决方案创建了静态或动态凭证。请参阅准备手动上传 AWS AMI 镜像。
  • 列表：您已在 AWS IAM 账号管理器中配置了一个 Access Key ID。
  • 列表：您已准备好了一个可写的 S3 存储桶。
  • 列表：您有一个定义的蓝图。
  • 列表：构建镜像： $ sudo image-builder build ami \ --blueprint <blueprint_name> \ --aws-region us-east-1 \ --aws-bucket <example_bucket> \ --aws-ami-name <image_name>
  • 列表：将镜像上传到 AWS。对于独立原始镜像，请使用 upload 命令： $ sudo image-builder upload rhel-10.1-ami-x86_64.raw \ --to=aws --aws-region=eu-central-1 \ --aws-bucket=<my_bucket> --aws-ami-name <image_name> 如果您使用默认配置集临时解决方案配置了动态凭证，upload 命令会自动使用配置的 credential_process 流。
  • 命令/配置摘录：
$ sudo image-builder build ami \  --blueprint <blueprint_name> \  --aws-region us-east-1 \  --aws-bucket <example_bucket> \  --aws-ami-name <image_name>
$ sudo image-builder upload rhel-10.1-ami-x86_64.raw \ --to=aws --aws-region=eu-central-1 \ --aws-bucket=<my_bucket> --aws-ami-name <image_name>

17.3. 创建镜像并将其自动将上传到 AWS Cloud AMI

  • 要点：您可以使用 RHEL 镜像构建器创建 RAW 镜像，然后选择 Upload to AWS 来自动将镜像上传到 Amazon AWS Cloud AMI 服务供应商。
  • 要点：先决条件
  • 列表：您必须有访问系统的 root 或 wheel 组用户权限。
  • 列表：您已在浏览器中打开了 RHEL web 控制台的 RHEL 镜像构建器界面。
  • 列表：您已创建了 RHEL 镜像构建器蓝图。
  • 列表：您必须在 AWS Identity and Access Management (IAM)帐户管理器中配置了一个 Access Key ID。
  • 列表：您必须准备了一个可写的 AWS Simple Storage Service (S3)存储桶。
  • 列表：在 RHEL 镜像构建器仪表盘中，在 blueprint name 里选择蓝图。选择 Images 选项卡，然后单击 Create Image。
  • 命令/配置摘录：
$ chmod 400 <your_instance_name>.pem
$ ssh -i <your-instance_name>.pem \\ ec2-user@<your-instance-IP-address>
  • 注意：注意 如果您不知道您的 Secret Key，请生成新的 Access Key ID。

第 18 章 准备 VHD 镜像并将其上传到 Microsoft Azure

  • 要点：您可以使用 RHEL 镜像构建器在 Microsoft Azure 云上手动创建或自动更新这些镜像。

18.1. 准备手动上传 Microsoft Azure VHD 镜像

  • 要点：要创建可手动上传到 Microsoft Azure 云的虚拟硬盘(VHD)镜像，您可以使用 RHEL 镜像构建器。
  • 要点：先决条件
  • 列表：您必须有 Microsoft Azure 资源组和存储帐户。
  • 列表：您已安装了 Python。AZ CLI 工具依赖于 Python。
  • 列表：导入 Microsoft 存储库密钥： $ sudo rpm --import https://packages.microsoft.com/keys/microsoft-2025.asc
  • 列表：创建一个 packages-microsoft-com-prod 存储库： [azure-cli] name=Azure CLI baseurl=https://packages.microsoft.com/yumrepos/packages.microsoft.com/rhel/10/prod/ enabled=1 gpgcheck=1 gpgkey=https://packages.microsoft.com/keys/microsoft.asc
  • 列表：安装 Microsoft Azure CLI。下载的 Microsoft Azure CLI 软件包版本可能会因当前可用的版本而异。 $ sudo dnf install azure-cli
  • 列表：运行 Microsoft Azure CLI： $ az login 命令行显示以下信息：Note, we have launched a browser for you to login.对于旧的设备代码，请使用 az login --use-device-code。随后，命令行会打开一个 Login 界面，您可以在其中完成登录。 注意 如果您正在运行远程(SSH)会话，则浏览器中不会打开登录页面链接。在这种情况下，您可以将链接复制到浏览器，并登录以验证您的远程会话。要登录，请使用网页浏览器打开 Login 页面，并输入要进行身份验证的设备代码。
  • 命令/配置摘录：
$ sudo rpm --import https://packages.microsoft.com/keys/microsoft-2025.asc
[azure-cli] name=Azure CLI baseurl=https://packages.microsoft.com/yumrepos/packages.microsoft.com/rhel/10/prod/ enabled=1 gpgcheck=1 gpgkey=https://packages.microsoft.com/keys/microsoft.asc
  • 注意：注意 如果您正在运行远程(SSH)会话，则浏览器中不会打开登录页面链接。在这种情况下，您可以将链接复制到浏览器，并登录以验证您的远程会话。要登录，请使用网页浏览器打开 Login 页面，并输入要进行身份验证的设备代码。

18.2. 手动将 VHD 镜像上传到 Microsoft Azure 云

  • 要点：创建自定义虚拟硬盘驱动器(VHD)镜像，并手动将其上传到 Microsoft Azure 云。当使用 CLI 创建 .vhd 镜像时，RHEL 镜像构建器将临时文件写入 /var 子目录。
  • 要点：先决条件
  • 列表：必须配置您的系统才能上传 Microsoft Azure VHD 镜像。
  • 列表：您有一个 Azure 访问密钥存储帐户。
  • 列表：创建 azure.toml 蓝图，并在其中添加以下信息： provider = "azure" [settings] storageAccount = "<your-storage-account-name>" storageAccessKey = "<storage-access-key-you-copied-in-the-Azure-portal>" container = "<your-storage-container-name>"
  • 列表：构建镜像，传递以下参数： $ image-builder build <your-blueprint> vhd <your-image-key> azure.toml 将 <your-image-key> 替换为您要的镜像的名称。
  • 列表：将镜像推送到 Microsoft Azure 并从中创建一个实例： $ az storage blob upload --account-name <account-name> --container-name <container-name> --file <image-disk>.vhd --name image-disk.vhd --type page
  • 列表：上传到 Microsoft Azure Blob 存储后，从其创建一个 Microsoft Azure 镜像。使用 RHEL 镜像构建器创建的镜像会生成支持 V1 = BIOS 和 V2 = UEFI 的混合镜像。使用 --hyper-v-generation 指定实例类型。V1 是默认值。 $ az image create --resource-group resource_group_name --name image-disk.vhd --os-type linux --location location \ --source https://$account_name.blob.core.windows.net/cont…
  • 命令/配置摘录：
provider = "azure" [settings] storageAccount = "<your-storage-account-name>" storageAccessKey = "<storage-access-key-you-copied-in-the-Azure-portal>" container = "<your-storage-container-name>"
$ image-builder build <your-blueprint> vhd <your-image-key> azure.toml
  • 注意：注意 蓝图中的分区和文件系统配置决定了 .vhd 镜像大小。不足的存储可能会导致 "No space left on device" 错误。确保 /var 有至少 15 到 20 GB 的可用空间。

18.3. 创建 VHD 镜像并将其自动上传到 Microsoft Azure 云

  • 要点：通过使用 RHEL 镜像构建器，您可以创建 .vhd 镜像，该镜像会自动上传到 Microsoft Azure Cloud 服务供应商中的 Azure Blob 存储。
  • 要点：先决条件
  • 列表：有对系统的 root 访问权限。
  • 列表：您有访问 RHEL web 控制台的 RHEL 镜像构建器界面的权限。
  • 列表：您创建了蓝图。请参阅在 web 控制台界面中创建一个 RHEL 镜像构建器蓝图。
  • 列表：您已创建了 Microsoft 存储帐户。
  • 列表：您有一个可写入 Blob Storage。
  • 列表：在 RHEL 镜像构建器仪表盘中，选择您的蓝图，点 Images 选项卡，然后点击 Create Image 来创建自定义 .vhd 镜像。

第 19 章 准备 VMDK 自定义镜像，并将其上传到 vSphere

  • 要点：您可以使用 RHEL 镜像构建器创建自定义镜像，并手动或自动更新到 VMware vSphere 云。

19.1. 使用镜像构建器创建并自动上传自定义的 RHEL VMDK 镜像

  • 要点：使用 RHEL 镜像构建器，您可以使用 Open Virtualization 格式(OVA)创建自定义系统镜像，并将这些镜像自动上传到 VMware vSphere 客户端。
  • 要点：OVA (.ova)是一个 .vmdk 镜像，它带有虚拟硬件的额外元数据，它包含一个最小模板，以便更轻松地将镜像导入到 vSphere 中。.ovf (Open Virtualization Format)软件包是 vSphere .ova 镜像的一部分。在 RHEL 镜像构建器完成将 .ova 镜像导入到 vSphere 客户端后，您可以使用任何其他硬件（如网络、磁盘和 CD ROMS）来配置它。
  • 列表：在浏览器中从 web 控制台打开 RHEL 镜像构建器应用程序。
  • 列表：您创建了蓝图。
  • 列表：在 RHEL 镜像构建器仪表盘中，点 Blueprint 选项卡。
  • 列表：在蓝图表中，找到您要构建镜像的蓝图。
  • 列表：在所选蓝图的右侧，点 Create Image。Create image 对话框向导将打开。
  • 列表：在 Image 输出页面中完成以下步骤： 从 Select a blueprint 列表中，选择您想要的镜像类型。 从 Image output type 列表中，选择您想要的镜像输出类型。 可选：选中 Upload to VMware 复选框，来将镜像直接上传到 VMware。 输入镜像的大小。 点 Next。

19.2. 上传 VMDK 镜像并在 vSphere 中创建 RHEL 虚拟机

  • 要点：使用 RHEL 镜像构建器，您可以创建自定义的 VMware vSphere 系统镜像，可以是 Open virtualization 格式(.ova)，也可以是虚拟磁盘(.vmdk)格式。
  • 要点：您可以将自定义镜像上传到 VMware vSphere 客户端。您可以使用 govc import.vmdk CLI 工具将 .vmdk 或 .ova 镜像上传到 VMware vSphere。您创建的 vmdk 包含已安装的 cloud-init 软件包，例如，您可以使用用户数据来置备用户。
  • 列表：您已使用用户名和密码自定义创建了一个蓝图。
  • 列表：您使用 RHEL 镜像构建器创建了 .ova 或 .vmdk 格式的 VMware vSphere 镜像，并将其下载到您的主机系统。
  • 列表：您已安装并配置了 govc CLI 工具，以便可以使用 import.vmdk 命令。
  • 列表：使用 GOVC 环境变量在用户环境中配置以下值： GOVC_URL GOVC_DATACENTER GOVC_FOLDER GOVC_DATASTORE GOVC_RESOURCE_POOL GOVC_NETWORK
  • 列表：进入到您下载 VMware vSphere 镜像的目录。
  • 列表：按照以下步骤在 vSphere 上启动 VMware vSphere 镜像： 将 VMware vSphere 镜像导入到 vSphere 中： $ govc import.vmdk ./api.vmdk <folder-name> 对于 .ova 格式： $ govc import.ova ./api.ova <folder-name> 在 vSphere 中创建虚拟机而不开机： govc vm.create \ -net.adapter=vmxnet3 \ -m=4096 -c=2 -g=rhel8_64Guest \ -firmware=efi -disk="<folder-name>/api.vmdk” \ -disk.c…
  • 命令/配置摘录：
GOVC_URL GOVC_DATACENTER GOVC_FOLDER GOVC_DATASTORE GOVC_RESOURCE_POOL GOVC_NETWORK
$ govc import.vmdk ./api.vmdk <folder-name>
  • 注意：注意 不支持使用 VMware vSphere GUI 上传 vmdk 镜像。
  • 注意：注意 不支持使用通过 govc datastore.upload 命令复制的镜像。vSphere GUI 不支持 import.vmdk 命令或直接导入，因此无法通过 vSphere GUI 使用 .vmdk 镜像。

19.3. 使用镜像构建器 GUI 创建 VMDK 镜像，并自动将其上传到 vSphere

  • 要点：您可以使用 RHEL 镜像构建器图形用户界面(GUI)工具构建 VMware 镜像，并自动将镜像直接推送到 vSphere 实例。这可避免手动下载镜像文件并推送它。
  • 要点：您创建的 vmdk 包含已安装的 cloud-init 软件包，例如，您可以使用用户数据来置备用户。要使用 RHEL 镜像构建器构建 .vmdk 镜像，并直接推送到 vSphere 实例服务提供商，请按照以下步骤执行：
  • 列表：您是 root 或 weldr 组的成员。
  • 列表：您已在浏览器中打开了 RHEL 镜像构建程序。
  • 列表：您已创建了蓝图。
  • 列表：您有一个 vSphere 帐户。
  • 列表：对于您创建的蓝图，点 Images 选项卡。
  • 列表：点 Create Image 创建自定义镜像。 Image type 窗口打开。
  • 命令/配置摘录：
$ rpm -qa | grep firefox

第 20 章 准备自定义 GCE 镜像并将其上传到 Google Cloud

  • 要点：使用 RHEL 镜像构建器，您可以构建 Google Compute Engine (GCE)镜像，为用户或 Google Cloud 服务帐户提供凭证，然后将 GCE 镜像直接上传到 Google Cloud 环境。

20.1. 使用 CLI 配置并上传 gce 镜像到 Google Cloud

  • 要点：使用凭证配置配置文件，通过 RHEL 镜像构建器 CLI 将 Google Compute Engine (GCE)镜像上传到 Google Cloud。
  • 要点：先决条件
  • 列表：您有有效的 Google 帐户和凭证，可将镜像上传到 Google Cloud。凭据可以从用户帐户或服务帐户获取。与凭证关联的帐户必须至少分配以下身份和访问管理(IAM)角色： roles/storage.admin - 用于创建和删除存储对象 roles/compute.storageAdmin - 将虚拟机镜像导入到 Compute Engine。
  • 列表：roles/storage.admin - 用于创建和删除存储对象
  • 列表：roles/compute.storageAdmin - 将虚拟机镜像导入到 Compute Engine。
  • 列表：您已有一个 Google Cloud 存储桶。 警告 您无法手动将 GCE 镜像导入到 Google Cloud，因为此类镜像无法启动。您必须使用 gcloud 或 RHEL 镜像构建器上传它。
  • 列表：使用文本编辑器创建一个包含以下内容的 gcp-config.toml 配置文件： provider = "gcp" [settings] bucket = "<gcp_bucket>" region = "<gcp_storage_region>" object = "<object_key>" credentials = "<gcp_credentials>" <gcp_bucket> 指向一个现有存储桶。此字段存储要上传的镜像的中间存储对象。 <gcp_storage_region> 可以是常规的 Google 存储区域，也可以是双区域或多区域。 <object_key> 是中间存储对象的名称。它在上传前不得存在，并且在上传过…
  • 列表：<gcp_bucket> 指向一个现有存储桶。此字段存储要上传的镜像的中间存储对象。
  • 命令/配置摘录：
provider = "gcp" [settings] bucket = "<gcp_bucket>" region = "<gcp_storage_region>" object = "<object_key>" credentials = "<gcp_credentials>"
$ sudo base64 -w 0 cee-gcp-nasa-476a1fa485b7.json
  • 注意：警告 您无法手动将 GCE 镜像导入到 Google Cloud，因为此类镜像无法启动。您必须使用 gcloud 或 RHEL 镜像构建器上传它。
  • 注意：注意 如果您使用不同的机制与 Google Cloud 进行身份验证，那么在 gcp-config.toml 文件中指定 <gcp_credentials> 是可选的。有关其他验证方法，请参阅 使用 Google Cloud 进行身份验证 。

20.2. RHEL 镜像构建器如何对不同的 Google Cloud 凭证的身份验证顺序进行排序

  • 要点：您可以在 RHEL 镜像构建器中使用几种不同类型的凭证来使用 Google Cloud 进行身份验证。如果将 RHEL 镜像构建器配置设置为使用多个凭证与 Google Cloud 进行身份验证，它会以首选顺序使用凭证。
  • 要点：首选顺序如下：
  • 列表：在配置文件中，使用 image-builder 命令指定的凭据。
  • 列表：Google Cloud SDK 库中的 应用程序默认凭证，它尝试使用以下选项自动找到身份验证的方法： 如果您设置了 GOOGLE_APPLICATION_CREDENTIALS 环境变量，应用程序默认凭据会尝试加载并使用变量所指向的文件中的凭证。 应用默认凭据尝试使用附加到运行代码的资源的服务帐户进行身份验证。例如，Google Compute Engine 虚拟机。 注意 您必须使用 Google Cloud 凭证来确定要将镜像上传到的 Google Cloud 项目。要上传到不同项目，请使用 image-builder 命令在 gcp-config.toml 中指定凭证。
  • 列表：如果您设置了 GOOGLE_APPLICATION_CREDENTIALS 环境变量，应用程序默认凭据会尝试加载并使用变量所指向的文件中的凭证。
  • 列表：应用默认凭据尝试使用附加到运行代码的资源的服务帐户进行身份验证。例如，Google Compute Engine 虚拟机。 注意 您必须使用 Google Cloud 凭证来确定要将镜像上传到的 Google Cloud 项目。要上传到不同项目，请使用 image-builder 命令在 gcp-config.toml 中指定凭证。
  • 注意：注意 您必须使用 Google Cloud 凭证来确定要将镜像上传到的 Google Cloud 项目。要上传到不同项目，请使用 image-builder 命令在 gcp-config.toml 中指定凭证。

第 21 章 准备自定义镜像，并将其直接上传到 OCI

  • 要点：您可以使用 RHEL 镜像构建器创建自定义镜像，并将它们自动更新到 Oracle Cloud Infrastructure (OCI)实例中。

21.1. 创建自定义镜像，并将其自动将上传到 OCI

  • 要点：使用 RHEL 镜像构建器，您可以构建自定义镜像并自动将它们直接推送到 Oracle Cloud Infrastructure (OCI)实例。然后，您可以从 OCI 仪表盘中启动镜像实例。
  • 要点：先决条件
  • 列表：您有访问系统的 root 或 weldr 组用户权限。
  • 列表：您有一个 Oracle Cloud 帐户。
  • 列表：您必须在 OCI 策略中 具有安全访问权限。
  • 列表：您已在您选择的 OCI_REGION 中创建了 OCI Bucket。
  • 列表：在浏览器中打开 web 控制台的 RHEL 镜像构建器界面。
  • 列表：点 Create blueprint。Create blueprint 向导将打开。

第 22 章 准备自定义 QCOW2 镜像，并将其直接上传到 OpenStack

  • 要点：您可以使用 RHEL 镜像构建器创建自定义 .qcow2 镜像，并手动将它们上传到 OpenStack 云部署。

22.1. 将 QCOW2 镜像上传到 OpenStack

  • 要点：使用 RHEL 镜像构建器工具，您可以创建适合上传到 OpenStack 云部署和启动实例的自定义 .qcow2 镜像。RHEL 镜像构建器以 QCOW2 格式创建镜像，但针对 OpenStack 有进一步的更改。
  • 要点：先决条件
  • 列表：您已创建了蓝图。
  • 列表：启动 QCOW2 镜像的 compose。 # image-builder build qcow2 --blueprint blueprint_name
  • 列表：访问 OpenStack 仪表盘，并单击 +Create Image。
  • 列表：在左侧菜单中，选择 Admin 选项卡。
  • 列表：从系统面板中，点镜像。 Create An Image 向导将打开。
  • 列表：在 Create An Image 向导中： 输入镜像的名称 点 Browse，上传 QCOW2 镜像。 从 格式 下拉列表中，选择 QCOW2 - QEMU Emulator。 点 Create Image。
  • 命令/配置摘录：
# image-builder build qcow2 --blueprint blueprint_name

第 23 章 准备自定义 RHEL 镜像，并将其上传到 Alibaba Cloud

  • 要点：您可以将使用 RHEL 镜像构建器创建的自定义 .ami 镜像上传到 Alibaba Cloud。

23.1. 使用 Alibaba Cloud 创建自定义 RHEL 镜像的一个实例

  • 要点：您可以使用 Alibaba ECS 控制台创建自定义 RHEL 镜像的实例。
  • 要点：先决条件
  • 列表：您已激活了 OSS 并上传您的自定义镜像。
  • 列表：您已成功将镜像导入到 ECS 控制台。
  • 列表：登录到 ECS 控制台。
  • 列表：在左侧菜单中，选择 Instances。
  • 列表：在右上角，点 Create Instance。此时会打开一个新窗口。
  • 列表：完成所有必需的信息。如需了解更多详细信息，请参阅使用自定义启动创建实例 。
  • 注意：注意 根据订阅，您可以看到 Create Order 选项，而不是 Create Instance 选项。

23.2. 将镜像导入到 Alibaba Cloud

  • 要点：您可以将使用 RHEL 镜像构建器创建的自定义 Alibaba RHEL 镜像导入到 Elastic Compute Service (ECS)。
  • 要点：先决条件
  • 列表：配置您的系统以上传 Alibaba 镜像。
  • 列表：您已使用 RHEL 镜像构建器创建了一个 ami 镜像。
  • 列表：您有一个存储桶。请参阅创建存储桶。
  • 列表：您有一个活跃的 Alibaba 帐户。
  • 列表：已激活了 OSS。
  • 列表：您已将镜像上传到对象存储服务(OSS)。

23.3. 将自定义 RHEL 镜像上传到 Alibaba

  • 要点：您可以使用 RHEL 镜像构建器将您创建的自定义 AMI 镜像上传到对象存储服务(OSS)。
  • 要点：先决条件
  • 列表：配置您的系统以上传 Alibaba 镜像。
  • 列表：您已使用 RHEL 镜像构建器创建了一个 ami 镜像。
  • 列表：您有一个存储桶。请参阅创建存储桶。
  • 列表：您有一个活跃的 Alibaba 帐户。
  • 列表：已激活了 OSS。
  • 列表：登录到 OSS 控制台。

23.4. 准备将自定义 RHEL 镜像上传到 Alibaba Cloud

  • 要点：要将自定义 RHEL 镜像部署到 Alibaba Cloud 中，您必须首先验证自定义镜像。镜像需要特定的配置才能引导，因为 Alibaba Cloud 自定义镜像必须满足某些要求。
  • 要点：先决条件
  • 列表：您必须已使用 RHEL 镜像构建器创建了一个 Alibaba 镜像。
  • 列表：使用 Alibaba image_check 工具连接到包含您要检查的镜像的系统。
  • 列表：下载 image_check 工具： $ curl -O https://docs-aliyun.cn-hangzhou.oss.aliyun-inc.com/assets/attach/73848/cn_zh/1557459863884/image_check
  • 列表：更改镜像合规工具的文件权限： # chmod +x image_check
  • 列表：运行命令启动镜像合规工具检查： # ./image_check 该工具会检查系统配置，并在屏幕上显示生成的报告。image_check 工具将此报告保存在与运行镜像合规工具同样的文件夹中。
  • 列表：如果任何 检测项 失败，请按照命令行中的说明进行更正。
  • 命令/配置摘录：
$ curl -O https://docs-aliyun.cn-hangzhou.oss.aliyun-inc.com/assets/attach/73848/cn_zh/1557459863884/image_check
# chmod +x image_check
  • 注意：注意 RHEL 镜像构建器生成符合 Alibaba 要求的镜像。但是，您必须使用 Alibaba 的 image_check 工具来验证镜像的格式合规性。

完整目录

  • 在 RHEL 10.0 上使用 RHEL 镜像构建器创建自定义系统镜像
  • 对红帽文档提供反馈
  • 第 1 章 RHEL 镜像构建器描述
    • 1.1. RHEL 镜像构建器术语
    • 1.2. RHEL 镜像构建器输出格式
    • 1.3. 支持的用于镜像构建的构架
    • 1.4. 其他资源
  • 第 2 章 安装 RHEL 镜像构建器
    • 2.1. RHEL 镜像构建器系统要求
    • 2.2. 安装 RHEL 镜像构建器
  • 第 3 章 配置 RHEL 镜像构建器存储库
    • 3.1. 在 RHEL 镜像构建器中添加附加软件仓库
    • 3.2. 将带有特定发行版的第三方存储库添加到 RHEL 镜像构建器中
    • 3.3. 在镜像构建过程中覆盖系统存储库
    • 3.4. 配置 Satellite CV ，并将其用作内容源
    • 3.5. 使用 Satellite CV 作为存储库，来在 RHEL 镜像构建器中构建镜像
  • 第 4 章 使用 RHEL 镜像构建器 CLI 创建系统镜像
    • 4.1. RHEL 镜像构建器命令行界面简介
    • 4.2. RHEL 镜像构建器蓝图格式
    • 4.3. 使用命令行创建蓝图
    • 4.4. 在命令行上使用 RHEL 镜像构建器创建系统镜像
    • 4.5. 基本 RHEL 镜像构建器命令行命令
    • 4.6. 在自定义镜像中启用服务
  • 第 5 章 支持的镜像自定义
    • 5.1. 选择一个发行版
    • 5.2. 选择一个软件包组
    • 5.3. 选择一个软件包
    • 5.4. 嵌入容器
    • 5.5. 设置镜像主机名
    • 5.6. 指定其他用户
    • 5.7. 指定附加组
    • 5.8. 为现有用户设置 SSH 密钥
    • 5.9. 附加一个内核参数
    • 5.10. 使用实时内核构建 RHEL 镜像
    • 5.11. 设置时区和 NTP
    • 5.12. 自定义区域设置
    • 5.13. 自定义防火墙
    • 5.14. 启用或禁用服务
    • 5.15. ISO 镜像中的 Kickstart 文件注入
    • 5.16. 指定分区模式
    • 5.17. 自定义文件系统配置规格
      • 5.17.1. 蓝图中的自定义文件规格
      • 5.17.2. 蓝图中的自定义目录规格
    • 5.18. 蓝图中的卷组和逻辑卷命名规格
  • 第 6 章 使用 RHEL 镜像构建器 web 控制台界面创建系统镜像
    • 6.1. 在 RHEL web 控制台中访问 RHEL 镜像构建器仪表盘
    • 6.2. 在 web 控制台界面中创建一个蓝图
    • 6.3. 在 RHEL 镜像构建器 web 控制台界面中导入蓝图
    • 6.4. 从 RHEL 镜像构建器 web 控制台界面导出蓝图
    • 6.5. 在 web 控制台界面中使用 RHEL 镜像构建器创建系统镜像
  • 第 7 章 使用 RHEL 镜像构建器创建一个引导 ISO 安装程序镜像
    • 7.1. 使用 RHEL 镜像构建器 CLI 创建一个引导 ISO 安装程序镜像
    • 7.2. 在 GUI 中使用 RHEL 镜像构建器创建一个引导 ISO 安装程序镜像
    • 7.3. 将可引导 ISO 安装到介质并引导它
  • 第 8 章 使用 RHEL 镜像构建器创建网络安装程序镜像
    • 8.1. 网络安装程序镜像的好处
    • 8.2. RHEL 镜像构建器中的 ISO 镜像类型概述
    • 8.3. 使用 image-builder cli 创建网络安装程序镜像
    • 8.4. 使用 Web 控制台创建网络安装程序镜像
  • 第 9 章 使用 RHEL 镜像构建器 OpenSCAP 集成创建预强化的镜像
    • 9.1. OpenSCAP 蓝图自定义
    • 9.2. 使用 RHEL 镜像构建器创建一个预强化的镜像
    • 9.3. 使用 RHEL 镜像构建器自定义预先强化的镜像
  • 第 10 章 使用 RHEL 镜像构建器启用 FIPS 模式
  • 第 11 章 使用 RHEL 镜像构建器生成 WSL 2 镜像
  • 第 12 章 使用 RHEL 镜像构建器准备并部署 KVM 客户机镜像
    • 12.1. 使用 RHEL 镜像构建器创建自定义 KVM 客户机镜像
    • 12.2. 从 KVM 客户机镜像创建虚拟机
  • 第 13 章 使用 RHEL 镜像构建器创建 Vagrant 框
    • 13.1. 为 libvirt 和 VirtualBox 后端构建 Vagrant 镜像
  • 第 14 章 使用 RHEL 镜像构建器创建无状态镜像
    • 14.1. 使用镜像构建器 CLI 构建 PXE 引导的 RHEL 镜像
    • 14.2. 使用 HTTP 服务器在 PXE 引导环境中引导无状态镜像
    • 14.3. 使用组合镜像在 PXE 引导环境中引导无状态镜像
  • 第 15 章 将容器推送到 registry 中并将其嵌入到镜像中
    • 15.1. 自定义蓝图，将容器嵌入到镜像中
    • 15.2. 将容器工件直接推送到容器 registry
    • 15.3. 构建镜像并将容器提取到镜像中
  • 第 16 章 使用 RHEL 镜像构建器准备并上传云镜像
  • 第 17 章 准备 AMI 镜像并将其上传到 AWS
    • 17.1. 准备手动上传 AWS AMI 镜像
    • 17.2. 使用 CLI 手动将 AMI 镜像上传到 AWS
    • 17.3. 创建镜像并将其自动将上传到 AWS Cloud AMI
  • 第 18 章 准备 VHD 镜像并将其上传到 Microsoft Azure
    • 18.1. 准备手动上传 Microsoft Azure VHD 镜像
    • 18.2. 手动将 VHD 镜像上传到 Microsoft Azure 云
    • 18.3. 创建 VHD 镜像并将其自动上传到 Microsoft Azure 云
  • 第 19 章 准备 VMDK 自定义镜像，并将其上传到 vSphere
    • 19.1. 使用镜像构建器创建并自动上传自定义的 RHEL VMDK 镜像
    • 19.2. 上传 VMDK 镜像并在 vSphere 中创建 RHEL 虚拟机
    • 19.3. 使用镜像构建器 GUI 创建 VMDK 镜像，并自动将其上传到 vSphere
  • 第 20 章 准备自定义 GCE 镜像并将其上传到 Google Cloud
    • 20.1. 使用 CLI 配置并上传 gce 镜像到 Google Cloud
    • 20.2. RHEL 镜像构建器如何对不同的 Google Cloud 凭证的身份验证顺序进行排序
  • 第 21 章 准备自定义镜像，并将其直接上传到 OCI
    • 21.1. 创建自定义镜像，并将其自动将上传到 OCI
  • 第 22 章 准备自定义 QCOW2 镜像，并将其直接上传到 OpenStack
    • 22.1. 将 QCOW2 镜像上传到 OpenStack
  • 第 23 章 准备自定义 RHEL 镜像，并将其上传到 Alibaba Cloud
    • 23.1. 使用 Alibaba Cloud 创建自定义 RHEL 镜像的一个实例
    • 23.2. 将镜像导入到 Alibaba Cloud
    • 23.3. 将自定义 RHEL 镜像上传到 Alibaba
    • 23.4. 准备将自定义 RHEL 镜像上传到 Alibaba Cloud