Red Hat Training

A Red Hat training course is available for RHEL 8

创建自定义 RHEL 系统镜像

Red Hat Enterprise Linux 8

在 Red Hat Enterprise Linux 8 上使用镜像构建器创建自定义系统镜像

Red Hat Customer Content Services

摘要

镜像构建器是用于创建部署就绪的自定义系统镜像的工具:安装磁盘、虚拟机、特定于云供应商的镜像等。使用镜像构建器,与手动过程相比,您可以更快地创建这些镜像,因为它消除了每个输出类型所需的特定配置。本文档论述了如何设置镜像构建器并使用它创建镜像。

使开源包含更多

红帽承诺替换我们的代码、文档和网页属性中存在问题的语言。我们从这四个术语开始:master、slave、黑名单和白名单。由于此项工作十分艰巨,这些更改将在即将推出的几个发行版本中逐步实施。详情请查看 CTO Chris Wright 的信息

对红帽文档提供反馈

我们感谢您对我们文档的反馈。让我们了解如何改进它。

根据具体内容提交评论

  1. 查看 Multi-page HTML 格式的文档,并确保在页面完全加载后看到右上角的 Feedback 按钮。
  2. 使用光标突出显示您要评论的文本部分。
  3. 点在高亮文本旁的 Add Feedback 按钮。
  4. 添加您的反馈并点 Submit

通过 Bugzilla 提交反馈(需要帐户)

  1. 登录到 Bugzilla 网站。
  2. Version 菜单中选择正确的版本。
  3. Summary 字段中输入描述性标题。
  4. Description 字段中输入您对改进的建议。包括文档相关部分的链接。
  5. Submit Bug

第 1 章 镜像构建器描述

要在云平台中部署系统,请创建一个系统镜像。要创建 RHEL 系统镜像,请使用镜像构建器工具。

1.1. 什么是镜像构建器?

您可以使用镜像构建器来创建 RHEL 的自定义系统镜像,包括为在云平台上进行部署的系统镜像。镜像构建器自动处理每个输出类型的设置详情,因此比手动创建镜像方法更易于使用和更快地使用。您可以通过 composer-cli 工具中的命令行界面或 RHEL web 控制台中的图形用户界面来访问镜像构建器的功能。

注意

从 RHEL 8.3 开始,osbuild-composer 后端替换了 lorax-composer。新服务为镜像构建提供 REST API。

1.2. 镜像构建器术语

蓝图(Blueprint)

蓝图是自定义系统镜像的描述。它列出了将成为系统一部分的软件包和自定义。您可以使用自定义编辑蓝图,并将其保存为特定版本。从蓝图创建系统镜像时,该镜像与 RHEL web 控制台的镜像构建器界面中的蓝图相关联。

您可以使用 TOML 格式创建蓝图。

组合(Compose)
compose 是基于特定蓝图的特定版本的系统镜像构建。作为一个术语,Compose 代表系统镜像以及来自其创建、输入、元数据和进程本身的日志。
自定义(Customizations)
自定义是不是软件包的镜像的规格。这包括用户、组和 SSH 密钥。

1.3. 镜像构建器输出格式

镜像构建器可以以多种输出格式创建镜像,如下表中所示。要检查支持的类型,请运行以下命令:

# composer-cli compose types

表 1.1. 镜像构建器输出格式

描述CLI 名称文件扩展

QEMU QCOW2 镜像

qcow2

.qcow2

TAR 归档

tar

.tar

Amazon 机器镜像磁盘

ami

.raw

Azure 磁盘镜像

vhd

.vhd

Google Cloud Platform

gce

.vhd

VMware 虚拟机磁盘

vmdk

.vmdk

Openstack

openstack

.qcow2

用于边缘提交的 RHEL

edge-commit

.tar

用于边缘容器的 RHEL

edge-container

.tar

用于边缘安装程序的 RHEL

edge-installer

.iso

用于 Edge Raw 的 RHEL

edge-raw-image

.tar

用于边缘简化安装程序的 RHEL

edge-simplified-installer

.iso

ISO 镜像

image-installer

.iso

1.4. 镜像构建器系统要求

镜像构建器运行的环境(如专用的虚拟机)必须满足下表中列出的要求。

表 1.2. 镜像构建器系统要求

参数最低要求值

系统类型

专用的虚拟机。请注意,镜像构建器在容器上不支持,包括 Red Hat Universal Base Images (UBI)。

处理器

2 个内核

内存

4 GiB

磁盘空间

/var 文件系统中有 20 GiB 的可用空间

访问权限

管理员级别(root)

Network

互联网连接

注意

如果您没有互联网连接,您可以在隔离的网络中使用镜像构建程序(如果您重新配置它以不连接到 Red Hat Content Delivery Network (CDN)。为此,您必须覆盖默认软件仓库以指向您的本地存储库。确保您有内部镜像的内容或使用 Red Hat Satellite。如需了解更多详细信息,请参阅管理软件仓库

第 2 章 安装镜像构建器

在使用镜像构建器之前,您必须在虚拟机中安装镜像构建器。

2.1. 在虚拟机中安装镜像构建器

要在专用虚拟机(VM)上安装镜像构建程序,请按照以下步骤操作:

先决条件

  • 您必须连接到 RHEL 虚拟机。
  • 镜像构建器的虚拟机必须正在运行并订阅到 Red Hat Subscription Manager (RHSM) 或 Red Hat Satellite。

流程

  1. 在虚拟机上安装镜像构建程序和其他必要的软件包:

    • osbuild-composer - 从 RHEL 8.3 开始支持
    • composer-cli
    • cockpit-composer
    • bash-completion
    # yum install osbuild-composer composer-cli cockpit-composer bash-completion

    Web 控制台作为 cockpit-composer 软件包的依赖项安装。

  2. 在每次重启后启动镜像构建器:

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

    osbuild-composercockpit 服务在第一次访问时自动启动。

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

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

osbuild-composer 软件包是新的后端引擎,它将是从 Red Hat Enterprise Linux 8.3 及更高版本开始的所有新功能的首选默认和重点。之前的后端 lorax-composer 软件包被视为已弃用,将只接收 Red Hat Enterprise Linux 8 生命周期剩余部分所选定的修复,并将在以后的主发行版本中被忽略。建议卸载 lorax-composer ,使用 osbuild-composer。

验证

您可以使用系统日志来跟踪镜像构建器服务活动。此外,您还可以在文件中找到日志消息。

  • 要查找回溯的日志输出,请运行以下命令:

    $ journalctl | grep osbuild
  • 显示远程或本地 worker:

    $ journalctl -u osbuild-worker*
  • 显示运行的服务:

    $ journalctl -u osbuild-composer.service

2.2. 恢复到 lorax-composer 镜像构建程序后端

osbuild-composer 后端虽然具有更大的可扩展性,但目前还无法与之前的 lorax-composer 后端功能相媲美。

要回到以前的后端,请按照以下步骤操作:

先决条件

  • osbuild-composer 软件包已安装

流程

  1. 删除 osbuild-composer 后端。

    # yum remove osbuild-composer
    # yum remove weldr-client
  2. /etc/yum.conf 文件中 ,为 osbuild-composer 软件包添加一个排除项。

    # cat /etc/yum.conf
    [main]
    gpgcheck=1
    installonly_limit=3
    clean_requirements_on_remove=True
    best=True
    skip_if_unavailable=False
    exclude=osbuild-composer weldr-client
  3. 安装 lorax-composer 软件包。

    # yum install lorax-composer composer-cli
  4. 启用并启动 lorax-composer 服务,以便在每次重启后启动。

    # systemctl enable --now lorax-composer.socket
    # systemctl start lorax-composer

第 3 章 管理镜像构建器存储库

3.1. 镜像构建器默认系统存储库

osbuild-composer 后端不会继承位于 /etc/yum.repos.d/ 目录中的系统存储库。相反,它拥有自己的一组在 /usr/share/osbuild-composer/repositories 目录中定义的官方存储库。这包括红帽官方存储库,其中包含要安装附加软件或将已安装的程序基础更新到新版本的基础系统 RPM。如果要覆盖官方存储库,您必须在 /etc/osbuild-composer/repositories 中定义覆盖。这个目录用于用户定义的覆盖,其中的文件优先于 /usr 目录中的文件。

配置文件不是 /etc/yum.repos.d/ 中常见的 YUM 存储库格式。相反,它们是简单的 JSON 文件。

3.2. 覆盖系统存储库

您可以按照以下步骤在 /etc/osbuild-composer/repositories 目录中为镜像构建器配置存储库覆盖。

注意

在 RHEL 8.5 发行版本中,仓库覆盖的名称为 rhel-8.json。从 RHEL 8.5 开始,名称也会尊重次要版本: rhel-84.jsonrhel-85.json 等等。

先决条件

  • 您有一个可从主机系统访问的自定义存储库

流程

  1. 创建一个要存储存储库覆盖的目录:

    $ sudo mkdir -p /etc/osbuild-composer/repositories
  2. 您可以创建自己的 JSON 文件结构。
  3. 使用与 RHEL 版本对应的名称,创建一个 JSON 文件。或者,您还可以从 /usr/share/osbuild-composer/ 中复制用于分发的文件,并修改其内容。

    对于 RHEL 8,使用 /etc/osbuild-composer/repositories/rhel-88.json

  4. 向 JSON 文件中添加以下结构,例如:

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

    仅指定以下属性之一:

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

      剩余的字段是可选的。

      1. 或者,您也可以复制 JSON 文件以用于您的分发。

        1. 将存储库文件复制到您创建的目录中。在以下命令中,将 rhel-version.json 替换为您的 RHEL 版本,例如:rhel-8.json。

          $  cp /usr/share/osbuild-composer/repositories/rhel-version.json /etc/osbuild-composer/repositories/
  5. 使用文本编辑器,编辑 rhel-8.json 文件中的 baseurl 路径,并保存。例如:

    $ vi /etc/osbuild-composer/repositories/rhel-version.json
  6. 重启 osbuild-composer.service

    $ sudo systemctl restart osbuild-composer.service

验证

  • 检查存储库是否指向正确的 URL:

    $ cat /etc/yum.repos.d/redhat.repo

    您可以看到仓库指向从 /etc/yum.repos.d/redhat.repo 文件复制的正确 URL。

3.3. 覆盖支持订阅的系统存储库

osbuild-composer 服务可以使用 /etc/yum.repos.d/redhat.repo 文件中定义的系统订阅。要在 osbuild-composer 中使用系统订阅,请定义具有以下内容的存储库覆盖:

  • /etc/yum.repos.d/redhat.repo 中定义的存储库相同的 baseurl
  • JSON 对象中定义的 "rhsm": true 值。

先决条件

  • 您的系统有一个在 /etc/yum.repos.d/redhat.repo 中定义的订阅
  • 您已创建了一个存储库覆盖。请参阅 覆盖系统存储库

流程

  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-8/8.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-8/8.0/AppStream/x86_64/os/",
                "gpgkey": "-----BEGIN PGP PUBLIC KEY BLOCK-----\n\n (…​)",
                "check_gpg": true,
                "rhsm": true
            }
        ]
    }
    注意

    osbuild-composer 不自动使用 /etc/yum.repos.d/ 中定义的存储库。您需要手动将它们指定为系统存储库覆盖 ,或使用 composer-cli 指定为额外的 。系统存储库覆盖通常用于"BaseOS"和"AppStream"存储库,而 composer-cli 源则用于所有其他存储库。

因此,镜像构建器从主机系统读取 /etc/yum.repos.d/redhat.repo 文件,并使用它作为订阅源。

第 4 章 使用镜像构建器命令行界面创建系统镜像

镜像构建器是创建自定义系统镜像的工具。要控制镜像构建器并创建自定义系统镜像,您可以使用命令行界面(CLI)或 Web 控制台界面。但是,当前 CLI 是使用镜像构建器的首选方法。

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

镜像构建器命令行界面(CLI)目前是使用镜像构建器的首选方法。它提供比 Web 控制台界面更多的功能。要使用 CLI,请使用适当的选项和子命令运行 composer-cli 命令。

命令行界面的工作流总结如下:

  1. 将蓝图定义导出(保存)到纯文本文件
  2. 在文本编辑器中编辑这个文件
  3. 将蓝图文本文件导回到(push)镜像构建器
  4. 运行 compose 来从蓝图构建镜像
  5. 导出镜像文件以下载它

除了实现此过程的基本子命令外,composer-cli 命令还提供多个子命令来检查配置的蓝图和组合的状态。

要以非 root 身份运行 composer-cli 命令,用户必须在 weldrroot 组中。

  • 要在 weldrroot 组中添加用户,请运行以下命令:

    $ sudo usermod -a -G weldr user
    $ newgrp weldr

4.2. 使用命令行界面创建镜像构建器蓝图

您可以使用命令行界面 (CLI) 创建新的镜像构建器蓝图。蓝图描述了最终的镜像及其自定义,如软件包和内核自定义。

前提条件

  • 访问镜像构建器工具。

流程

  1. 创建一个包含以下内容的纯文本文件:

    name = "BLUEPRINT-NAME"
    description = "LONG FORM DESCRIPTION TEXT"
    version = "0.0.1"
    modules = []
    groups = []

    用您的蓝图的名称和描述替换 BLUEPRINT-NAMELONG FORM DESCRIPTION TEXT

    根据 Semantic Versioning 方案,将 0.0.1 替换为一个版本号。

  2. 对于您要包含在蓝图中的每个软件包,请在文件中添加以下行:

    [[packages]]
    name = "package-name"
    version = "package-version"

    使用软件包名称替换 package-name,比如 httpdgdb-doc 或者 coreutils

    package-version 替换为要使用的版本。此字段支持 dnf 版本规范:

    • 对于特定版本,请使用确切的版本号,如 8.7.0
    • 对于最新可用版本,请使用星号 *
    • 对于最新的次版本,请使用以下格式,如 8.*。
  3. 自定义蓝图以满足您的需要。例如,禁用 Simultaneous Multi Threading (SMT),在蓝图文件中添加以下行:

    [customizations.kernel]
    append = "nosmt=force"

    有关其他可用的定制信息,请参阅 支持的镜像自定义

  4. 将文件保存为 例如 BLUEPRINT-NAME.toml,并关闭文本编辑器。
  5. 推送(导入)蓝图:

    # composer-cli blueprints push BLUEPRINT-NAME.toml

    BLUEPRINT-NAME 替换为您在前面步骤中使用的值。

    注意

    以非 root 身份运行 composer-cli 命令创建镜像,请将您的用户添加到 weldrroot 组中。

    # usermod -a -G weldr user
    $ newgrp weldr

验证

  • 列出现有的蓝图以验证蓝图是否已推送并已存在:

    # composer-cli blueprints list
  • 显示您刚刚添加的蓝图配置:

    # composer-cli blueprints show BLUEPRINT-NAME
  • 检查蓝图中列出的组件和版本是否有效:

    # composer-cli blueprints depsolve BLUEPRINT-NAME

    如果镜像构建器无法从自定义存储库中解释软件包,请按照以下步骤执行:

  • 删除 osbuild-composer 缓存:

    $ sudo rm -rf /var/cache/osbuild-composer/*
    $ sudo systemctl restart osbuild-composer

4.3. 使用命令行界面编辑镜像构建器蓝图

您可以在命令行(CLI)界面中编辑现有的镜像构建器蓝图,例如添加新软件包或定义一个新组,以创建自定义镜像。为此,请按照以下步骤操作:

先决条件

  • 您已创建了蓝图。

流程

  1. 将蓝图保存(导出)到本地文本文件:

    # composer-cli blueprints save BLUEPRINT-NAME
  2. 使用文本编辑器编辑 BLUEPRINT-NAME.toml 文件并进行更改。
  3. 在完成编辑前,请验证该文件是否是一个有效的蓝图:

    1. 如果存在,删除此行:

      packages = []
    2. 增加版本号,如从 0.0.1 增加到 0.1.0。请记住,镜像构建器蓝图版本必须使用 Semantic Versioning 方案。请注意,如果您没有更改版本,补丁版本组件会自动增加。
    3. 检查内容是否是有效的 TOML 规格。如需更多信息,请参阅 TOML 文档

      注意

      TOML 文档是一款社区产品,红帽不支持。您可以使用该工具报告任何问题: https://github.com/toml-lang/toml/issues

  4. 保存文件并关闭文本编辑器。
  5. 将蓝图推送(导入)回镜像构建器:

    # composer-cli blueprints push BLUEPRINT-NAME.toml
    注意

    要将蓝图导回到镜像构建器,请提供包括 .toml 扩展名的文件名,而其他命令则只使用蓝图名称。

  6. 要验证上传到镜像构建器的内容是否与您编辑的匹配,请列出蓝图的内容:

    # composer-cli blueprints show BLUEPRINT-NAME
  7. 检查蓝图中列出的组件和版本是否有效:

    # composer-cli blueprints depsolve BLUEPRINT-NAME

4.4. 在命令行界面中使用镜像构建器创建系统镜像

您可以使用镜像构建器命令行界面构建自定义镜像。

先决条件

流程

  1. 启动 compose:

    # composer-cli compose start BLUEPRINT-NAME IMAGE-TYPE

    BLUEPRINT-NAME 替换为蓝图的名称,将 IMAGE-TYPE 替换为镜像的类型。有关可用值,请查看 composer-cli compose types 命令的输出。

    compose 进程在后台启动,并显示 composer Universally Unique Identifier (UUID)。

  2. 等待 compose 过程完成。镜像创建最多可能需要十分钟才能完成。

    检查 Compose 的状态:

    # composer-cli compose status

    完成的 compose 显示 FINISHED 状态值。要识别列表中您的 compose,请使用其 UUID。

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

    # composer-cli compose image UUID

    使用前面步骤中显示的 UUID 值替换 UUID。

验证

创建镜像后,您可以使用以下命令检查镜像创建进度:

  • 检查 compose 状态:

    $ sudo composer-cli compose status
  • 下载镜像元数据:

    $ sudo composer-cli compose metadata UUID
  • 下载镜像的日志:

    $ sudo composer-cli compose logs UUID

    该命令会创建一个 .tar 文件,其中包含创建镜像的日志。如果日志为空,您可以检查日志。

  • 检查日志:

    $ journalctl | grep osbuild
  • 检查清单:

    $ sudo cat /var/lib/osbuild-composer/jobs/job_UUID.json

    您可以在日志中找到 job_UUID.json。

其他资源

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

镜像构建器命令行界面提供以下子命令。

蓝图操作

列出所有可用的蓝图
# composer-cli blueprints list
显示 TOML 格式的蓝图内容
# composer-cli blueprints show BLUEPRINT-NAME
将蓝图内容以 TOML 格式保存(导出)到文件 BLUEPRINT-NAME.toml
# composer-cli blueprints save BLUEPRINT-NAME
删除蓝图
# composer-cli blueprints delete BLUEPRINT-NAME
将 TOML 格式的蓝图文件推送(导入)到镜像构建器中
# composer-cli blueprints push BLUEPRINT-NAME

从蓝图制作镜像

列出可用的镜像类型
# composer-cli compose types
启动一个目录
# composer-cli compose start BLUEPRINT COMPOSE-TYPE

BLUEPRINT 替换为要构建的蓝图名称,将 COMPOSE-TYPE 替换为输出镜像类型。

列出所有 compose
# composer-cli compose list
列出所有 compose 及其状态
# composer-cli compose status
取消正在运行的 compose
# composer-cli compose cancel COMPOSE-UUID
删除完成的 compose
# composer-cli compose delete COMPOSE-UUID
显示有关 compose 的详细信息
# composer-cli compose info COMPOSE-UUID
下载 compose 的镜像文件
# composer-cli compose image COMPOSE-UUID
更多子命令和选项
# composer-cli help

其他资源

  • composer-cli(1) man page

4.6. 镜像构建器蓝图格式

镜像构建器蓝图以纯文本形式展现给用户,格式为 TOML 格式。

典型的蓝图文件元素包括:

蓝图元数据
name = "BLUEPRINT-NAME"
description = "LONG FORM DESCRIPTION TEXT"
version = "VERSION"

BLUEPRINT-NAMELONG FORM DESCRIPTION TEXT 字段是您的蓝图的名称和描述。

VERSIONSemantic Versioning 方案的版本号。

这部分只针对整个蓝图文件显示一次。

modules 条目列出了要安装到镜像中的软件包名称和版本。

group 条目描述要安装到镜像中的一组软件包。组使用以下软件包类别:

  • Mandatory(必需)
  • Default(默认)
  • 选填

    蓝图安装必需的和默认的软件包。没有选择可选软件包的机制。

镜像中包含的组
[[groups]]
name = "group-name"

group-name 是组的名称,例如 anaconda-tools, widget, wheelusers

镜像中包含的软件包
[[packages]]
name = "package-name"
version = "package-version"

package-name 是软件包的名称,如 httpdgdb-doccoreutils

package-version 是要使用的版本。此字段支持 dnf 版本规范:

  • 对于特定版本,请使用确切的版本号,如 8.7.0
  • 对于最新的可用版本,请使用星号 *
  • 对于最新的次版本,请使用以下格式,如 8.*。

为每个要包括的软件包重复这个块。

注意

目前镜像构建器工具中的软件包和模块之间没有区别。两者都被视为 RPM 软件包依赖项。

4.7. 支持的镜像自定义

您可以通过启用服务或自定义内核命令行参数来在蓝图中添加额外的 RPM 软件包来自定义镜像。您可以在蓝图中使用多个镜像自定义。要使用这些选项,您必须在蓝图中配置自定义,并将其导入(推送)到镜像构建器。

注意

在 web 控制台中使用镜像构建器时,不支持这些自定义。

选择一个软件包组
[[packages]]
name = "package_group_name"

将 "package_group_name" 替换为组的名称。例如:"@server with gui"。

设置镜像主机名
[customizations]
hostname = "baseimage"
生成系统镜像的用户规范
[[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 = NUMBER
gid = NUMBER

GID 是可选的,且必须在镜像中已存在。(可选)软件包会创建它,或者蓝图使用 [[customizations.group] 条目创建 GID。

重要

要生成 密码哈希,您必须在系统上安装 python3

# yum install python3

PASSWORD-HASH 替换为实际的 密码哈希。要生成 密码哈希,请使用如下命令:

$ python3 -c 'import crypt,getpass;pw=getpass.getpass();print(crypt.crypt(pw) if (pw==getpass.getpass("Confirm: ")) else exit())'

PUBLIC-SSH-KEY 替换为实际公钥。

使用适当的值替换其他占位符。

您必须输入 name。您可以省略您不需要的任何行。

为每个要包含的用户重复这个块。

生成系统镜像的组规范
[[customizations.group]]
name = "GROUP-NAME"
gid = NUMBER

为每个组重复此块。

设置现有的用户 SSH 密钥
[[customizations.sshkey]]
user = "root"
key = "PUBLIC-SSH-KEY"
注意

"创建现有用户 SSH 密钥"自定义仅适用于现有用户。要创建用户并设置 SSH 密钥,请参阅 生成系统镜像的用户规格 自定义。

在默认值中附加一个内核引导参数选项
[customizations.kernel]
append = "KERNEL-OPTION"
默认情况下,镜像构建器将默认内核构建到镜像中。但是,您可以使用蓝图中的以下配置自定义内核
[customizations.kernel]
name = "KERNEL-rt"
定义一个要在镜像中使用的内核名称
[customizations.kernel.name]
name = "KERNEL-NAME"
为生成的系统镜像设置时区和 网络时间协议 (NTP) 服务器
[customizations.timezone]
timezone = "TIMEZONE"
ntpservers = "NTP_SERVER"

如果您没有设置时区,系统将默认使用 Universal Time, Coordinated (UTC)。设置 NTP 服务器是可选的。

为生成的系统镜像设置区域设置
[customizations.locale]
languages = ["LANGUAGE"]
keyboard = "KEYBOARD"

设置语言和键盘选项是必需的。您可以添加许多其他语言。您添加的第一个语言是主要语言,其他语言为次要语言。例如:

[customizations.locale]
languages = ["en_US.UTF-8"]
keyboard = "us"

要列出语言支持的值,请运行以下命令:

$ localectl list-locales

要列出键盘支持的值,请运行以下命令:

$ localectl list-keymaps
为生成的系统镜像设置防火墙
[customizations.firewall]
port = ["PORTS"]

要启用列表,您可以使用数字端口或 /etc/services 文件中的名称。

自定义防火墙服务

查看可用的防火墙服务。

$ firewall-cmd --get-services

在蓝图中,在 customs.firewall.service 部分下指定要自定义的防火墙服务。

[customizations.firewall.services]
enabled = ["SERVICES"]
disabled = ["SERVICES"]

firewall.services 中列出的服务与 /etc/services 文件中提供的服务名不同。

注意

如果您不想自定义防火墙服务,请省略蓝图中的 [customizations.firewall][customizations.firewall.services] 部分。

设置在引导时要启用哪个服务
[customizations.services]
enabled = ["SERVICES"]
disabled = ["SERVICES"]

您可以控制在引导期间要启用哪些服务。有些镜像类型已经启用或禁用了服务,以确保镜像可以正常工作,此设置不能被覆盖。蓝图中的 [customizations.services] 自定义不会替换这些服务,而是将它们添加到镜像模板中已存在的服务列表中。

注意

每次构建启动时,它会克隆主机系统的存储库。如果您引用一个包含大量历史记录的存储库,则可能需要一些时间来克隆,其使用了大量的磁盘空间。另外,克隆是临时的,构建会在创建 RPM 软件包后将其删除。

指定自定义文件系统配置

您可以在蓝图中指定自定义文件系统配置,因此可以创建具有特定磁盘布局,而不是默认布局配置的镜像。通过使用蓝图中的非默认布局配置,您可以受益于:

  • 安全基准合规性
  • 防止磁盘不足错误
  • 提高了性能
  • 与现有设置的一致性

    要在蓝图中自定义文件系统配置:

    [[customizations.filesystem]]
    mountpoint = "MOUNTPOINT"
    size = MINIMUM-PARTITION-SIZE

    蓝图支持以下 mountpoints 及其子目录:

    • / - root 挂载点
    • /var
    • /home
    • /opt
    • /srv
    • /usr
    • /app
    • /data
    • /boot - 从 RHEL 8.7 和 RHEL 9.1 开始支持。

      注意

      通过使用 CLI,只有 RHEL 8.5 和 RHEL 9.0 发行版支持自定义挂载点。在之前的发行版本中,您只能将 root 分区指定为挂载点,并将 size 参数指定为镜像大小的别名。

      如果您在自定义镜像中有多个分区,您可以在 LVM 上创建带有自定义文件系统分区的镜像,并在运行时调整这些分区大小。要做到这一点,您可以在蓝图中指定自定义的文件系统配置,因此可以创建具有所需磁盘布局的镜像。默认文件系统布局保持不变 - 如果您使用没有文件系统自定义的普通镜像,cloud-init 会调整 root 分区的大小。

      注意

      从 8.6 开始,对于 osbuild-composer-46.1-1.el8 RPM 及更新的版本,物理分区不再可用,文件系统自定义创建逻辑卷。

      蓝图自动将文件系统自定义转换为 LVM 分区。

      MINIMUM-PARTITION-SIZE 值没有默认大小格式。蓝图自定义支持以下值和单位:kB 到 TB 以及 KiB 到 TiB。例如,您可以以字节为单位定义挂载点大小:

      [[customizations.filesystem]]
      mountpoint = "/var"
      size = 1073741824

      您还可以使用单位定义挂载点大小。

      注意

      您只能使用为 RHEL 8.6 和 RHEL 9.0 发行版提供的软件包版本的单元来定义挂载点大小。

      例如:

      [[customizations.filesystem]]
      mountpoint = "/opt"
      size = "20 GiB"
      
      or
      
      [[customizations.filesystem]]
      mountpoint = "/boot"
      size = "1 GiB"
/etc 目录下为您的镜像创建自定义目录和文件

要在镜像中创建自定义文件和目录,请使用 [[customizations.files]][[customizations.directories]] 蓝图自定义。目前,您只能在 /etc 目录中使用这些自定义。

注意

这些蓝图自定义适用于所有镜像类型,但部署 OSTree 提交的镜像类型除外,如 edge-raw-imageedge-installeredge-simplified-installer

创建自定义目录蓝图自定义

使用 [[customizations.directories]] 蓝图自定义,您可以在镜像的 /etc 目录中创建自定义目录。

警告

如果您使用自定义 . 目录,且镜像中已存在的目录路径已设置了 模式用户或组 ,则镜像构建无法防止更改现有目录的所有权或权限。

使用 [[customizations.directory]] 蓝图自定义,您可以:

  • 创建新目录。
  • 为您要创建的目录设置用户和组所有权。
  • 以八进制格式设置目录模式权限。
  • 确保根据需要创建父目录。

要在蓝图中自定义目录配置,请使用以下内容创建一个文件,例如:

[[customizations.directories]]
path = "/etc/directory_name"
mode = "octal_access_permission"
user = "user_string_or_integer"
group = "group_string_or_integer"
ensure_parents = boolean

蓝图条目如下所述:

  • path - Mandatory - 输入您要创建的目录的路径。它必须是 /etc 目录下的绝对路径。
  • mode - 可选 - 以八进制格式设置目录的访问权限。如果没有指定权限,则默认为 0755。前导零是可选的。
  • user - 可选 - 将用户设置为目录的所有者。如果没有指定用户,则默认为 root。您可以将用户指定为字符串或整数。
  • group - 可选 - 将组设置为目录的所有者。如果没有指定组,则默认为 root。您可以将组指定为字符串或整数。
  • ensure_parents - 可选 - 指定是否要根据需要创建父目录。如果没有指定值,则默认为 false

创建自定义文件蓝图自定义

您可以使用自定义文件蓝图自定义来创建新文件或替换现有文件。您指定的文件的父目录必须存在,否则镜像构建会失败。通过在 [[customizations.directories]] 自定义中指定它来确保父目录存在。

警告

如果您将文件自定义与其他蓝图自定义相结合,这可能会影响其他自定义的功能,或者可能会覆盖当前的文件自定义。如果您不确定自定义,请使用适当的蓝图自定义。

使用 [[customizations.files]] 蓝图自定义,您可以:

  • 创建新文本文件。
  • 修改现有文件。警告:这可以覆盖现有内容。
  • 为您要创建的文件设置用户和组所有权。
  • 以八进制格式设置模式权限。

    注意

    您无法创建或替换以下文件:

  • /etc/fstab
  • /etc/shadow
  • /etc/passwd
  • /etc/group

要在蓝图中自定义文件,请使用以下内容创建一个文件,例如:

[[customizations.files]]
path = "/etc/directory_name"
mode = "octal_access_permission"
user = "user_string_or_integer"
group = "group_string_or_integer"
data = "Hello world!"

蓝图条目如下所述:

  • path - Mandatory - 输入您要创建的文件的路径。它必须是 /etc 目录下的绝对路径。
  • 模式 可选 - 以八进制格式设置对文件的访问权限。如果没有指定权限,则默认为 0644。前导零是可选的。
  • user - 可选 - 将用户设置为文件所有者。如果没有指定用户,则默认为 root。您可以将用户指定为字符串或整数。
  • group - 可选 - 将组设置为文件所有者。如果没有指定组,则默认为 root。您可以将组指定为字符串或整数。
  • data - 可选 - 指定纯文本文件的内容。如果没有指定内容,它会创建一个空文件。

4.8. 镜像构建器安装的软件包

使用镜像构建器创建系统镜像时,系统会安装一组基本软件包。默认情况下,镜像构建器使用 Core 组作为软件包的基本列表。

表 4.1. 支持创建镜像类型的默认软件包

镜像类型默认软件包

ami

checkpolicy, chrony, cloud-init, cloud-utils-growpart, @Core, dhcp-client, gdisk, insights-client, kernel, langpacks-en, net-tools, NetworkManager, redhat-release, redhat-release-eula, rng-tools, rsync, selinux-policy-targeted, tar, yum-utils

openstack

@core, langpacks-en

qcow2

@core, chrony, dnf, kernel, yum, nfs-utils, dnf-utils, cloud-init, python3-jsonschema, qemu-guest-agent, cloud-utils-growpart, dracut-norescue, tar, tcpdump, rsync, dnf-plugin-spacewalk, rhn-client-tools, rhnlib, rhnsd, rhn-setup, NetworkManager, dhcp-client, cockpit-ws, cockpit-system, subscription-manager-cockpit, redhat-release, redhat-release-eula, rng-tools, insights-client

tar

policycoreutils, selinux-policy-targeted

vhd

@core, langpacks-en

vmdk

@core, chrony, cloud-init, firewalld, langpacks-en, open-vm-tools, selinux-policy-targeted

edge-commit

attr, audit, basesystem, bash, bash-completion, chrony, clevis, clevis-dracut, clevis-luks, container-selinux, coreutils,criu, cryptsetup, curl, dnsmasq, dosfstools, dracut-config-generic, dracut-network, e2fsprogs, firewalld, fuse-overlayfs, fwupd, glibc, glibc-minimal-langpack, gnupg2, greenboot, gzip, hostname, ima-evm-utils, iproute, iptables, iputils, keyutils, less, lvm2, NetworkManager, NetworkManager-wifi, NetworkManager-wwan, nss-altfiles, openssh-clients, openssh-server, passwd, pinentry, platform-python, podman, policycoreutils, policycoreutils-python-utils, polkit, procps-ng, redhat-release, rootfiles, rpm, rpm-ostree, rsync, selinux-policy-targeted, setools-console, setup, shadow-utils, shadow-utils, skopeo, slirp4netns, sudo, systemd, tar, tmux, traceroute, usbguard, util-linux, vim-minimal, wpa_supplicant, xz

edge-container

dnf, dosfstools, e2fsprogs, glibc, lorax-templates-generic, lorax-templates-rhel, lvm2, policycoreutils, python36, python3-iniparse, qemu-img, selinux-policy-targeted, systemd, tar, xfsprogs, xz

edge-installer

aajohan-comfortaa-fonts, abattis-cantarell-fonts, alsa-firmware, alsa-tools-firmware, anaconda, anaconda-install-env-deps, anaconda-widgets, audit, bind-utils, bitmap-fangsongti-fonts, bzip2, cryptsetup, dbus-x11, dejavu-sans-fonts, dejavu-sans-mono-fonts, device-mapper-persistent-data, dnf, dump, ethtool, fcoe-utils, ftp, gdb-gdbserver, gdisk, gfs2-utils, glibc-all-langpacks, google-noto-sans-cjk-ttc-fonts, gsettings-desktop-schemas, hdparm, hexedit, initscripts, ipmitool, iwl3945-firmware, iwl4965-firmware, iwl6000g2a-firmware, iwl6000g2b-firmware, jomolhari-fonts, kacst-farsi-fonts, kacst-qurn-fonts, kbd, kbd-misc, kdump-anaconda-addon, khmeros-base-fonts, libblockdev-lvm-dbus, libertas-sd8686-firmware, libertas-sd8787-firmware, libertas-usb8388-firmware, libertas-usb8388-olpc-firmware, libibverbs, libreport-plugin-bugzilla, libreport-plugin-reportuploader, libreport-rhel-anaconda-bugzilla, librsvg2, linux-firmware, lklug-fonts, lldpad, lohit-assamese-fonts, lohit-bengali-fonts, lohit-devanagari-fonts, lohit-gujarati-fonts, lohit-gurmukhi-fonts, lohit-kannada-fonts, lohit-odia-fonts, lohit-tamil-fonts, lohit-telugu-fonts, lsof, madan-fonts, metacity, mtr, mt-st, net-tools, nmap-ncat, nm-connection-editor, nss-tools, openssh-server, oscap-anaconda-addon, pciutils, perl-interpreter, pigz, python3-pyatspi, rdma-core, redhat-release-eula, rpm-ostree, rsync, rsyslog, sg3_utils, sil-abyssinica-fonts, sil-padauk-fonts, sil-scheherazade-fonts, smartmontools, smc-meera-fonts, spice-vdagent, strace, system-storage-manager, thai-scalable-waree-fonts, tigervnc-server-minimal, tigervnc-server-module, udisks2, udisks2-iscsi, usbutils, vim-minimal, volume_key, wget, xfsdump, xorg-x11-drivers,xorg-x11-fonts-misc,xorg-x11-server-utils,xorg-x11-server-Xorg, xorg-x11-xauth

edge-simplified-installer

attr, basesystem, binutils, bsdtar, clevis-dracut, clevis-luks, cloud-utils-growpart, coreos-installer, coreos-installer-dracut, coreutils, device-mapper-multipath, dnsmasq, dosfstools, dracut-live, e2fsprogs, fcoe-utils, fdo-init, gzip, ima-evm-utils, iproute, iptables, iputils, iscsi-initiator-utils, keyutils, lldpad, lvm2, passwd, policycoreutils, policycoreutils-python-utils, procps-ng, rootfiles, setools-console, sudo, traceroute, util-linux

image-installer

anaconda-dracut, curl, dracut-config-generic, dracut-network, hostname, iwl100-firmware, iwl1000-firmware, iwl105-firmware, iwl135-firmware, iwl2000-firmware, iwl2030-firmware, iwl3160-firmware, iwl5000-firmware, iwl5150-firmware, iwl6000-firmware, iwl6050-firmware, iwl7260-firmware, kernel, less, nfs-utils, openssh-clients, ostree, plymouth, prefixdevname, rng-tools, rpcbind, selinux-policy-targeted, systemd, tar, xfsprogs, xz

edge-raw-image

dnf, dosfstools, e2fsprogs, glibc, lorax-templates-generic, lorax-templates-rhel, lvm2, policycoreutils, python36, python3-iniparse, qemu-img, selinux-policy-targeted, systemd, tar, xfsprogs, xz

gce

@core, langpacks-en, acpid, dhcp-client, dnf-automatic, net-tools, python3, rng-tools, tar, vim

注意

当您在蓝图中添加其他组件时,请确保添加的组件中的软件包不会与任何其他软件包组件冲突。否则,系统无法解决依赖项并创建自定义镜像失败。您可以通过运行以下命令检查软件包之间没有冲突:

# composer-cli blueprints depsolve BLUEPRINT-NAME

其他资源

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

当使用镜像构建器配置自定义镜像时,镜像使用的默认服务由以下内容决定:

  • 使用 osbuild-composer 工具的 RHEL 发行版本
  • 镜像类型

例如,ami 镜像类型默认启用 sshdchronydcloud-init 服务。如果没有启用这些服务,则自定义镜像不会引导。

表 4.2. 启用服务来支持镜像类型创建

镜像类型默认启用的服务

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

rhel-edge-commit

默认没有启用任何额外服务

tar

默认没有启用任何额外服务

vhd

sshd, chronyd, waagent, cloud-init, cloud-init-local, cloud-config, cloud-final

vmdk

sshd、chronyd、vmtoolsd、cloud-init

注:您可以自定义在系统引导过程中要启用的服务。但是,自定义不会覆盖上述镜像类型默认启用的服务。

第 5 章 使用镜像构建器 Web 控制台界面创建系统镜像

镜像构建器是创建自定义系统镜像的工具。要控制镜像构建器并创建自定义系统镜像,您可以使用 Web 控制台界面。请注意, 命令行界面 目前为首选,因为它提供了更多的功能。

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

使用 RHEL web 控制台的 cockpit-composer 插件,您可以使用图形界面管理镜像构建器蓝图和 compose。

先决条件

  • 您必须有对该系统的根权限。
  • 已安装镜像构建器。

流程

  1. 在安装了镜像构建器的系统上的 Web 浏览器中打开 https://localhost:9090/

    有关如何远程访问镜像构建器的更多信息,请参阅 使用 RHEL web 控制台管理系统 文档。

  2. 以 root 用户身份登录 Web 控制台。
  3. 要显示镜像构建器控制,请单击窗口左上角的 镜像构建器 图标。

    镜像构建器短划线会打开,列出现有的蓝图(若有)。

5.2. 在 web 控制台界面中创建镜像构建程序蓝图

在创建自定义 RHEL 系统镜像前,创建蓝图是一个必要的步骤。所有自定义都是可选的。

注意

这些蓝图自定义可用于 Red Hat Enterprise Linux 9.2 或更高版本,或 Red Hat Enterprise Linux 8.8 或更高版本。

先决条件

流程

  1. 点右上角的 Create Blueprint

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

  2. Details 页面中:

    1. 输入蓝图的名称,以及可选的描述。点击 Next
  3. 可选:在 Packages 页面中:

    1. Available packages 搜索中,输入软件包名称并点击 & gt; 按钮将其移到 Chosen packages 字段。搜索并包含您想要多的软件包。点击 Next

      注意

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

  4. Kernel 页面中,输入内核名称和命令行参数。
  5. 文件系统 页面中,您可以选择 Use automatic partitioning手动配置 镜像文件系统的分区。要手动配置分区,请完成以下步骤:

    1. 手动配置分区 按钮。

      此时会打开 Configure partitions 部分,显示基于红帽标准和安全指南的配置。

    2. 在下拉菜单中,提供配置分区的详情:

      1. 对于 Mount point 字段,选择以下挂载点类型选项之一:

        • / - root 挂载点
        • /var
        • /home
        • /opt
        • /srv
        • /usr
        • /app
        • /data
        • /tmp
        • /usr/local

          您还可以向 挂载点 添加附加路径,如 /tmp。例如: /var 作为前缀,/tmp 作为附加路径会导致 /var/tmp

          注意

          根据您选择的挂载点类型,文件系统类型会更改为 xfs,以此类推。

      2. 对于 文件系统的 Minimum size 分区 字段,请输入所需的最小分区大小。在最小大小下拉菜单中,您可以使用通用大小单位,如 GiBMiBKiB。默认单位为 GiB

        注意

        最小大小 意味着镜像构建器仍然可以增加分区大小,以防它们太小来创建工作镜像。

    3. 要添加更多分区,请点击 Add partition 按钮。如果您看到以下出错信息:"Duplicate partitions: 每个挂载点只有一个分区。",您可以:

      1. Remove 按钮删除重复的分区。
      2. 为您要创建的分区选择一个新的挂载点。
    4. 完成分区配置后,点 Next
  6. Services 页面中,您可以启用或禁用服务:

    1. 输入您要启用或禁用的服务名称,用逗号、空格或按 Enter 键分隔它们。点击 Next
  7. Firewall 页面中,设置防火墙设置:

    1. 输入 Ports,以及您要启用或禁用的防火墙服务。
    2. Add zone 按钮,为每个区单独管理您的防火墙规则。点击 Next
  8. Users 页面中,按照以下步骤添加用户:

    1. 单击 Add user
    2. 输入用户名密码,以及 SSH 密钥。您还可以单击 Server administrator 复选框,将用户标记为特权用户。点击 Next
  9. Groups 页面中,完成以下步骤来添加组:

    1. Add groups 按钮:

      1. 输入 组名称 和组 ID。您可以添加更多组。点击 Next
  10. SSH 密钥 页面中,添加一个密钥:

    1. Add key 按钮。

      1. 输入 SSH 密钥。
      2. 输入 用户。点击 Next
  11. Timezone 页面中,设置您的时区设置:

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

      如果您没有设置时区,系统默认使用 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/sda1。点击 Next
  14. 仅在构建 FIDO 镜像时才强制: 在 FIDO 设备加入 页面中完成以下步骤:

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

      1. DIUN 公钥不安全 字段中,输入不安全的公钥。
      2. DIUN 公钥哈希 字段中,输入公钥哈希。
      3. DIUN 公钥 root certs 字段中,输入公钥 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

镜像构建器视图将打开,列出现有的蓝图。

5.3. 在镜像构建器 Web 控制台界面中导入蓝图

您可以导入并使用已存在的蓝图。系统会自动解决所有依赖项。

先决条件

  • 您已在浏览器中从 thr Web 控制台打开了镜像构建器应用。
  • 您有一个要在镜像构建器 web 控制台界面中使用的蓝图。

流程

  1. 在镜像构建器仪表盘上,单击 Import blueprint。此时会打开 Import blueprint 向导。
  2. Upload 字段中,拖放或上传现有的蓝图。此蓝图可以是 TOMLJSON 格式。
  3. Import。仪表板列出了您导入的蓝图。

    当您点您导入的蓝图时,您可以访问带有您导入蓝图的所有自定义仪表板。

验证

  • 要验证已为导入蓝图选择的软件包,请导航到 Packages 选项卡。

    • 要列出所有软件包依赖项,请单击 All。列表是可搜索的,并可排序。
  • 可选:修改任何自定义:

    • Customizations 仪表板中,点击您要更改的自定义。另外,您可以点击 Edit blueprint 来导航到所有可用的自定义选项。

5.4. 从镜像构建器 Web 控制台界面导出蓝图

您可以导出蓝图以在另一个系统中使用自定义。您可以使用 TOMLJSON 格式导出蓝图。这两个格式在 CLI 和 API 接口中都有效。

先决条件

  • 您已在浏览器中从 Web 控制台打开了镜像构建器应用。
  • 您有一个要导出的蓝图。

流程

  1. 在镜像构建器仪表盘上,选择您要导出的蓝图。
  2. Export blueprint。此时会打开 Export blueprint 向导。
  3. 要保存 导出的蓝图,请点击 Export 按钮。

    1. (可选)点击 Copy 按钮复制蓝图。

验证

  1. 打开导出的蓝图来检查并查看它。

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

您可以通过完成以下步骤,从蓝图创建自定义 RHEL 系统镜像。

先决条件

  • 在浏览器中,您从 Web 控制台打开了镜像构建器应用。
  • 您创建了蓝图。

流程

  1. 访问镜像构建器仪表板。
  2. 在蓝图表中,找到您要构建镜像的蓝图。
  3. 在所选蓝图的右侧,点 Create ImageCreate image 对话框向导将打开。
  4. 导航到 Images 选项卡,再点 Create ImageCreate image 向导将打开。
  5. Image 输出页面中完成以下步骤:

    1. Select a blueprint 列表中,选择您想要的镜像类型。
    2. Image output type 列表中,选择您想要的镜像输出类型。

      根据您选择的镜像类型,您需要添加更多详细信息。

  6. 点击 Next
  7. Review 页面中,查看镜像创建的详情并点 Create image

    镜像构建启动,需要 20 分钟完成。

验证

镜像完成构建后,您可以:

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

第 6 章 使用镜像构建器创建引导 ISO 安装程序镜像

您可以使用镜像构建器创建可引导的 ISO 安装程序镜像。这些镜像由一个带有根文件系统的 .tar 文件组成。您可以使用可引导的 ISO 镜像来将文件系统安装到裸机服务器上。

镜像构建器构建一个清单,该清单会创建一个包含根文件系统的引导 ISO。要创建 ISO 镜像,请选择映像类型 image-installer。镜像构建器使用以下内容构建一个 .tar 文件:

  • 标准 Anaconda 安装程序 ISO
  • 嵌入式 RHEL 系统 tar 文件
  • 安装提交的默认 Kickstart 文件,其要求最小

创建的安装程序 ISO 镜像包含一个预先配置的系统镜像,您可以直接安装到裸机服务器。

6.1. 在命令行界面中使用镜像构建器创建引导 ISO 安装程序镜像

您可以使用镜像构建器命令行界面创建自定义的引导 ISO 安装程序镜像。

先决条件

  • 您已为镜像创建了一个包含用户的蓝图,并将其推送回镜像构建器。请参阅 用户的蓝图自定义

流程

  1. 创建 ISO 镜像:

    # composer-cli compose start BLUEPRINT-NAME image-installer
    • 带有您创建的蓝图名称的 BLUEPRINT-NAME
    • image-installer 是镜像类型

      compose 进程在后台启动,并显示 Compose 的 UUID。

  2. 等待 compose 完成。请注意,这可能需要几分钟时间。

    检查 Compose 的状态:

    # composer-cli compose status

    完成的 compose 显示 FINISHED 状态值。根据 UUID 识别列表中的内容。

  3. 完成 compose 后,下载创建的镜像文件:

    # composer-cli compose image UUID

    UUID 替换为前面步骤中获取的 UUID 值。

    因此,镜像构建器构建一个包含 .tar 文件的 .iso 文件。.tar 文件是要为操作系统安装的镜像。. iso 设置为引导 Anaconda 并安装 tar 文件来设置系统。

验证

  1. 导航到下载镜像文件的文件夹。
  2. 找到您下载的 .iso 镜像。
  3. 挂载 ISO。

    $ mount -o ro path_to_ISO /mnt

    您可以在 /mnt/liveimg.tar.gz 目录中找到 .tar 文件。

  4. 提取 .tar 文件内容。

    $ tar xzf /mnt/liveimg.tar.gz

您可以使用在硬盘上创建的 ISO 镜像文件,或者在虚拟机中引导,例如在 HTTP 引导或 USB 安装中。

6.2. 在 GUI 中使用镜像构建器创建引导 ISO 安装程序镜像

您可以使用镜像构建器 GUI 构建自定义引导 ISO 安装程序镜像。

先决条件

流程

  1. 在浏览器中打开 RHEL web 控制台的镜像构建器界面。请参阅使用命令行界面创建镜像构建器蓝图
  2. 找到您要用来构建镜像的蓝图。为此,请在左上角的搜索框中输入蓝图名称或部分名称,然后单击 Enter
  3. 在蓝图的右侧,点对应的 Create Image 按钮。

    Create image 对话框向导将打开。

  4. Create image 对话框向导中:

    1. Image Type 列表中,选择 "RHEL Installer (.iso) "。
    2. Create

镜像构建器将 RHEL ISO 镜像的组成添加到队列中。

注意

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

过程完成后,您可以看到镜像构建完成状态。镜像构建器创建了 ISO 镜像。

验证

成功创建镜像后,您可以下载该镜像。

  1. Download"RHEL Installer (.iso) " 镜像保存到您的系统中。
  2. 进入您下载 "RHEL Installer(.iso)" 镜像的文件夹。
  3. 找到您下载的 .tar 镜像。
  4. 提取 "RHEL 安装程序(.iso)" 镜像内容。

    $ tar -xf content.tar

您可以使用在硬盘上生成的 ISO 镜像文件,或者在虚拟机中引导,例如在 HTTP 引导或 USB 安装中。

6.3. 将镜像构建器 ISO 镜像安装到裸机系统

使用镜像构建器将您创建的可引导 ISO 镜像安装到裸机系统。

先决条件

流程

  1. 使用 dd 工具将可引导 ISO 镜像直接写入 USB 驱动器。例如:

    dd if=installer.iso of=/dev/sdX

    其中 installer.iso 是 ISO 镜像文件名,/dev/sdX 是您的 USB 闪存驱动器设备路径。

  2. 将闪存驱动器插入到您要引导的计算机的 USB 端口中。
  3. 从 USB 闪存引导 ISO 镜像。

    当安装环境启动时,您可能需要手动完成安装,类似于默认的 Red Hat Enterprise Linux 安装。

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

内部镜像构建器支持 OpenSCAP 集成来生成预先强化的 RHEL 镜像。使用与 OpenSCAP 集成的内部镜像构建器,您可以生成预先强化的 RHEL 镜像。您可以设置蓝图,从一组预定义的安全配置集中选择、添加一组软件包或附加文件,并构建了一个自定义的 RHEL 镜像,供您部署到更适合于您的环境的选择平台上。

红帽为构建系统时可以选择的安全强化配置集定期更新版本,以便您能够满足您的当前部署指南。

7.1. Kickstart 和预先强化的镜像之间的区别

对于使用 Kickstart 文件创建的传统镜像,您需要选择要安装哪些软件包,并确保系统不受安全漏洞的影响。借助镜像构建器 OpenSCAP 集成,您可以构建安全强化型镜像。在镜像构建过程中,OSBuild oscap remediation stage 在文件系统树的 chroot 中运行 OpenSCAP 工具。OpenSCAP 工具为您选择的配置集运行标准评估,并将补救应用于镜像。因此,如果您与在实时系统上运行补救进行比较,您可以构建更加全面的强化型镜像。

7.2. OpenSCAP 蓝图自定义

通过对蓝图自定义进行 OpenSCAP 支持,您可以创建蓝图,然后使用它们构建自己的预先强化的镜像。要创建预先强化的镜像,您可以自定义挂载点并根据所选的安全配置集配置文件系统布局。在镜像构建过程中,OpenSCAP 应用第一次引导补救。

选择 OpenSCAP 配置集后,OpenSCAP 蓝图自定义配置镜像,以便在使用所选配置集的镜像构建过程中触发补救。

要在镜像蓝图中使用 OpenSCAP 蓝图,请输入以下信息:

  • datastream 补救指令的数据流路径。您可以在 /usr/share/xml/scap/ssg/content/ 目录中找到。
  • 所需的安全配置集的 profile_idprofile_id 字段接受长和简短形式,例如: cisxccdf_org.ssgproject.content_profile_cis。如需了解更多详细信息,请参阅 RHEL 8 支持的 SCAP 安全指南配置集

    以下是一个带有 OpenSCAP 自定义示例的蓝图:

    [customizations]
    [customizations.openscap]
    datastream = "/usr/share/xml/scap/ssg/content/ssg-rhel8-ds.xml"
    profile_id = "xccdf_org.ssgproject.content_profile_cis"

    最常见的 SCAP 文件类型是 SCAP 源数据流。要显示 scap-security-guide 软件包中的 SCAP 源数据流详情,请输入以下命令:

    $ oscap info /usr/share/xml/scap/ssg/content/ssg-rhel8-ds.xml

    oscap 工具在镜像树上运行,以执行挂载在任意路径的文件系统的离线扫描。您可以使用它扫描 oscap-dockeroscap-vm 不支持的自定义对象,如 Docker 以外的格式容器。oscap-chroot 模拟 oscap 工具的使用和选项。

    镜像构建器根据您的蓝图自定义生成 osbuild 阶段所需的配置。另外,镜像构建器为镜像添加两个软件包:

  • openscap-scanner - OpenSCAP 工具。
  • scap-security-guide - 包含补救指令的软件包。

    注意

    补救阶段将 scap-security-guide 软件包用于 datastream,因为这个软件包默认安装在镜像中。如果要使用不同的数据流,将必要的软件包添加到蓝图中,并在 oscap 配置中指定到 datastream 的路径。

7.3. 使用镜像构建器创建预先强化的镜像

通过 OpenSCAP 与镜像构建器的集成,您可以创建预先强化的镜像。

流程

  1. 使用 TOML 格式创建蓝图,其内容如下:

    name = "blueprint_name"
    description = "blueprint_description"
    version = "0.0.1"
    modules = []
    groups = []
     distro = ""
    
    [customizations]
    [[customizations.user]]
    name = "scap-security-guide"
    description = "Admin account"
    password = secure_password_hash
    key = ssh-key
    home = "/home/scap-security-guide"
    group = ["wheel"]
    
    
    [[customizations.filesystem]]
    mountpoint = "/tmp"
    size = 13107200
    [customizations.openscap]
    datastream = "/usr/share/xml/scap/ssg/content/ssg-rhel8-ds.xml "
    profile_id = "cis"
  2. 启动 OpenSCAP 镜像的构建:

    # composer-cli compose start blueprint_name qcow2

    其中 blueprint_name 是蓝图名称。

    镜像构建就绪后,您可以在部署中使用预先强化的镜像。请参阅创建虚拟机

验证

在虚拟机中部署预先强化的镜像后,可以执行配置合规性扫描,以验证镜像是否与所选安全配置集一致。

重要

执行配置合规性扫描不能保证系统是合规的。如需更多信息,请参阅配置合规性扫描

  1. 使用 SSH 连接到镜像。
  2. 运行 oscap 扫描程序。

    # scap-workbench
  3. 选择您要扫描的系统版本。点 Load content
  4. 选择您要扫描的配置集,然后点 Scan。OpenSCAP 检查系统的所有要求。
  5. 扫描完成后,点 Show Report

    您可以从系统安全的结果中看到。

第 8 章 使用镜像构建器准备和部署 KVM 客户机镜像

要创建用于在 Red Hat Virtualization 上使用的专用镜像,您可以使用镜像构建器制作一个 KVM 客户机镜像。但请注意,只有 Red Hat Virtualization 中的 rhel-guest-image 才支持 KVM 客户机镜像。

使用自定义 KVM 客户机镜像涉及以下高级别步骤:

  1. 使用镜像构建器创建 KVM 客户机 .qcow2 镜像。
  2. 从 KVM 客户机镜像创建虚拟机。

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

您可以使用镜像构建器创建自定义 .qcow2 KVM 客户机镜像。

先决条件

流程

  1. 点您创建的蓝图名称。
  2. 选择 Images 选项卡。
  3. 单击 Create Image 来创建自定义镜像。此时会打开弹出窗口。
  4. Type 下拉菜单中选择 QEMU Image (.qcow2)
  5. 在实例化时设置您想要的镜像大小,并点击 Create
  6. 窗口右上角的小弹窗通知您已将镜像创建添加到队列中。镜像创建过程完成后,您可以看到镜像构建完成状态。

验证

  1. 点击 breadcrumbs 图标,并选择 Download 选项。镜像构建器将 KVM 客户机镜像 .qcow2 文件下载到您的默认下载位置。

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

使用镜像构建器,您可以构建 .qcow2 镜像,并使用 KVM 客户机镜像创建虚拟机。使用镜像构建器创建的 KVM 客户机镜像已安装并启用了 cloud-init

先决条件

  • 您已使用镜像构建器创建了一个 .qcow2 镜像。请参阅 在 web 控制台界面中创建镜像构建器蓝图。
  • qemu-kvm 软件包已安装在您的系统上。您可以检查您系统中是否有 /dev/kvm 文件夹。
  • 在您的系统上已安装了 libvirtvirt-install 软件包。
  • genisoimage 工具已安装在您的系统上。

流程

  1. 将您使用镜像构建器创建的 KVM 客户机镜像移到 /var/lib/libvirt/images 目录中。
  2. 创建一个目录,如 cloudinitiso ,并导航到这个新创建的目录:

    $ mkdir cloudinitiso
    $ cd cloudinitiso
  3. 创建一个名为 meta-data 的文件。在此文件中添加以下信息:

    instance-id: citest
    local-hostname: vmname
  4. 创建一个名为 user-data 的文件。在文件中添加以下信息:

    #cloud-config
    user: admin
    password: password
    chpasswd: {expire: False}
    ssh_pwauth: True
    ssh_authorized_keys:
      - ssh-rsa AAA...fhHQ== your.email@example.com

    其中,ssh_authorized_keys 是您的 SSH 公钥。您可以在 ~/.ssh/id_rsa.pub 中找到 SSH 公钥。

  5. 使用 genisoimage 命令创建一个包含 user-datameta-data 文件的 ISO 镜像。

    # genisoimage -output cloud-init.iso -volid cidata -joliet -rock user-data meta-data
    
    I: -input-charset not specified, using utf-8 (detected in locale settings)
    Total translation table size: 0
    Total rockridge attributes bytes: 331
    Total directory bytes: 0
    Path table size(bytes): 10
    Max brk space used 0
    183 extents written (0 MB)
  6. 使用 virt-install 命令从 KVM 客户机映像创建一个新虚拟机。将您在第 4 步中创建的 ISO 镜像作为虚拟机镜像的附件。

    # virt-install \
        --memory 4096 \
        --vcpus 4 \
        --name myvm \
        --disk rhel-8-x86_64-kvm.qcow2,device=disk,bus=virtio,format=qcow2 \
        --disk cloud-init.iso,device=cdrom \
        --os-variant rhel 8 \
        --virt-type kvm \
        --graphics none \
        --import

    其中,

    • --graphics none - 表示它是一个无头的 RHEL 8 虚拟机。
    • --vcpus 4 - 表示它使用 4 个虚拟 CPU。
    • --memory 4096 - 表示它使用 4096 MB RAM。
  7. 虚拟机安装开始:

    Starting install...
    Connected to domain mytestcivm
    ...
    [  OK  ] Started Execute cloud user/final scripts.
    [  OK  ] Reached target Cloud-init target.
    
    Red Hat Enterprise Linux 8 (Ootpa)
    Kernel 4.18.0-221.el8.x86_64 on an x86_64

验证

引导完成后,虚拟机会显示文本登录界面。登录到虚拟机:

  1. 输入 admin 作为用户名,然后按 Enter 键。
  2. 输入 password 作为密码,然后按 Enter 键。

    登录身份验证完成后,您可以使用 CLI 访问虚拟机。

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

通过对蓝图中的容器自定义的支持,您可以创建容器并将其直接嵌入到您创建的镜像中。

9.1. 蓝图自定义,将容器嵌入到镜像中

要从 registry.access.redhat.com registry 中嵌入容器,您必须在蓝图中添加容器自定义。例如:

[[containers]]
source = "registry.access.redhat.com/ubi9/ubi:latest"
name =  "local-name"
tls-verify = true
  • source - 必需的字段。它是对 registry 中的容器镜像的引用。这个示例使用 registry.access.redhat.com registry。您可以指定标签版本。默认标签版本为 latest
  • name - 本地 registry 中的容器名称。
  • tls-verify - 可选布尔值字段。tls-verify 布尔值字段控制传输层安全性。默认值为 true

    镜像构建器在镜像构建过程中拉取容器,并将容器存储到镜像中。默认本地容器存储位置取决于镜像类型,因此所有支持 container-tools (如 Podman)都可以使用它。嵌入的容器没有启动。要访问受保护的容器资源,您可以使用 containers-auth.json 文件。

9.2. 容器 registry 凭证

osbuild-worker 服务负责与容器 registry 的通信。要启用此功能,您可以设置 /etc/osbuild-worker/osbuild-worker.toml 配置文件。

注意

在设置 /etc/osbuild-worker/osbuild-worker.toml 配置文件后,您必须重启 osbuild-worker 服务,因为在 osbuild-worker 服务启动时,它只会读取 /etc/osbuild-worker/osbuild-worker.toml 配置文件一次。

/etc/osbuild-worker/osbuild-worker.toml 配置文件有一个 containers 部分,它带有 auth_field_path 条目,其值是是一个字符串代表用于访问受保护的资源的 containers-auth.json 文件路径。容器 registry 凭证仅在将容器嵌入到镜像中时用于从 registry 中拉取容器镜像。

以下是一个示例:

[containers]
auth_file_path = "/etc/osbuild-worker/containers-auth.json"

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

使用镜像构建程序 CLI 后,您可以将容器工件(如 RHEL for Edge 容器镜像)直接推送到容器 registry。为此,您必须设置 上传供应商 ,以及可选的凭证,然后您可以构建容器镜像,将 registry 和存储库作为参数传递到 composer-cli。镜像就绪后,可在您设置的容器 registry 中提供。

先决条件

  • 访问 quay.io registry。本例使用 quay.io 容器 registry 作为目标 registry,但您可以使用您选择的容器 registry。

流程

  1. 设置 registry-config.toml 文件以选择容器提供程序。

    provider = "container_provider"
    
    [settings]
    tls_verify = false
    username = "admin"
    password = "your_password"
  2. 使用 .toml 格式创建蓝图。这是您在蓝图中安装 nginx 软件包的容器蓝图。

    name = "simple-container"
    description = "Simple RHEL container"
    version = "0.0.1"
    
    [[packages]]
    name = "nginx"
    version = "*"
  3. 推送蓝图:

    # composer-cli blueprints push blueprint.toml
  4. 构建容器镜像:

    # composer-cli compose start simple-container container "quay.io:8080/osbuild/repository" registry-config.toml
    • simple-container - 是蓝图名称。
    • Container - 是镜像类型。
    • "quay.io:8080/osbuild/repository" - quay.io 是目标 registry, osbuild 是机构,repository 是在构建完成后要推送到的容器的位置。另外,您可以设置一个 tag。如果没有为 :tag 设置值,则默认为 :latest 标签。

      注意

      构建容器镜像需要很长时间,因为需要处理自定义软件包。

  5. 在镜像构建完成后,您创建的容器将出现在 quay.io 中。
  6. 访问 quay.io,再点 Repository Tags

     You can see details about the container you created, such as:
    - last modified
    - image size
    - the `manifest ID`, that you can copy to the clipboard.
  7. 复制 清单 ID 值以构建您要嵌入容器的镜像。

其他资源

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

创建容器镜像后,您可以构建自定义镜像并将容器镜像提取到其中。为此,您必须在蓝图中指定 容器自定义,以及最终镜像的 容器名称。在构建过程中,会获取容器镜像,并放置在本地 Podman 容器存储中。

先决条件

  • 您创建了容器镜像并将其推送到本地 quay.io 容器 registry 实例。
  • 您可以访问 registry.access.redhat.com
  • 您有一个容器 清单 ID
  • 已安装 qemu-kvmqemu-img 软件包。要安装它,请运行以下命令:

    # yum install qemu-kvm qemu-img

流程

  1. 创建蓝图来构建 qcow2 镜像。蓝图必须包含 自定义。

    name = "image"
    description = "A qcow2 image with a container"
    version = "0.0.1"
    distro = "rhel-90"
    
    [[packages]]
    name = "podman"
    version = "*"
    
    [[containers]]
    source = "registry.access.redhat.com/ubi9:8080/osbuild/container/container-image@sha256:manifest-ID-from-Repository-tag: tag-version"
    name =  "source-name"
    tls-verify = true
  2. 推送蓝图:

    # composer-cli blueprints push blueprint-image.toml
  3. 构建容器镜像:

    # composer-cli start compose image qcow2

    其中:

    • image 是蓝图名称。
    • qcow2 是镜像类型。

      注意

      构建镜像需要一些时间,因为它将检查 quay.io registry 上的容器。

      镜像构建状态变为 "FINISHED" 后,您可以使用您在虚拟机中创建的 qcow2 镜像。

验证

  1. .qcow2 镜像从 composer-cli 拉取到本地文件系统:

    # composer-cli compose image COMPOSE-UUID
  2. 在虚拟机中启动 qcow2 镜像。请参阅从 KVM 客户机镜像创建虚拟机
  3. qemu 向导将打开。登录到 qcow2 镜像。

    1. 输入用户名和密码。这些可以是您在 "customizations.user" 部分的 .qcow2 蓝图中设置的用户名和密码,或是在引导时使用 cloud-init 创建的。
  4. 运行容器镜像,并在容器内打开 shell 提示符:

    # podman run -it registry.access.redhat.com/ubi9:8080/osbuild/repository /bin/bash/

    其中:

    • registry.access.redhat.com 是目标 registry,osbuild 是机构,repository 则是在完成构建时推送容器的位置。
  5. 检查您添加到蓝图中的软件包是否可用:

    # type -a nginx

    输出显示 nginx 软件包路径。

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

镜像构建器可以创建自定义系统镜像,以便在各种云平台上使用。要在云中使用自定义的 RHEL 系统镜像,请使用镜像构建器使用相应的输出类型创建系统镜像,配置您的系统以上传镜像,并将镜像上传到您的云帐户。您可以在 RHEL web 控制台中通过 image builder 应用程序将自定义镜像推送到云,作为我们支持的服务提供商的子集提供,如 AWSMicrosoft Azure 云。请参阅 将镜像推送到 AWS Cloud AMI将 VHD 镜像推送到 Microsoft Azure 云

10.1. 准备上传 AWS AMI 镜像

在上传 AWS AMI 镜像前,您必须配置系统来上传镜像。

先决条件

流程

  1. 安装 Python 3 和 pip 工具:

    # yum install python3
    # yum install python3-pip
  2. 使用 pip 安装 AWS 命令行工具

    # pip3 install awscli
  3. 运行以下命令设定您的配置集。终端提示您提供凭证、地区和输出格式:

    $ aws configure
    AWS Access Key ID [None]:
    AWS Secret Access Key [None]:
    Default region name [None]:
    Default output format [None]:
  4. 为存储桶定义名称,并使用以下命令创建存储桶:

    $ BUCKET=bucketname
    $ aws s3 mb s3://$BUCKET

    使用实际存储桶名称替换 bucketname。它必须是全局唯一的名称。因此,您的存储桶会被创建。

  5. 要授予访问 S3 存储桶的权限,如果您还没有这样做,请在 AWS Identity and Access Management (IAM) 中创建一个 vmimport S3 角色:

    $ printf '{ "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Service": "vmie.amazonaws.com" }, "Action": "sts:AssumeRole", "Condition": { "StringEquals":{ "sts:Externalid": "vmimport" } } } ] }' > trust-policy.json
    $ printf '{ "Version":"2012-10-17", "Statement":[ { "Effect":"Allow", "Action":[ "s3:GetBucketLocation", "s3:GetObject", "s3:ListBucket" ], "Resource":[ "arn:aws:s3:::%s", "arn:aws:s3:::%s/*" ] }, { "Effect":"Allow", "Action":[ "ec2:ModifySnapshotAttribute", "ec2:CopySnapshot", "ec2:RegisterImage", "ec2:Describe*" ], "Resource":"*" } ] }' $BUCKET $BUCKET > role-policy.json
    $ aws iam create-role --role-name vmimport --assume-role-policy-document file://trust-policy.json
    $ aws iam put-role-policy --role-name vmimport --policy-name vmimport --policy-document file://role-policy.json

10.2. 使用 CLI 将 AMI 镜像上传到 AWS

您可以使用镜像构建器来构建 ami 镜像,并使用 CLI 将其直接推送到 Amazon AWS Cloud 服务供应商。

先决条件

  • 您已在 AWS IAM 账号管理器中配置了一个 Access Key ID
  • 您已准备好了一个可写的 S3 存储桶
  • 您有一个定义的蓝图。

流程

  1. 使用文本编辑器,使用以下内容创建配置文件:

    provider = "aws"
    
    [settings]
    accessKeyID = "AWS_ACCESS_KEY_ID"
    secretAccessKey = "AWS_SECRET_ACCESS_KEY"
    bucket = "AWS_BUCKET"
    region = "AWS_REGION"
    key = "IMAGE_KEY"

    将字段中的值替换为您的 accessKeyIDsecretAccessKeybucketregion 的凭证。IMAGE_KEY 值是要上传到 EC2 的虚拟机镜像的名称。

  2. 将文件保存为 CONFIGURATION-FILE.toml,然后关闭文本编辑器。
  3. 启动 compose:

    # composer-cli compose start BLUEPRINT-NAME IMAGE-TYPE IMAGE_KEY CONFIGURATION-FILE.toml

    替换:

    • BLUEPRINT-NAME 替换为您创建的蓝图名称
    • IMAGE-TYPE 替换为 ami 镜像类型。
    • IMAGE_KEY 替换为要上传到 EC2 的虚拟机镜像的名称。
    • CONFIGURATION-FILE.toml 替换为云供应商的配置文件的名称。

      注意

      对于要将自定义镜像发送到的存储桶,您必须拥有正确的 IAM 设置。在将镜像上传到存储桶前,您必须对存储桶设置策略。

  4. 检查镜像构建的状态,并将其上传到 AWS:

    # composer-cli compose status

    完成镜像上传过程后,您可以看到"FINISHED"状态。

验证

要确认镜像上传成功:

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

10.3. 将镜像推送到 AWS Cloud AMI

您可以将您创建的输出镜像推送到 Amazon AWS Cloud AMI 服务供应商。

先决条件

流程

  1. 蓝图名称
  2. 选择选项卡 Images
  3. Create Image 创建自定义镜像。

    此时会打开弹出窗口。

    1. Type 下拉菜单中选择 Amazon Machine Image Disk (.raw)
    2. 选中 "Upload to AWS" 复选框,将您的镜像上传到 AWS 云,并点击 Next
    3. 要验证您是否可以访问 AWS ,请在对应的字段中输入您的"AWS access key ID""AWS secret access key"。点击 Next

      注意

      您只能在创建新 Access Key ID 时查看 AWS secret access key 。如果您不知道您的 Secret Key,请生成一个新的 Access Key ID。

    4. Image name 字段中输入镜像名称,在 Amazon S3 bucket name 字段中输入 Amazon bucket 名称,并为您要添加自定义镜像的存储桶输入 AWS region 字段。点击 Next
    5. 查看信息并点 Finish

      (可选)您可以点击 Back 来修改任何不正确的详情。

      注意

      您必须具有要发送自定义镜像的存储桶的正确 IAM 设置。此流程使用 IAM 导入和导出,因此您必须在将镜像上传到存储桶前为存储桶设置 策略。如需更多信息,请参阅 IAM 用户所需的权限

  4. 右上角的一个小弹出会通知您保存的进度。它还告知镜像创建过程、创建此镜像的过程以及后续的上传到 AWS Cloud。

    完成这个过程后,您可以看到 镜像构建完成状态。

  5. 点菜单中的 Service→EC2,然后在 AWS 控制台中选择 正确的区域。镜像必须具有 Available 状态,以指示它已被上传。
  6. 在控制面板中,选择您的镜像并点 Launch
  7. 此时会打开一个新窗口。根据启动镜像所需的资源选择实例类型。点 Review and Launch
  8. 查看您的实例启动详情。如果需要进行任何更改,您可以编辑任何部分。点 Launch
  9. 在启动实例之前,选择一个访问它的公钥。

    您可以使用您已有的密钥对,也可以创建一个新的密钥对。

    按照以下步骤在 EC2 中创建新的密钥对,并将它连接到新实例。

    1. 在下拉菜单中选择 "Create a new key pair"
    2. 输入新密钥对名称。它生成一个新的密钥对。
    3. "下载密钥对" 在您的本地系统中保存新密钥对。
  10. 然后,您可以点 Launch Instance 来启动您的实例。

    您可以检查实例的状态,它显示为 Initializing

  11. 实例状态变为 running 后,连接按钮将变为可用。
  12. 连接。此时会出现一个弹出窗口,其中包含有关如何使用 SSH 连接的说明。

    1. 选择 A standalone SSH client 作为首选连接方法并打开终端。
    2. 在您存储私钥的位置,确保您的密钥是公开可见的,以便 SSH 可以正常工作。要做到这一点,请运行以下命令:

      $ chmod 400 <your-instance-name.pem>_
    3. 使用其公共 DNS 连接到您的实例:

      $ ssh -i "<_your-instance-name.pem_"> ec2-user@<_your-instance-IP-address_>
    4. 键入 yes 以确认您要继续连接。

      因此,您使用 SSH 连接到实例。

验证

  1. 检查在使用 SSH 连接到实例后您是否能够执行任何操作。

10.4. 准备上传 Microsoft Azure VHD 镜像

您可以使用镜像构建器准备可上传到 Microsoft Azure 云的 VHD 镜像。

先决条件

  • 您必须具有可用的 Microsoft Azure 资源组和存储帐户。
  • 已安装 python2,因为 AZ CLI 工具依赖于 python 2.7。

流程

  1. 导入 Microsoft 存储库密钥:

    # rpm --import https://packages.microsoft.com/keys/microsoft.asc
  2. 创建本地 azure-cli 存储库信息:

    # sh -c 'echo -e "[azure-cli]\nname=Azure CLI\nbaseurl=https://packages.microsoft.com/yumrepos/azure-cli\nenabled=1\ngpgcheck=1\ngpgkey=https://packages.microsoft.com/keys/microsoft.asc" > /etc/yum.repos.d/azure-cli.repo'
  3. 安装 Microsoft Azure CLI:

    # yumdownloader azure-cli
    # rpm -ivh --nodeps azure-cli-2.0.64-1.el7.x86_64.rpm
    注意

    下载的 Microsoft Azure CLI 软件包版本可能会因当前可用的版本而异。

  4. 运行 Microsoft Azure CLI:

    $ az login

    终端会显示以下信息 Note, we have launched a browser for you to login.For old experience with device code, use "az login --use-device-code.然后,终端会打开浏览器,其中包含可从其登录 https://microsoft.com/devicelogin 的链接。

    注意

    如果您正在运行远程(SSH)会话 ,https://microsoft.com/devicelogin 链接不会在浏览器中打开。在这种情况下,您可以将链接复制到浏览器,并登录以验证您的远程会话。要登录,使用网页浏览器打开页面 https://microsoft.com/devicelogin 并输入要进行身份验证的设备代码。

  5. 列出 Microsoft Azure 中存储帐户的密钥:

    $ GROUP=resource-group-name
    $ ACCOUNT=storage-account-name
    $ az storage account keys list --resource-group $GROUP --account-name $ACCOUNT

    resource-group-name 替换为 Microsoft Azure 资源组的名称,将 storage-account-name 替换为 Microsoft Azure 存储帐户的名称。

    注意

    您可以使用以下命令列出可用资源:

    $ az resource list
  6. 记录上一个命令输出中的 key1 值,并将其分配给环境变量:

    $ KEY1=value
  7. 创建存储容器:

    $ CONTAINER=storage-account-name
    $ az storage container create --account-name $ACCOUNT \
    --account-key $KEY1 --name $CONTAINER

    storage-account-name 替换为存储帐户的名称。

10.5. 将 VHD 镜像上传到 Microsoft Azure 云

创建了自定义 VHD 镜像后,您可以将其上传到 Microsoft Azure 云。

先决条件

  • 必须设置您的系统以上传 Microsoft Azure VHD 镜像。请参阅 准备上传 Microsoft Azure VHD 镜像
  • 您必须有镜像构建器创建的 Microsoft Azure VHD 镜像。

    • 在 CLI 中,使用 vhd 输出类型。
    • 在 GUI 中,使用 Azure Disk Image (.vhd) 镜像类型。

      流程

      1. 将镜像推送到 Microsoft Azure 并从中创建一个实例:

        $ VHD=25ccb8dd-3872-477f-9e3d-c2970cd4bbaf-disk.vhd
        $ az storage blob upload --account-name $ACCOUNT --container-name $CONTAINER --file $VHD --name $VHD --type page
        ...
      2. 上传到 Microsoft Azure Blob 存储后,从其创建一个 Microsoft Azure 镜像:

        $ az image create --resource-group $GROUP --name $VHD --os-type linux --location eastus --source https://$ACCOUNT.blob.core.windows.net/$CONTAINER/$VHD
         - Running ...

验证

  1. 使用 Microsoft Azure 门户创建实例,或者使用以下命令:

    $ az vm create --resource-group $GROUP --location eastus --name $VHD --image $VHD --admin-username azure-user --generate-ssh-keys
     - Running ...
  2. 通过 SSH 使用您的私钥访问生成的实例。以 azure-user 用户身份登录。

10.6. 将 VHD 镜像推送到 Microsoft Azure 云

您可以使用镜像构建器创建 .vhd 镜像。然后,您可以将输出 .vhd 镜像推送到 Microsoft Azure Cloud 服务供应商的 Blob 存储。

先决条件

流程

  1. 在镜像构建器仪表盘中,选择要使用的蓝图。
  2. Images 选项卡。
  3. Create Image 创建自定义 .vhd 镜像。

    Create image 向导将打开。

    1. Type 下拉菜单中选择 Microsoft Azure (.vhd)
    2. 选中 Upload to Azure 复选框,将您的镜像上传到 Microsoft Azure Cloud。
    3. 输入 Image Size 并点 Next
  4. Upload to Azure 页面中,输入以下信息:

    1. 在 Authentication 页面中,输入:

      1. 您的 存储帐户 名称。您可以在 Storage account 页面的 Microsoft Azure 门户中 找到它。
      2. 您的存储访问密钥 :您可以在 Access Key Storage 页面中找到它。
      3. 点击 Next
    2. Authentication 页面中,输入:

      1. 镜像名称。
      2. 存储容器.它是您将上传到的 blob 容器。在 Microsoft Azure 门户Blob 服务 部分中找到它。
      3. 点击 Next
  5. Review 页面上,点 Create。镜像构建和上传过程开始。

后续步骤

  1. 要访问推送到 Microsoft Azure Cloud 的镜像,请访问 Microsoft Azure 门户
  2. 在搜索栏中,键入"storage account",然后从列表中单击 Storage accounts
  3. 在搜索栏中,键入"Images",然后在 服务 下选择第一个条目。您将被重定向到 镜像仪表盘
  4. 在导航面板中,单击 Containers
  5. 查找您创建的容器。在容器内,是您创建和推送的 your_image_name.vhd 文件。

验证

验证您能否创建虚拟机镜像并启动它。

  1. 在搜索栏中,输入 images 帐户,再单击列表中的 Images
  2. 单击 +Create
  3. 从下拉列表中,选择您之前使用的资源组。
  4. 输入镜像的名称。
  5. 对于 操作系统类型,请选择 Linux
  6. 对于虚拟机 生成,请选择 Gen 2
  7. Storage Blob 下,点 Browse 并点 storage account 和 container,直到您到达 VHD 文件。
  8. 点页面末尾的 Select
  9. 选择一个帐户类型,例如 Standard SSD
  10. Review + Create,然后点 Create。等待几分钟,以便创建镜像。

要启动虚拟机,请按照以下步骤执行:

  1. Go to resource
  2. 从标题的菜单栏中,单击 + Create VM
  3. 输入虚拟机的名称。
  4. 完成 SizeAdministrator 帐户 部分。
  5. Review + Create,然后点 Create。您可以查看部署进度。

    部署完成后,单击虚拟机名称,以检索使用 SSH 连接的实例的公共 IP 地址。

  6. 打开一个终端,以创建与虚拟机的 SSH 连接。

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

使用 govc import.vmdk CLI 工具将 .vmdk 镜像上传到 VMware vSphere。

注意

不支持通过 UI 上传镜像。

先决条件

  • 您已使用用户名和密码自定义创建了一个蓝图。
  • 您使用镜像构建器创建了一个 .vmdk 镜像,并将其下载到主机系统。
  • 您已安装 govc import.vmdk CLI 工具。
  • 您已配置了 govc import.vmdk CLI 工具客户端。

    • 您必须在环境中设置以下值:

      GOVC_URL
      GOVC_DATACENTER
      GOVC_FOLDER
      GOVC_DATASTORE
      GOVC_RESOURCE_POOL
      GOVC_NETWORK

流程

  1. 导航到您下载 .vmdk 镜像的目录。
  2. 按照以下步骤在 vSphere 上启动镜像:

    1. .vmdk 镜像导入到 vSphere :

      $ govc import.vmdk ./composer-api.vmdk foldername
    2. 在 VSphere 中创建虚拟机而不开机:

      govc vm.create \
      -net.adapter=vmxnet3 \
      -m=4096 -c=2 -g=rhel8_64Guest \
      -firmware=efi -disk=”foldername/composer-api.vmdk” \
      -disk.controller=scsi -on=false \
       vmname
    3. 打开虚拟机:

      govc vm.power -on vmname
    4. 检索虚拟机 IP 地址:

      HOST=$(govc vm.ip vmname)
    5. 使用您在蓝图中指定的用户名和密码,使用 SSH 登录到虚拟机:

      $ ssh admin@HOST
      注意

      如果您使用 govc datastore.upload 命令将 .vmdk 镜像从本地主机复制到目的地,则不支持使用该镜像。在 vSphere GUI 中没有选项来使用 import.vmdk 命令,因此 vSphere GUI 不支持直接上传,因此 .vmdk 镜像无法直接从 vSphere GUI 使用。

10.8. 使用镜像构建器将镜像上传到 GCP

使用镜像构建器,您可以构建 gce 镜像,为用户或 GCP 服务帐户提供凭证,然后将 gce 镜像直接上传到 GCP 环境。

10.8.1. 使用 CLI 将 gce 镜像上传到 GCP

按照以下步骤使用凭证设置配置文件,将 gce 镜像上传到 GCP。

先决条件

  • 有用户或服务帐户 Google 凭证,以便将镜像上传到 GCP。与凭证关联的帐户必须至少分配以下 IAM 角色:

    • roles/storage.admin - 用于创建和删除存储对象
    • roles/compute.storageAdmin - 将虚拟机镜像导入到 Compute Engine。
  • 您有一个现有的 GCP 存储桶。

流程

  1. 使用文本编辑器,创建包含以下内容的 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 是中间存储对象的名称。它在上传过程前不能存在,并在上传过程完成后被删除。如果对象名称不以 .tar.gz 结尾,则扩展会自动添加到对象名称中。
    • GCP_CREDENTIALS 是一个从 GCP 下载的凭证 JSON 文件的 Base64 编码方案。凭证决定了 GCP 将镜像上传到的项目。

      注意

      如果您使用不同的 GCP 机制与 GCP 进行身份验证,在 gcp-config.toml 中指定 GCP_CREDENTIALS 是可选的。如需有关使用 GCP 验证的不同方法的更多详情,请参阅使用 GCP 进行身份验证

  2. 使用附加镜像名称和云供应商配置集创建 compose:

    $ sudo composer-cli compose start BLUEPRINT-NAME gce IMAGE_KEY gcp-config.toml

    备注:镜像构建、上传和云注册过程最多可能需要十分钟才能完成。

验证

  • 验证镜像状态为 FINISHED:

    $ sudo composer-cli compose status

10.8.2. 使用 GCP 进行身份验证

您可以在镜像构建器中使用几种不同类型的凭证来使用 GCP 进行身份验证。如果将镜像构建器配置被设置为使用多个凭证通过 GCP 进行身份验证,它会按以下首选顺序使用凭证:

  1. 在配置文件中,使用 composer-cli 命令指定的凭证。
  2. 凭证在 osbuild-composer worker 配置中被配置。
  3. Google GCP SDK 库中的应用程序默认凭证,它尝试使用以下选项自动找到身份验证的方法:

    1. 如果设置了 GOOGLE_APPLICATION_CREDENTIALS 环境变量,应用程序默认凭据会尝试加载并从文件中使用由变量指向的凭证。
    2. 应用默认凭据尝试使用附加到运行代码的资源的服务帐户进行身份验证。例如,Google Compute Engine 虚拟机。

      注意

      您必须使用 GCP 凭证来决定将镜像上传到的 GCP 项目。因此,除非要将所有镜像上传到同一 GCP 项目,您必须使用 composer-cli 命令指定 gcp-config.toml 配置文件中的凭证。

10.8.2.1. 使用 composer-cli 命令指定凭证

您可以在提供的上传目标配置 gcp-config.toml 中指定 GCP 验证凭证。使用 Google 帐户凭证 JSON 文件的 Base64 编码方案来节省时间。

流程

  • 在提供的上传目标配置 gcp-config.toml 中,设置凭证:

    provider = "gcp"
    
    [settings]
    provider = "gcp"
    
    [settings]
    ...
    credentials = "GCP_CREDENTIALS"
  • 要获得 Google 帐户凭证文件的编码内容,且路径保存在 GOOGLE_APPLICATION_CREDENTIALS 环境变量中,请运行以下命令:

    $ base64 -w 0 "${GOOGLE_APPLICATION_CREDENTIALS}"

10.8.2.2. 在 osbuild-composer worker 配置中指定凭证

您可以将 GCP 身份验证凭据配置为全局用于 GCP 用于所有镜像构建。这样,如果您想要将镜像导入到同一 GCP 项目,则所有镜像都可以使用相同的凭证来上传到 GCP。

流程

  • /etc/osbuild-worker/osbuild-worker.toml worker 配置中,设置以下凭证值:

    [gcp]
    credentials = "PATH_TO_GCP_ACCOUNT_CREDENTIALS"

10.9. 使用 GUI 镜像构建器工具将 VMDK 镜像推送到 vSphere

您可以使用 GUI 镜像构建器工具构建 VMware 镜像,并将镜像直接推送到 vSphere 实例,以避免下载镜像文件并手动推送它。要使用镜像构建器直接为 vSphere 实例服务提供商创建 .vmdk 镜像,请按照以下步骤执行:

先决条件

流程

  1. 对于您创建的蓝图,点 Images 选项卡。
  2. Create Image 创建自定义镜像。

    此时将打开镜像类型窗口。

  3. Image type 窗口中:

    1. 从下拉菜单中,选择 Type: VMware VSphere (.vmdk)。
    2. 选中 Upload to VMware 复选框,来将镜像上传到 vSphere。
    3. 可选:设置您要实例化的镜像的大小。最小的默认大小为 2GB。
    4. 点击 Next
  4. Upload to VMware 窗口中,在 Authentication 下输入以下详情:

    1. 用户名 :vSphere 帐户的用户名。
    2. Password :vSphere 帐户的密码。
  5. Upload to VMware 窗口中,在 Destination 下输入以下详情:

    1. Image name:要上传的镜像的名称。
    2. Host :镜像将要上传到的 VMware vSphere 的 URL。
    3. Cluster :镜像将要上传到的集群的名称。
    4. Data center :镜像将要上传到的数据中心的名称。
    5. Data store :镜像将要上传到的数据存储的名称。
    6. Next
  6. Review 窗口中,查看镜像创建的详情并点 Finish

    您可以点击 Back 来修改任何不正确的详情。

    镜像构建器将 RHEL vSphere 镜像的组成添加到队列中,创建镜像并将其上传到您指定的 vSphere 实例的集群上。

    注意

    镜像构建和上传过程需要几分钟时间才能完成。

    完成这个过程后,您可以看到 镜像构建完成状态。

验证

成功完成镜像上传后,您可以从上传的镜像创建虚拟机(VM),并登录到虚拟机。要做到这一点:

  1. 访问 VMware vSphere 客户端。
  2. 在您指定的 vSphere 实例上的集群中搜索镜像。
  3. 您可以从上传的镜像创建一个新虚拟机:

    1. 选择您上传的镜像。
    2. 右键点所选镜像。
    3. New Virtual Machine

      此时 New Virtual Machine 窗口打开。

      New Virtual Machine 窗口中提供了以下详情:

      1. 选择 New Virtual Machine
      2. 为您的虚拟机选择一个名称和文件夹。
      3. 选择计算资源:为此操作选择一个目标计算资源。
      4. 选择存储: 例如,选择 NFS-Node1
      5. 选择兼容性:镜像应仅限于 BIOS。
      6. 选择一个客户机操作系统:例如,选择 LinuxRed Hat Fedora (64 位)。
      7. 自定义硬件 :创建虚拟机时,在右上角的 Device Configuration按钮,删除默认的 New Hard Disk,并使用下拉菜单来选择 Existing Hard Disk 磁盘镜像:
      8. 准备完成:查看详情并点击 Finish 来创建镜像。
    4. 导航至 VMs 选项卡。

      1. 从列表中选择您创建的虚拟机。
      2. 单击面板上的 Start 按钮。此时会显示一个新窗口,显示正在加载 VM 镜像。
      3. 使用您为蓝图创建的凭证登录。
      4. 您可以验证添加到蓝图中的软件包是否已安装。例如:

        $ rpm -qa | grep firefox

其他资源

10.10. 将 QCOW2 镜像上传到 OpenStack

使用镜像构建器工具,您可以创建适合上传到 OpenStack 云部署的自定义 .qcow2 镜像,并在那里启动实例。

警告

不要将您使用镜像构建器创建的通用 QCOW2 命令类型输出格式与 OpenStack 镜像类型的相混淆,后者虽然也是 QCOW2 格式,但包含了针对 OpenStack 的进一步更改。

先决条件

  • 您已创建了蓝图。
  • 使用镜像构建器创建一个 QCOW2 镜像。查看

流程

  1. 启动 QCOW2 镜像的 compose。

    # composer-cli compose start blueprint_name openstack
  2. 检查构建的状态。

    # composer-cli compose status

    镜像构建完成后,您可以下载镜像。

  3. 下载 QCOW2 镜像:

    # composer-cli compose image UUID
  4. 访问 OpenStack 仪表板,再单击 +Create Image
  5. 在左侧菜单中,选择 Admin 选项卡。

    1. 系统面板中,点镜像

      Create An Image 向导将打开。

  6. Create An Image 向导中:

    1. 输入镜像的名称
    2. Browse,上传 QCOW2 镜像。
    3. 格式 下拉列表中,选择 QCOW2 - QEMU Emulator
    4. Create Image

      composer openstack upload image

  7. 在左侧菜单中,选择 Project 选项卡。

    1. Compute 菜单中,选择 Instances
    2. 启动实例按钮。

      此时会打开 Launch Instance 向导。

    3. Details 页面中,输入实例的名称。点击 Next
    4. Source 页面中,选择您上传的镜像的名称。点击 Next
    5. Flavor 页面中,选择最适合您的需要的机器资源。点 Launch

      composer openstack start instance

  8. 您可以使用任何机制(CLI 或 OpenStack Web UI)来从镜像运行镜像实例。通过 SSH 使用您的私钥访问生成的实例。以 cloud-user 用户身份登录。

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

要将自定义 RHEL 镜像部署到 Alibaba Cloud,首先需要验证自定义镜像。镜像需要特定的配置才能成功引导,因为 Alibaba Cloud 在使用前需要自定义镜像来满足某些要求。

注意

镜像构建器生成符合 Alibaba 要求的镜像。但是,红帽建议使用 Alibaba image_check 工具来验证镜像的格式合规性。

先决条件

  • 您必须使用镜像构建器创建 Alibaba 镜像。

流程

  1. 使用 Alibaba image_check 工具连接到含您要检查的镜像的系统。
  2. 下载 image_check 工具

    $ curl -O http://docs-aliyun.cn-hangzhou.oss.aliyun-inc.com/assets/attach/73848/cn_zh/1557459863884/image_check
  3. 更改镜像合规工具的文件权限:

    # chmod +x image_check
  4. 运行命令启动镜像合规工具检查:

    # ./image_check

    该工具会验证系统配置,并生成在屏幕上显示的报告。image_check 工具会在运行镜像合规工具的同一目录中保存此报告。

故障排除

如果任何检测项失败,请按照终端中的说明进行更正。请参阅链接:Detection items 部分。

其他资源

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

您可以使用镜像构建器将您创建的自定义 AMI 镜像上传到对象存储服务 (OSS)。

先决条件

流程

  1. 登录到 OSS 控制台
  2. 在左侧的 Bucket 菜单中,选择要向其上传镜像的存储桶。
  3. 在右菜单中点 Files 标签页。
  4. Upload。一个对话框窗口会在右侧打开。配置以下内容:

    • Upload To:选择将文件上传到 Current 目录或一个指定的目录。
    • 文件 ACL:选择上传的文件的权限类型。
  5. Upload
  6. 选择您要上传的镜像。
  7. 点击 Open

因此,自定义的 AMI 镜像会上传到 OSS 控制台。

10.13. 将镜像导入到 Alibaba

要将使用镜像构建器创建的自定义 Alibaba RHEL 镜像导入到 Elastic Cloud Console (ECS),请按照以下步骤执行:

先决条件

流程

  1. 登录到 ECS 控制台。

    1. 在左侧菜单中,点 Images
    2. 在右上角,点 Import Image。此时会打开一个对话框窗口。
    3. 确认您已设置了镜像所在的正确区域。输入以下信息:

      1. OSS 对象地址 :了解如何获取 OSS 对象地址
      2. 镜像名称
      3. 操作系统
      4. 系统磁盘大小
      5. 系统架构
      6. Platform: Red Hat
    4. 另外,还可提供以下详情:

      1. 镜像格式:qcow2ami,具体取决于上传的镜像格式。
      2. 镜像描述
      3. 添加数据磁盘的镜像

        地址可以在 OSS 管理控制台中确定。在左侧菜单中选择所需的存储桶之后:

  2. 选择 Files 部分。
  3. 点相应镜像右侧的 Details 链接。

    窗口会出现在屏幕右侧,显示镜像详情。OSS 对象地址位于 URL 框中。

  4. 点击 OK

    注意

    导入过程的时间可能因镜像大小而异。

自定义镜像导入到 ECS 控制台。

10.14. 使用 Alibaba 创建自定义 RHEL 镜像实例

您可以使用 Alibaba ECS 控制台 创建自定义 RHEL 镜像的实例。

先决条件

流程

  1. 登录到 ECS 控制台。
  2. 在左侧菜单中,选择 Instances
  3. 在右上角,点 Create Instance。您会被重新定向到新窗口。
  4. 完成所有必需的信息。如需了解更多详细信息,请参阅使用向导创建实例
  5. Create Instance 并确认顺序。

    注意

    根据订阅,您可以看到 Create Order 选项,而不是 Create Instance 选项。

因此,您有一个活跃的实例准备好从 Alibaba ECS 控制台进行部署

法律通告

Copyright © 2023 Red Hat, Inc.
The text of and illustrations in this document are licensed by Red Hat under a Creative Commons Attribution–Share Alike 3.0 Unported license ("CC-BY-SA"). An explanation of CC-BY-SA is available at http://creativecommons.org/licenses/by-sa/3.0/. In accordance with CC-BY-SA, if you distribute this document or an adaptation of it, you must provide the URL for the original version.
Red Hat, as the licensor of this document, waives the right to enforce, and agrees not to assert, Section 4d of CC-BY-SA to the fullest extent permitted by applicable law.
Red Hat, Red Hat Enterprise Linux, the Shadowman logo, the Red Hat logo, JBoss, OpenShift, Fedora, the Infinity logo, and RHCE are trademarks of Red Hat, Inc., registered in the United States and other countries.
Linux® is the registered trademark of Linus Torvalds in the United States and other countries.
Java® is a registered trademark of Oracle and/or its affiliates.
XFS® is a trademark of Silicon Graphics International Corp. or its subsidiaries in the United States and/or other countries.
MySQL® is a registered trademark of MySQL AB in the United States, the European Union and other countries.
Node.js® is an official trademark of Joyent. Red Hat is not formally related to or endorsed by the official Joyent Node.js open source or commercial project.
The OpenStack® Word Mark and OpenStack logo are either registered trademarks/service marks or trademarks/service marks of the OpenStack Foundation, in the United States and other countries and are used with the OpenStack Foundation's permission. We are not affiliated with, endorsed or sponsored by the OpenStack Foundation, or the OpenStack community.
All other trademarks are the property of their respective owners.