Red Hat Training
A Red Hat training course is available for RHEL 8
创建自定义 RHEL 系统镜像
在 Red Hat Enterprise Linux 8 上使用镜像构建器创建自定义系统镜像
摘要
使开源包含更多
红帽承诺替换我们的代码、文档和网页属性中存在问题的语言。我们从这四个术语开始:master、slave、黑名单和白名单。由于此项工作十分艰巨,这些更改将在即将推出的几个发行版本中逐步实施。详情请查看 CTO Chris Wright 的信息。
对红帽文档提供反馈
我们感谢您对我们文档的反馈。让我们了解如何改进它。
根据具体内容提交评论
- 查看 Multi-page HTML 格式的文档,并确保在页面完全加载后看到右上角的 Feedback 按钮。
- 使用光标突出显示您要评论的文本部分。
- 点在高亮文本旁的 Add Feedback 按钮。
- 添加您的反馈并点 Submit。
通过 JIRA 提交反馈(需要帐户)
- 登录到 JIRA 网站。
- 在顶部导航栏中点 Create
- 在 Summary 字段中输入描述性标题。
- 在 Description 字段中输入您对改进的建议。包括文档相关部分的链接。
- 点对话框底部的 Create。
第 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 镜像 |
|
|
TAR 归档 |
|
|
Amazon 机器镜像磁盘 |
|
|
Azure 磁盘镜像 |
|
|
Google Cloud Platform |
|
|
VMware 虚拟机磁盘 |
|
|
Openstack |
|
|
用于边缘提交的 RHEL |
|
|
用于边缘容器的 RHEL |
|
|
用于边缘安装程序的 RHEL |
|
|
用于 Edge Raw 的 RHEL |
|
|
用于边缘简化安装程序的 RHEL |
|
|
ISO 镜像 |
|
|
1.4. 镜像构建器系统要求
镜像构建器运行的环境(如专用的虚拟机)必须满足下表中列出的要求。
表 1.2. 镜像构建器系统要求
参数 | 最低要求值 |
---|---|
系统类型 | 专用的虚拟机。请注意,镜像构建器在容器上不支持,包括 Red Hat Universal Base Images (UBI)。 |
处理器 | 2 个内核 |
内存 | 4 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。
-
您已启用了
BaseOS
和AppStream
软件仓库,以便能安装 RHEL 镜像构建器软件包。
流程
在虚拟机上安装镜像构建程序和其他必要的软件包:
-
osbuild-composer
- 从 RHEL 8.3 开始支持 -
composer-cli
-
cockpit-composer
-
bash-completion
# yum install osbuild-composer composer-cli cockpit-composer bash-completion
Web 控制台作为 cockpit-composer 软件包的依赖项安装。
-
在每次重启后启动镜像构建器:
# systemctl enable --now osbuild-composer.socket # systemctl enable --now cockpit.socket
osbuild-composer
和cockpit
服务在第一次访问时自动启动。载入 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。
验证
您可以使用系统日志来跟踪 RHEL 镜像构建器活动。此外,您还可以在文件中找到日志消息。
要查找回溯的日志输出,请运行以下命令:
$ journalctl | grep osbuild
显示远程或本地 worker:
$ journalctl -u osbuild-worker*
显示运行的服务:
$ journalctl -u osbuild-composer.service
2.2. 恢复到 lorax-composer
镜像构建程序后端
osbuild-composer
后端虽然具有更大的可扩展性,但目前还无法与之前的 lorax-composer
后端功能相媲美。
要回到以前的后端,请按照以下步骤操作:
先决条件
-
osbuild-composer
软件包已安装
流程
删除 osbuild-composer 后端。
# yum remove osbuild-composer # yum remove weldr-client
在
/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
安装
lorax-composer
软件包。# yum install lorax-composer composer-cli
启用并启动
lorax-composer
服务,以便在每次重启后启动。# systemctl enable --now lorax-composer.socket # systemctl start lorax-composer
其他资源
第 3 章 管理镜像构建器存储库
您可以在镜像构建器中使用以下类型的存储库:
- 自定义第三方存储库
- 使用这些存储库来包括官方 RHEL 软件仓库中没有的软件包。
- 官方存储库覆盖
- 如果要从官方存储库以外的其他位置下载基本系统 RPM,如网络中的自定义镜像,请使用它们。由于使用官方存储库覆盖会禁用默认存储库,所以您的自定义镜像必须包含所有必要的软件包。
3.1. 添加自定义第三方存储库
您可以将自定义第三方源添加到存储库中,并使用 composer-cli
管理这些存储库。
先决条件
- 您有自定义第三方存储库的 URL。
流程
创建存储库源文件:
id = "repository_id" name = "repository_name" type = "repository_type" url = "repository-url" check_gpg = false check_ssl = false
例如:
id = "k8s" name = "Kubernetes" type = "yum-baseurl" url = "https://packages.cloud.google.com/yum/repos/kubernetes-el7-x86_64" check_gpg = false check_ssl = false system = false
- 以 TOML 格式保存文件。
使用以下命令添加新的第三方源:
$ composer-cli sources add <file-name>.toml
验证
检查新源是否已成功添加:
$ composer-cli sources list
检查新源内容:
$ composer-cli sources info <source_id>
3.2. 使用特定发行版本添加第三方存储库
您可以使用可选字段 distro
在自定义第三方源文件中指定发行版列表。在镜像构建期间解析依赖项时,存储库文件使用分发字符串列表。
指定 rhel-8
的任何请求都将使用此源。例如,如果您列出了软件包,并指定了 rhel-8
,它将包含此源。但是,列出主机分发的软件包将不包括此源。
流程
创建存储库源文件:
check_gpg = true check_ssl = true distros = ["list_of_distributions"] id = "repository_id" name = "repository-name" system = false type = ""repository_type" url = "repository-url"
例如,要指定发行版:
check_gpg = true check_ssl = true distros = ["rhel-8"] id = "rh9-local" name = "packages for RHEL" system = false type = "yum-baseurl" url = "http://local/repos/rhel8/projectrepo/"
- 以 TOML 格式保存文件。
3.3. 使用 GPG 检查存储库元数据
要检测和避免损坏的软件包,您可以使用 DNF 软件包管理器检查 RPM 软件包上的 GNU Privacy Guard (GPG)签名,并检查存储库元数据是否已使用 GPG 密钥进行了签名。
为安全起见,您可以通过 https
提供 GPG 密钥,从而在与 RPM 分开的渠道中分发密钥。您可以通过在源中设置 check_repogpg = true
来指示要使用哪个 GPG 密钥来做检查。如果密钥可以通过 https
提供,请将 gpgkeys
条目设置为密钥的 URL。另外,您还可以将整个密钥嵌入到源 gpgkeys
条目中,以直接导入它,而不是从 URL 获取它。
流程
访问您要创建存储库的文件夹:
$ cd repo/
运行
createrepo_c
来从 RPM 软件包创建存储库:$ createrepo_c .
访问 repodata 所在的目录:
$ cd repodata/
通过签名
repomd.xml
文件来设置存储库:$ gpg -u YOUR-GPG-KEY-EMAIL --yes --detach-sign --armor repomd.xml
检查 GPG 签名。
-
在存储库源中设置
check_repogpg = true
。 如果您的密钥可以通过
https
提供,请使用密钥的密钥 URL 设置gpgkeys
字段。您可以根据需要添加任意数量的 URL 密钥。以下是一个示例:check_gpg = true check_ssl = true id = "repository_id" name = "repository_name" system = false type = "repository_type" url = "repository_URL" check_repogpg = true gpgkeys=["_GPG_key_URL"]
可选:您可以将整个密钥嵌入到
gpgkeys
字段中。您可以根据需要添加任意数量的密钥。例如,直接在gpgkeys
字段中添加 GPG 密钥:check_gpg = true check_ssl = true check_repogpg id = "repository_id" name = "repository_name" system = false type = "repository_type" url = "repository_URL" gpgkeys=["GPG_key"]
-
在存储库源中设置
验证
手动测试存储库的签名:
$ gpg --verify repomd.xml.asc
如果测试找不到签名,系统会提示您类似如下的错误:
$ GPG verification is enabled, but GPG signature is not available. This may be an error or the repository does not support GPG verification: Status code: 404 for http://repo-server/rhel/repodata/repomd.xml.asc (IP: 192.168.1.3)
如果签名无效,系统会提示您类似如下的错误:
repomd.xml GPG signature verification error: Bad GPG signature
3.4. 镜像构建器默认系统存储库
osbuild-composer
后端不会继承位于 /etc/yum.repos.d/
目录中的系统存储库。相反,它拥有自己的一组在 /usr/share/osbuild-composer/repositories
目录中定义的官方存储库。这包括红帽官方存储库,其中包含要安装附加软件或将已安装的程序基础更新到新版本的基础系统 RPM。如果要覆盖官方存储库,您必须在 /etc/osbuild-composer/repositories
中定义覆盖。这个目录用于用户定义的覆盖,其中的文件优先于 /usr
目录中的文件。
配置文件不是 /etc/yum.repos.d/
中常见的 YUM 存储库格式。相反,它们是简单的 JSON 文件。
3.5. 覆盖系统存储库
您可以按照以下步骤在 /etc/osbuild-composer/repositories
目录中为镜像构建器配置存储库覆盖。
在 RHEL 8.5 发行版本中,仓库覆盖的名称为 rhel-8.json
。从 RHEL 8.5 开始,名称也会尊重次要版本: rhel-84.json
、rhel-85.json
等等。
先决条件
- 您有一个可从主机系统访问的自定义存储库
流程
创建一个要存储存储库覆盖的目录:
$ sudo mkdir -p /etc/osbuild-composer/repositories
- 您可以创建自己的 JSON 文件结构。
使用与 RHEL 版本对应的名称,创建一个 JSON 文件。或者,您还可以从
/usr/share/osbuild-composer/
中复制用于分发的文件,并修改其内容。对于 RHEL 8,请使用
/etc/osbuild-composer/repositories/rhel-88.json
。向 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剩余的字段是可选的。
或者,您也可以复制 JSON 文件以用于您的分发。
将存储库文件复制到您创建的目录中。在以下命令中,将
rhel-version.json
替换为您的 RHEL 版本,例如:rhel-8.json。$ cp /usr/share/osbuild-composer/repositories/rhel-version.json /etc/osbuild-composer/repositories/
-
使用文本编辑器,编辑
rhel-8.json
文件中的baseurl
路径,并保存。例如:$ vi /etc/osbuild-composer/repositories/rhel-version.json
重启
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.6. 覆盖支持订阅的系统存储库
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
中定义的订阅 - 您已创建了一个存储库覆盖。请参阅 覆盖系统存储库。
流程
从
/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
配置存储库覆盖以使用相同的
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
命令。
命令行界面的工作流总结如下:
- 将蓝图定义导出(保存)到纯文本文件
- 在文本编辑器中编辑这个文件
- 将蓝图文本文件导回到(push)镜像构建器
- 运行 compose 来从蓝图构建镜像
- 导出镜像文件以下载它
除了实现此过程的基本子命令外,composer-cli
命令还提供多个子命令来检查配置的蓝图和组合的状态。
要以非 root 身份运行 composer-cli
命令,用户必须在 weldr
或 root
组中。
要在
weldr
或root
组中添加用户,请运行以下命令:$ sudo usermod -a -G weldr user $ newgrp weldr
4.2. 使用命令行界面创建镜像构建器蓝图
您可以使用命令行界面 (CLI) 创建新的镜像构建器蓝图。蓝图描述了最终的镜像及其自定义,如软件包和内核自定义。
前提条件
- 访问镜像构建器工具。
流程
创建一个包含以下内容的纯文本文件:
name = "BLUEPRINT-NAME" description = "LONG FORM DESCRIPTION TEXT" version = "0.0.1" modules = [] groups = []
用您的蓝图的名称和描述替换 BLUEPRINT-NAME 和 LONG FORM DESCRIPTION TEXT。
根据 Semantic Versioning 方案,将 0.0.1 替换为一个版本号。
对于您要包含在蓝图中的每个软件包,请在文件中添加以下行:
[[packages]] name = "package-name" version = "package-version"
使用软件包名称替换 package-name,比如 httpd、gdb-doc 或者 coreutils。
将 package-version 替换为要使用的版本。此字段支持
dnf
版本规范:- 对于特定版本,请使用确切的版本号,如 8.7.0。
- 对于最新可用版本,请使用星号 *。
- 对于最新的次版本,请使用以下格式,如 8.*。
自定义蓝图以满足您的需要。例如,禁用 Simultaneous Multi Threading (SMT),在蓝图文件中添加以下行:
[customizations.kernel] append = "nosmt=force"
有关其他可用的定制信息,请参阅 支持的镜像自定义。
- 将文件保存为 例如 BLUEPRINT-NAME.toml,并关闭文本编辑器。
推送(导入)蓝图:
# composer-cli blueprints push BLUEPRINT-NAME.toml
将 BLUEPRINT-NAME 替换为您在前面步骤中使用的值。
注意以非 root 身份运行
composer-cli
命令创建镜像,请将您的用户添加到weldr
或root
组中。# 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)界面中编辑现有的镜像构建器蓝图,例如添加新软件包或定义一个新组,以创建自定义镜像。为此,请按照以下步骤操作:
先决条件
- 您已创建了蓝图。
流程
将蓝图保存(导出)到本地文本文件:
# composer-cli blueprints save BLUEPRINT-NAME
- 使用文本编辑器编辑 BLUEPRINT-NAME.toml 文件并进行更改。
在完成编辑前,请验证该文件是否是一个有效的蓝图:
如果存在,删除此行:
packages = []
- 增加版本号,如从 0.0.1 增加到 0.1.0。请记住,镜像构建器蓝图版本必须使用 Semantic Versioning 方案。请注意,如果您没有更改版本,补丁版本组件会自动增加。
检查内容是否是有效的 TOML 规格。如需更多信息,请参阅 TOML 文档。
注意TOML 文档是一款社区产品,红帽不支持。您可以使用该工具报告任何问题: https://github.com/toml-lang/toml/issues
- 保存文件并关闭文本编辑器。
将蓝图推送(导入)回镜像构建器:
# composer-cli blueprints push BLUEPRINT-NAME.toml
注意要将蓝图导回到镜像构建器,请提供包括
.toml
扩展名的文件名,而其他命令则只使用蓝图名称。要验证上传到镜像构建器的内容是否与您编辑的匹配,请列出蓝图的内容:
# composer-cli blueprints show BLUEPRINT-NAME
检查蓝图中列出的组件和版本是否有效:
# composer-cli blueprints depsolve BLUEPRINT-NAME
其他资源
4.4. 在命令行界面中使用镜像构建器创建系统镜像
您可以使用镜像构建器命令行界面构建自定义镜像。
先决条件
- 您已为镜像准备了蓝图。请参阅使用命令行界面创建镜像构建器蓝图。
流程
启动 compose:
# composer-cli compose start BLUEPRINT-NAME IMAGE-TYPE
将 BLUEPRINT-NAME 替换为蓝图的名称,将 IMAGE-TYPE 替换为镜像的类型。有关可用值,请查看
composer-cli compose types
命令的输出。compose 进程在后台启动,并显示 composer Universally Unique Identifier (UUID)。
等待 compose 过程完成。镜像创建最多可能需要十分钟才能完成。
检查 Compose 的状态:
# composer-cli compose status
完成的 compose 显示 FINISHED 状态值。要识别列表中您的 compose,请使用其 UUID。
完成 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-NAME 和 LONG FORM DESCRIPTION TEXT 字段是您的蓝图的名称和描述。
VERSION 是 Semantic Versioning 方案的版本号。
这部分只针对整个蓝图文件显示一次。
modules 条目列出了要安装到镜像中的软件包名称和版本。
group 条目描述要安装到镜像中的一组软件包。组使用以下软件包类别:
- Mandatory(必需)
- Default(默认)
选填
蓝图安装必需的和默认的软件包。没有选择可选软件包的机制。
- 镜像中包含的组
[[groups]] name = "group-name"
group-name 是组的名称,例如 anaconda-tools, widget, wheel 或 users。
- 镜像中包含的软件包
[[packages]] name = "package-name" version = "package-version"
package-name 是软件包的名称,如 httpd、gdb-doc 或 coreutils。
package-version 是要使用的版本。此字段支持
dnf
版本规范:- 对于特定版本,请使用确切的版本号,如 8.7.0。
- 对于最新的可用版本,请使用星号 *。
- 对于最新的次版本,请使用以下格式,如 8.*。
为每个要包括的软件包重复这个块。
目前镜像构建器工具中的软件包和模块之间没有区别。两者都被视为 RPM 软件包依赖项。
4.7. 支持的镜像自定义
您可以通过启用服务或自定义内核命令行参数来在蓝图中添加额外的 RPM 软件包来自定义镜像。您可以在蓝图中使用多个镜像自定义。要使用这些选项,您必须在蓝图中配置自定义,并将其导入(推送)到镜像构建器。
在 web 控制台中使用镜像构建器时,不支持这些自定义。
- 选择一个发布
name = "blueprint_name" description = "blueprint_version" version = "0.1" distro = "different_minor_version"
替换 "different_minor_version" 以构建不同的次版本,例如,如果要构建 RHEL 8.6,请使用
distro
= "rhel-86"。在 RHEL 8.7 上,您可以构建次版本,如 RHEL 8.6 及更早的版本。如果没有指定发行版,则蓝图将使用主机分发。如果您升级主机操作系统,则没有发行版设置的蓝图将使用新的操作系统版本构建镜像。- 选择一个软件包组
[[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
- 防火墙自定义
为生成的系统镜像设置防火墙。默认情况下,防火墙会阻止所有访问,明确启用其端口的服务除外,如
sshd
。以下蓝图可用于打开其他端口或服务。如果您不想使用
[customizations.firewall]
或[customizations.firewall.services]
,可以删除属性,或者将它们设置为空列表 []。如果您只想使用默认的防火墙设置,您可以从蓝图中省略自定义。注意Google 和 OpenStack 模板为其环境明确禁用防火墙。这不能被蓝图覆盖。
[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
中的名称来启用或禁用端口列表。
- 自定义防火墙服务
services
是一个具有以下包含要为firewalld
启用或禁用服务的属性的可选对象:-
enabled
- 要启用的服务的可选字符串列表。 disabled
- 要禁用的服务的可选字符串列表。检查可用的防火墙服务。
$ firewall-cmd --get-services
在蓝图中,在
customs.firewall.service
部分下指定要自定义的防火墙服务。[customizations.firewall.services] enabled = ["SERVICES"] disabled = ["SERVICES"]
例如:
[customizations.firewall.services] enabled = ["ftp", "ntp", "dhcp"] disabled = ["telnet"]
firewall.services
中列出的服务与/etc/services
文件中提供的服务名不同。注意如果您不想自定义防火墙服务,请省略蓝图中的
[customizations.firewall]
和[customizations.firewall.services]
部分。
-
- 设置在引导时要启用哪个服务
[customizations.services] enabled = ["SERVICES"] disabled = ["SERVICES"]
您可以控制在引导期间要启用哪些服务。有些镜像类型已经启用或禁用了服务,以确保镜像可以正常工作,此设置不能被覆盖。蓝图中的
[customizations.services]
自定义不会替换这些服务,而是将它们添加到镜像模板中已存在的服务列表中。注意每次构建启动时,它会克隆主机系统的存储库。如果您引用一个包含大量历史记录的存储库,则可能需要一些时间来克隆,其使用了大量的磁盘空间。另外,克隆是临时的,构建会在创建 RPM 软件包后将其删除。
- 指定自定义文件系统配置
您可以在蓝图中指定自定义文件系统配置,因此可以创建具有特定磁盘布局,而不是默认布局配置的镜像。通过使用蓝图中的非默认布局配置,您可以受益于:
- 安全基准合规性
- 防止磁盘不足错误
- 提高了性能
与现有设置的一致性
要在蓝图中自定义文件系统配置:
注意OSTree 系统不支持文件系统自定义,因为 OSTree 镜像有自己的挂载规则,如只读。
[[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-image
、edge-installer
、edge-simplified-installer
。
创建一个自定义目录蓝图自定义
使用 [[customizations.directories]]
蓝图自定义,您可以在镜像的 /etc
目录中创建自定义目录。
如果您使用带有目录路径的 customizations.directories
,且其在设置了 mode
、user
或 group
的镜像中已存,则镜像构建无法防止更改现有目录的所有权或权限。
使用 [[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
- 必需 - 输入您要创建的目录的路径。它必须是/etc
目录下的绝对路径。 -
mode
- 可选 - 以八进制格式设置目录的访问权限。如果没有指定权限,则默认为 0755。前面的零是可选的。 -
user
- 可选 - 将用户设为目录的所有者。如果没有指定用户,则默认为root
。您可以将用户指定为字符串或整数。 -
group
- 可选 - 将组设为目录的所有者。如果没有指定组,则默认为root
。您可以将组指定为字符串或整数。 -
ensure_parents
- 可选 - 指定是否根据需要创建父目录。如果没有指定值,则默认为false
。
创建一个自定义文件蓝图自定义
您可以使用自定义文件蓝图自定义来创建新文件或替换现有文件。您指定的文件的父目录必须存在,否则镜像构建会失败。通过在 [[customizations.directories]]
自定义中指定它来确保父目录存在。
如果您将文件自定义与其他蓝图自定义相结合,这可能会影响其他自定义的功能,或者可能会覆盖当前的文件自定义。如果您不确定自定义,请使用合适的蓝图自定义。
使用 [[customizations.files]]
蓝图自定义,您可以:
- 创建新文本文件。
- 修改现有文件。警告:这可能会覆盖现有内容。
- 为您要创建的文件设置用户和组所有权。
以八进制格式设置 mode 权限。
注意您无法创建或替换以下文件:
-
/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
- 必需 - 输入您要创建的文件的路径。它必须是/etc
目录下的绝对路径。 -
mode
可选 - 以八进制格式设置文件的访问权限。如果没有指定权限,则默认为 0644。前面的零是可选的。 -
user
- 可选 - 将用户设为文件的所有者。如果没有指定用户,则默认为root
。您可以将用户指定为字符串或整数。 -
group
- 可选 - 将组设为文件的所有者。如果没有指定组,则默认为root
。您可以将组指定为字符串或整数。 -
data
- 可选 - 指定纯文本文件的内容。如果没有指定内容,它会创建一个空文件。
其他资源
4.8. 镜像构建器安装的软件包
使用镜像构建器创建系统镜像时,系统会安装一组基本软件包。默认情况下,镜像构建器使用 Core
组作为软件包的基本列表。
表 4.1. 支持创建镜像类型的默认软件包
镜像类型 | 默认软件包 |
---|---|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
当您在蓝图中添加其他组件时,请确保添加的组件中的软件包不会与任何其他软件包组件冲突。否则,系统无法解决依赖项并创建自定义镜像失败。您可以通过运行以下命令检查软件包之间没有冲突:
# composer-cli blueprints depsolve BLUEPRINT-NAME
其他资源
4.9. 在自定义镜像中启用服务
当使用镜像构建器配置自定义镜像时,镜像使用的默认服务由以下内容决定:
-
使用
osbuild-composer
工具的 RHEL 发行版本 - 镜像类型
例如,ami
镜像类型默认启用 sshd
、chronyd
和 cloud-init
服务。如果没有启用这些服务,则自定义镜像不会引导。
表 4.2. 启用服务来支持镜像类型创建
镜像类型 | 默认启用的服务 |
---|---|
| sshd, cloud-init, cloud-init-local, cloud-config, cloud-final |
| sshd, cloud-init, cloud-init-local, cloud-config, cloud-final |
| cloud-init |
| 默认没有启用任何额外服务 |
| 默认没有启用任何额外服务 |
| sshd, chronyd, waagent, cloud-init, cloud-init-local, cloud-config, cloud-final |
| sshd、chronyd、vmtoolsd、cloud-init |
注:您可以自定义在系统引导过程中要启用的服务。但是,自定义不会覆盖上述镜像类型默认启用的服务。
其他资源
第 5 章 使用镜像构建器 Web 控制台界面创建系统镜像
镜像构建器是创建自定义系统镜像的工具。要控制镜像构建器并创建自定义系统镜像,您可以使用 Web 控制台界面。请注意, 命令行界面 目前为首选,因为它提供了更多的功能。
5.1. 在 RHEL web 控制台中访问镜像构建器仪表盘
使用 RHEL web 控制台的 cockpit-composer 插件,您可以使用图形界面管理镜像构建器蓝图和 compose。
先决条件
- 您必须有对该系统的根权限。
- 已安装镜像构建器。
流程
在安装了镜像构建器的系统上的 Web 浏览器中打开
https://localhost:9090/
。有关如何远程访问镜像构建器的更多信息,请参阅 使用 RHEL web 控制台管理系统 文档。
- 以 root 用户身份登录 Web 控制台。
要显示镜像构建器控制,请单击窗口左上角的
镜像构建器
图标。镜像构建器仪表盘会打开,列出现有的蓝图(若有的话)。
其他资源
5.2. 在 web 控制台界面中创建镜像构建程序蓝图
在创建自定义 RHEL 系统镜像前,创建蓝图是一个必要的步骤。所有自定义都是可选的。
Red Hat Enterprise Linux 9.2 或更高版本,以及 Red Hat Enterprise Linux 8.8 或更高版本提供这些蓝图自定义。
先决条件
- 您已在浏览器中从 Web 控制台打开了镜像构建器应用。请参阅 RHEL web 控制台中的访问镜像构建器 GUI。
流程
点右上角的 Create Blueprint。
此时会打开一个对话框向导,其中包含蓝图名称和描述字段。
在
Details
页面中:- 输入蓝图的名称,以及可选的描述。点击 Next。
可选:在
Packages
页面中:在
Available packages
搜索中,输入软件包名称并点击 > 按钮将其移到所选的软件包字段。搜索并包含尽可能多的软件包。点击 Next。注意除非另有指定,否则这些自定义都是可选的。
-
在
Kernel
页面中,输入内核名称和命令行参数。 在
File system
页面中,您可以对镜像文件系统选择Use automatic partitioning
或Manually configure partitions
。要手动配置分区,请完成以下步骤:点 Manually configure partitions 按钮。
此时会打开
Configure partitions
部分,显示基于红帽标准和安全指南的配置。在下拉菜单中,提供配置分区的详情:
对于
Mount point
字段,选择以下挂载点类型选项之一:-
/
- root 挂载点 -
/var
-
/home
-
/opt
-
/srv
-
/usr
-
/app
-
/data
-
/tmp
/usr/local
您还可以向
Mount point
添加额外的路径,如/tmp
。例如:/var
作为前缀,/tmp
作为附加路径会产生/var/tmp
。注意根据您选择的挂载点类型,文件系统类型会更改为
xfs
,以此类推。
-
对于文件系统的
Minimum size partition
字段,请输入所需的最小分区大小。在 Minimum size 下拉菜单中,您可以使用通用大小单位,如GiB
、MiB
或KiB
。默认单位为GiB
。注意Minimum size
意味着镜像构建器在分区太小以致不能创建工作镜像的情况下,仍然可以增加分区大小。
要添加更多分区,请点击 Add partition 按钮。如果您看到以下出错信息:"Duplicate partitions: Only one partition at each mount point can be created.”,您可以:
- 点 Remove 按钮删除重复的分区。
- 为您要创建的分区选择一个新的挂载点。
- 完成分区配置后,点 Next。
在
Services
页面中,您可以启用或禁用服务:- 输入您要启用或禁用的服务名称,用逗号、空格或按 Enter 键分隔它们。点击 Next。
在
Firewall
页面上,设置防火墙设置:-
输入
Ports
,以及您要启用或禁用的防火墙服务。 - 点 Add zone 按钮,为每个区域单独管理您的防火墙规则。点击 Next。
-
输入
在
Users
页面上,按照以下步骤添加用户:- 单击 Add user。
-
输入
Username
、password
,以及SSH key
。您还可以单击Server administrator
复选框,将用户标记为特权用户。点击 Next。
在
Groups
页面上,完成以下步骤来添加组:点 Add groups 按钮:
-
输入
Group name
和Group ID
。您可以添加多个组。点击 Next。
-
输入
在
SSH keys
页面上,添加一个密钥:点 Add key 按钮。
- 输入 SSH 密钥。
-
输入
User
。点击 Next。
在
Timezone
页面上,设置您的时区设置:在
Timezone
字段中输入您要添加到系统镜像的时区。例如,添加以下时区格式:"US/Epastern"。如果您没有设置时区,系统默认使用 Universal Time, Coordinated (UTC)作为默认值。
-
输入
NTP
服务器。点击 Next。
在
Locale
页面上,完成以下步骤:-
在
Keyboard
搜索字段中,输入您要添加到系统镜像的软件包名称。例如: ["en_US.UTF-8"]。 -
在
Languages
搜索字段中,输入您要添加到系统镜像的软件包名称。例如:"us"。点击 Next。
-
在
在
Others
页面上,完成以下步骤:-
在
Hostname
字段上,输入您要添加到系统镜像的主机名。如果没有添加主机名,操作系统会决定主机名。 -
仅对 Simplifier Installer 镜像是必需的:在
Installation Devices
字段上,输入您系统镜像的有效节点。例如:dev/sda1
。点击 Next。
-
在
仅在构建 FIDO 镜像时才是必需的:在
FIDO device onboardin
页面上,完成以下步骤:在
Manufacturing server URL
字段中输入以下信息:-
在
DIUN public key insecure
字段中,输入不安全的公钥。 -
在
DIUN public key hash
字段中,输入公钥哈希。 -
在
DIUN public key root certs
字段中,输入公钥根证书。点击 Next。
-
在
在
OpenSCAP
页面上,完成以下步骤:-
在
Datastream
字段上,输入您要添加到系统镜像的datastream
补救指令。 -
在
Profile ID
字段删,输入您要添加到系统镜像的profile_id
安全配置文件。点击 Next。
-
在
仅在构建 Ignition 镜像时必需:在
Ignition
页面上,完成以下步骤:-
在
Firstboot URL
字段上,输入您要添加到系统镜像的软件包名称。 -
在
Embedded Data
字段上,拖动或上传您的文件。点击 Next。
-
在
-
.在
Review
页面上,查看蓝图的详情。点 Create。
镜像构建器视图将打开,列出现有的蓝图。
5.3. 在镜像构建器 Web 控制台界面中导入蓝图
您可以导入并使用已存在的蓝图。系统会自动解决所有依赖项。
先决条件
- 您已在浏览器中从 Web 控制台打开了镜像构建器应用。
- 您有一个要导入到镜像构建器 web 控制台界面中使用的蓝图。
流程
-
在镜像构建器仪表盘上,单击 Import blueprint。此时会打开
Import blueprint
向导。 -
在
Upload
字段中,拖放或上传现有的蓝图。此蓝图可以是TOML
或JSON
格式。 点 Import。仪表盘列出了您导入的蓝图。
当您点您导入的蓝图时,您可以访问带有您导入蓝图的所有自定义的仪表盘。
验证
要验证已为导入蓝图选择的软件包,请导航到
Packages
选项卡。- 要列出所有软件包依赖项,请单击 All。列表是可搜索的,并可排序。
可选:要修改任何自定义:
-
在
Customizations
仪表盘中,点击您要更改的自定义。另外,您可以点击 Edit blueprint 来导航到所有可用的自定义选项。
-
在
5.4. 从镜像构建器 Web 控制台界面导出蓝图
您可以导出蓝图以便在另一个系统中使用自定义。您可以以 TOML
或 JSON
格式导出蓝图。这两个格式在 CLI 和 API 接口中都可以工作。
先决条件
- 您已在浏览器中从 Web 控制台打开了镜像构建器应用。
- 您有一个要导出的蓝图。
流程
- 在镜像构建器仪表盘上,选择您要导出的蓝图。
-
点
Export blueprint
。此时会打开Export blueprint
向导。 要保存
导出的蓝图
,请点击 Export 按钮。- (可选)点击 Copy 按钮来复制蓝图。
验证
- 打开导出的蓝图来检查并查看它。
5.5. 在 web 控制台界面中使用镜像构建器创建系统镜像
您可以通过完成以下步骤,从蓝图创建一个自定义 RHEL 系统镜像。
先决条件
- 在浏览器中,您从 Web 控制台打开了镜像构建器应用。
- 您创建了蓝图。
流程
- 访问镜像构建器仪表盘。
- 在蓝图表中,找到您要构建镜像的蓝图。
- 在所选蓝图的右侧,点 Create Image。Create image 对话框向导将打开。
-
导航到
Images
选项卡,再点Create Image
。Create image
向导将打开。 在 Image 输出页面中完成以下步骤:
- 从 Select a blueprint 列表中,选择您想要的镜像类型。
从 Image output type 列表中,选择您想要的镜像输出类型。
根据您选择的镜像类型,您需要添加更多详细信息。
- 点击 Next。
在 Review 页面上,查看关于镜像创建的详情,并点 Create image。
镜像构建启动,需要 20 分钟完成。
验证
镜像完成构建后,您可以:
- 下载镜像。
- 下载镜像的日志以检查元素,并验证是否发现了任何问题。
第 6 章 使用镜像构建器来从不同的版本创建系统镜像
您可以使用镜像构建器创建与主机不同的多个 RHEL 次版本的镜像,如 RHEL 8.7 和 RHEL 8.6。为此,您可以使用设置发行版本发布字段添加源系统仓库,也可以使用正确的发行版本发布字段创建蓝图。
另外,如果您以旧格式拥有现有的蓝图或源系统程序库,您可以使用正确的发行版本发布字段创建新蓝图。
要列出支持的发行版本发行版本,您可以运行以下命令:
$ composer-cli distros list
输出显示支持的发行版本分布名称的列表:
rhel-8 rhel-84 rhel-85 rhel-86 rhel-87 rhel-88
注意不支持跨发布镜像构建,如在 RHEL 上构建 CentOS 镜像。
6.1. 通过 CLI 创建一个使用不同发布的镜像
要在 CLI 中制作镜像时选择要使用的发行版,您必须在蓝图中设置 distro
字段。为此,请按照以下步骤操作:
流程
- 如果要创建新蓝图
- 创建一个蓝图。例如:
name = "<blueprint_name>" description = "<image-description>" version = "0.0.1" modules = [] groups = [] distro = "<distro-version>"
通过将
distro
字段设置为 "rhel-84",您可以确保它始终构建 RHEL 8.4 镜像,无论哪个版本在主机上运行。注意如果
distro
字段为空,它会使用相同的主机分布。- 如果要更新现有蓝图
- 将现有蓝图保存(导出)到本地文本文件:
# composer-cli blueprints save EXISTING-BLUEPRINT
使用您选择的文本编辑器编辑现有蓝图文件,使用您选择的发布设置
distro
字段,例如:name = "blueprint_84" description = "A 8.4 base image" version = "0.0.1" modules = [] groups = [] distro = "rhel-84"
- 保存文件并关闭编辑器。
将蓝图推送(导入)回镜像构建器:
# composer-cli blueprints push EXISTING-BLUEPRINT.toml
启动镜像创建:
# composer-cli compose start BLUEPRINT-NAME IMAGE-TYPE
等待 compose 完成。
检查 compose 的状态:
# composer-cli compose status
完成 compose 后,它会显示一个 FINISHED 状态值。根据 UUID 识别列表中的内容。
下载生成的镜像文件:
# composer-cli compose image UUID
使用前面步骤中显示的 UUID 值替换 UUID。
6.2. 使用特定发行版本的系统仓库
您可以在解析依赖项和构建镜像时指定系统存储库源使用的分发字符串列表。为此,请按照以下步骤执行:
流程
创建一个具有以下结构的 TOML 文件,例如:
check_gpg = true check_ssl = true distros = ["<distro-version>"] id = "<image-id>" name = "<image-name>_" system = false type = "<image-type>" url = "http://local/repos/rhel-<distro-version>/<project-repo>/"
例如:
check_gpg = true check_ssl = true distros = ["rhel-84"] id = "rhel-84-local" name = "local packages for rhel-84" system = false type = "yum-baseurl" url = "http://local/repos/rhel-84/projectrepo/"
其他资源
第 7 章 使用镜像构建器创建引导 ISO 安装程序镜像
您可以使用镜像构建器创建可引导的 ISO 安装程序镜像。这些镜像由一个带有根文件系统的 .tar
文件组成。您可以使用可引导的 ISO 镜像来将文件系统安装到裸机服务器上。
镜像构建器构建一个清单,该清单会创建一个包含根文件系统的引导 ISO。要创建 ISO 镜像,请选择映像类型 image-installer。镜像构建器使用以下内容构建一个 .tar
文件:
- 标准 Anaconda 安装程序 ISO
- 嵌入式 RHEL 系统 tar 文件
- 安装提交的默认 Kickstart 文件,其要求最小
创建的安装程序 ISO 镜像包含一个预先配置的系统镜像,您可以直接安装到裸机服务器。
7.1. 在命令行界面中使用镜像构建器创建引导 ISO 安装程序镜像
您可以使用镜像构建器命令行界面创建自定义的引导 ISO 安装程序镜像。
先决条件
- 您已为镜像创建了一个包含用户的蓝图,并将其推送回镜像构建器。请参阅 用户的蓝图自定义。
流程
创建 ISO 镜像:
# composer-cli compose start BLUEPRINT-NAME image-installer
- 带有您创建的蓝图名称的 BLUEPRINT-NAME
image-installer 是镜像类型
compose 进程在后台启动,并显示 Compose 的 UUID。
等待 compose 完成。请注意,这可能需要几分钟时间。
检查 Compose 的状态:
# composer-cli compose status
完成的 compose 显示 FINISHED 状态值。根据 UUID 识别列表中的内容。
完成 compose 后,下载创建的镜像文件:
# composer-cli compose image UUID
将 UUID 替换为前面步骤中获取的 UUID 值。
因此,镜像构建器构建一个包含
.tar
文件的.iso
文件。.tar
文件是要为操作系统安装的镜像。. iso
设置为引导 Anaconda 并安装 tar 文件来设置系统。
验证
- 导航到下载镜像文件的文件夹。
-
找到您下载的
.iso
镜像。 挂载 ISO。
$ mount -o ro path_to_ISO /mnt
您可以在
/mnt/liveimg.tar.gz
目录中找到.tar
文件。提取
.tar
文件内容。$ tar xzf /mnt/liveimg.tar.gz
您可以使用在硬盘上创建的 ISO 镜像文件,或者在虚拟机中引导,例如在 HTTP 引导或 USB 安装中。
7.2. 在 GUI 中使用镜像构建器创建引导 ISO 安装程序镜像
您可以使用镜像构建器 GUI 构建自定义引导 ISO 安装程序镜像。
先决条件
- 您已为镜像创建了一个蓝图。请参阅在 web 控制台界面中创建镜像构建程序蓝图。
流程
- 在浏览器中打开 RHEL web 控制台的镜像构建器界面。请参阅使用命令行界面创建镜像构建器蓝图。
- 找到您要用来构建镜像的蓝图。为此,请在左上角的搜索框中输入蓝图名称或部分名称,然后单击 Enter。
在蓝图的右侧,点对应的 Create Image 按钮。
Create image 对话框向导将打开。
在 Create image 对话框向导中:
-
在 Image Type 列表中,选择
"RHEL Installer (.iso)
"。 - 点 Create。
-
在 Image Type 列表中,选择
镜像构建器将 RHEL ISO 镜像的组成添加到队列中。
完成镜像构建过程需要几分钟时间。
过程完成后,您可以看到镜像构建完成状态。镜像构建器创建了 ISO 镜像。
验证
成功创建镜像后,您可以下载该镜像。
-
点 Download 将
"RHEL Installer (.iso) "
镜像保存到您的系统中。 -
进入您下载
"RHEL Installer(.iso)"
镜像的文件夹。 - 找到您下载的 .tar 镜像。
提取
"RHEL 安装程序(.iso)"
镜像内容。$ tar -xf content.tar
您可以使用在硬盘上生成的 ISO 镜像文件,或者在虚拟机中引导,例如在 HTTP 引导或 USB 安装中。
7.3. 将镜像构建器 ISO 镜像安装到裸机系统
使用镜像构建器将您创建的可引导 ISO 镜像安装到裸机系统。
先决条件
- 您已使用镜像构建器创建了可引导的 ISO 镜像。请参阅在命令行界面中使用镜像构建器创建引导 ISO 安装程序镜像。
- 您已下载了可引导 ISO 镜像。
-
已安装
dd
工具。 - 您有一个有足够容量的 USB 闪存驱动器 ISO 镜像。所需的大小因您在蓝图中选择的软件包而异,但推荐的最小值为 8 GB。
流程
使用
dd
工具将可引导 ISO 镜像直接写入 USB 驱动器。例如:dd if=installer.iso of=/dev/sdX
其中
installer.iso
是 ISO 镜像文件名,/dev/sdX
是您的 USB 闪存驱动器设备路径。- 将闪存驱动器插入到您要引导的计算机的 USB 端口中。
从 USB 闪存引导 ISO 镜像。
当安装环境启动时,您可能需要手动完成安装,类似于默认的 Red Hat Enterprise Linux 安装。
第 8 章 使用镜像构建器 OpenSCAP 集成创建预先强化的镜像
内部镜像构建器支持 OpenSCAP 集成,以生成预先强化的 RHEL 镜像。使用与 OpenSCAP 集成的内部镜像构建器,您可以生成预先强化的 RHEL 镜像。您可以设置蓝图,从一组预定义的安全配置集中选择、添加一组软件包或附加文件,并构建了一个自定义的 RHEL 镜像,供您部署到更适合于您的环境的选择平台上。
红帽为构建系统时可以选择的安全强化配置集定期更新版本,以便您能够满足您的当前部署指南。
镜像构建器不包括对 FIPS 引导模式的支持。因此,目前不支持需要启用 FIPS 模式的 OpenSCAP 配置集,如 DISA STIG。
8.1. Kickstart 和预先强化的镜像之间的区别
对于使用 Kickstart 文件创建的传统镜像,您需要选择要安装哪些软件包,并确保系统不受安全漏洞的影响。借助镜像构建器 OpenSCAP 集成,您可以构建安全强化型镜像。在镜像构建过程中,OSBuild oscap remediation stage
在文件系统树的 chroot 中运行 OpenSCAP
工具。OpenSCAP
工具为您选择的配置集运行标准评估,并将补救应用于镜像。因此,如果您与在实时系统上运行补救进行比较,您可以构建更加全面的强化型镜像。
8.2. 安装 OpenSCAP
安装 OpenSCAP 工具可访问 SCAP 工具,以帮助您为您的系统创建标准安全清单。
流程
在您的系统上安装 OpenSCAP:
# *yum install openscap-scanner*
安装
scap-security-guide
软件包:# *yum install scap-security-guide*
安装完成后,您可以使用
oscap
命令行工具开始。SCAP 内容将安装在/usr/share/xml/scap/ssg/content/
目录中。
8.3. OpenSCAP 蓝图自定义
通过对蓝图自定义进行 OpenSCAP 支持,您可以创建蓝图,然后使用它们构建自己的预先强化的镜像。要创建预先强化的镜像,您可以自定义挂载点并根据所选的安全配置集配置文件系统布局。在镜像构建过程中,OpenSCAP 应用第一次引导补救。
选择 OpenSCAP 配置集后,OpenSCAP 蓝图自定义配置镜像,以便在使用所选配置集的镜像构建过程中触发补救。
要在镜像蓝图中使用 OpenSCAP 蓝图,请输入以下信息:
-
到
datastream
补救指令的数据流路径。datastream 路径位于 /usr/share/xml/scap/ssg/content/ 目录中。 所需的安全配置集的
profile_id
。profile_id
字段接受长和简短形式,例如:cis
或xccdf_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-docker
或oscap-vm
不支持的自定义对象,如 Docker 以外的格式容器。oscap-chroot
模拟oscap
工具的使用和选项。镜像构建器根据您的蓝图自定义生成
osbuild
阶段所需的配置。另外,镜像构建器为镜像添加两个软件包:-
openscap-scanner
-OpenSCAP
工具。 scap-security-guide
- 包含补救指令的软件包。注意补救阶段将
scap-security-guide
软件包用于 datastream,因为这个软件包默认安装在镜像中。如果要使用不同的数据流,将必要的软件包添加到蓝图中,并在oscap
配置中指定到 datastream 的路径。
其他资源
8.4. 使用镜像构建器创建预先强化的镜像
通过 OpenSCAP 与镜像构建器的集成,您可以创建预先强化的镜像。
流程
使用 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"
启动 OpenSCAP 镜像的构建:
# composer-cli compose start blueprint_name qcow2
其中 blueprint_name 是蓝图名称。
镜像构建就绪后,您可以在部署中使用预先强化的镜像。请参阅创建虚拟机。
验证
在虚拟机中部署预先强化的镜像后,可以执行配置合规性扫描,以验证镜像是否与所选安全配置集一致。
执行配置合规性扫描不能保证系统是合规的。如需更多信息,请参阅配置合规性扫描。
- 使用 SSH 连接到镜像。
运行
oscap
扫描程序。# scap-workbench
- 选择您要扫描的系统版本。点 Load content。
- 选择您要扫描的配置集,然后点 Scan。OpenSCAP 检查系统的所有要求。
- 扫描完成后,点 Show Report。
其他资源
第 9 章 使用镜像构建器准备和部署 KVM 客户机镜像
要创建用于在 Red Hat Virtualization 上使用的专用镜像,您可以使用镜像构建器制作一个 KVM
客户机镜像。KVM 客户机镜像仅被 Red Hat Virtualization 中的 rhel-guest-image
支持。
当使用 RHEL 镜像构建器创建磁盘镜像时,即使您指定了自己的分区布局,它也会在 GUID 分区表(GPT)布局中创建分区表,并带有双引导的镜像:BIOS 模式或 UEFI 模式。然后,它会创建一个 BIOS 引导分区以及 UEFI 分区。
使用自定义 KVM 客户机镜像涉及以下高级别步骤:
-
使用镜像构建器创建 KVM 客户机
.qcow2
镜像。 - 从 KVM 客户机镜像创建虚拟机。
9.1. 使用镜像构建器创建自定义 KVM 客户机镜像
您可以使用镜像构建器创建自定义 .qcow2
KVM 客户机镜像。
先决条件
- 您必须有访问系统的 root 或 wheel 组用户权限。
-
cockpit-composer
软件包已安装。 - 在 RHEL 系统上,您已打开 web 控制台的镜像构建器仪表盘。
- 您已创建了蓝图。请参阅在 web 控制台界面中创建镜像构建程序蓝图。
流程
- 点您创建的蓝图名称。
- 选择 Images 选项卡。
- 单击 Create Image 来创建自定义镜像。此时会打开弹出窗口。
-
在 Type 下拉菜单中选择
QEMU Image (.qcow2)
。 - 在实例化时设置您想要的镜像大小,并点击 Create。
- 窗口右上角的小弹窗通知您已将镜像创建添加到队列中。镜像创建过程完成后,您可以看到镜像构建完成状态。
验证
-
点击 breadcrumbs 图标,并选择 Download 选项。镜像构建器将 KVM 客户机镜像
.qcow2
文件下载到您的默认下载位置。
其他资源
9.2. 从 KVM 客户机镜像创建虚拟机
使用镜像构建器,您可以构建 .qcow2
镜像,并使用 KVM 客户机镜像创建虚拟机。使用镜像构建器创建的 KVM 客户机镜像已安装并启用了 cloud-init
。
先决条件
-
您已使用镜像构建器创建了一个
.qcow2
镜像。请参阅 在 web 控制台界面中创建镜像构建器蓝图。 -
qemu-kvm
软件包已安装在您的系统上。您可以检查您系统中是否有/dev/kvm
文件夹。 -
在您的系统上已安装了
libvirt
和virt-install
软件包。 -
genisoimage
工具已安装在您的系统上。
流程
-
将您使用镜像构建器创建的 KVM 客户机镜像移到
/var/lib/libvirt/images
目录中。 创建一个目录,如
cloudinitiso
,并导航到这个新创建的目录:$ mkdir cloudinitiso $ cd cloudinitiso
创建一个名为
meta-data
的文件。在此文件中添加以下信息:instance-id: citest local-hostname: vmname
创建一个名为
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 公钥。使用
genisoimage
命令创建一个包含user-data
和meta-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)
使用
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。
虚拟机安装开始:
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
验证
引导完成后,虚拟机会显示文本登录界面。登录到虚拟机:
-
输入
admin
作为用户名,然后按 Enter 键。 输入
password
作为密码,然后按 Enter 键。登录身份验证完成后,您可以使用 CLI 访问虚拟机。
第 10 章 将容器推送到 registry 中并将其嵌入到镜像中
通过对蓝图中的容器自定义的支持,您可以创建容器并将其直接嵌入到您创建的镜像中。
10.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
文件。
10.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"
10.3. 将容器工件直接推送到容器 registry
使用镜像构建程序 CLI 后,您可以将容器工件(如 RHEL for Edge 容器镜像)直接推送到容器 registry。为此,您必须设置 上传供应商
,以及可选的凭证,然后您可以构建容器镜像,将 registry 和存储库作为参数传递到 composer-cli
。镜像就绪后,可在您设置的容器 registry 中提供。
先决条件
-
访问 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 = "*"
推送蓝图:
# composer-cli blueprints push blueprint.toml
构建容器镜像:
# 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
标签。注意构建容器镜像需要一些时间,因为需要解析自定义软件包的依赖项。
- 在镜像构建完成后,您创建的容器将出现在 quay.io 中。
访问 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.
-
复制
清单 ID
值以构建您要嵌入容器的镜像。
其他资源
10.4. 构建镜像并将容器提取到镜像中
创建容器镜像后,您可以构建自定义镜像并将容器镜像提取到其中。为此,您必须在蓝图中指定 容器自定义,以及最终镜像的 容器名称。在构建过程中,会获取容器镜像,并放置在本地 Podman 容器存储中。
先决条件
-
您创建了容器镜像并将其推送到本地
quay.io
容器 registry 实例。 - 您可以访问 registry.access.redhat.com。
-
您有一个容器
清单 ID
。 已安装
qemu-kvm
和qemu-img
软件包。要安装它,请运行以下命令:# yum install qemu-kvm qemu-img
流程
创建蓝图来构建
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
推送蓝图:
# composer-cli blueprints push blueprint-image.toml
构建容器镜像:
# composer-cli start compose image qcow2
其中:
- image 是蓝图名称。
qcow2
是镜像类型。注意构建镜像需要一些时间,因为它将检查
quay.io
registry 上的容器。镜像构建状态变为 "FINISHED" 后,您可以使用您在虚拟机中创建的
qcow2
镜像。
验证
将
.qcow2
镜像从composer-cli
拉取到本地文件系统:# composer-cli compose image COMPOSE-UUID
-
在虚拟机中启动
qcow2
镜像。请参阅从 KVM 客户机镜像创建虚拟机。 qemu
向导将打开。登录到qcow2
镜像。-
输入用户名和密码。这些可以是您在 "customizations.user" 部分的
.qcow2
蓝图中设置的用户名和密码,或是在引导时使用cloud-init
创建的。
-
输入用户名和密码。这些可以是您在 "customizations.user" 部分的
运行容器镜像,并在容器内打开 shell 提示符:
# podman run -it registry.access.redhat.com/ubi9:8080/osbuild/repository /bin/bash/
其中:
-
registry.access.redhat.com
是目标 registry,osbuild
是机构,repository
则是在完成构建时推送容器的位置。
-
检查您添加到蓝图中的软件包是否可用:
# type -a nginx
输出显示
nginx
软件包路径。
第 11 章 使用镜像构建器准备并上传云镜像
镜像构建器可以创建自定义系统镜像,以便在各种云平台上使用。要在云中使用自定义的 RHEL 系统镜像,请使用镜像构建器使用相应的输出类型创建系统镜像,配置您的系统以上传镜像,并将镜像上传到您的云帐户。您可以在 RHEL web 控制台中通过 image builder
应用程序将自定义镜像推送到云,作为我们支持的服务提供商的子集提供,如 AWS 和 Microsoft Azure 云。请参阅 将镜像推送到 AWS Cloud AMI 和 将 VHD 镜像推送到 Microsoft Azure 云。
11.1. 准备上传 AWS AMI 镜像
在上传 AWS AMI 镜像前,您必须配置系统来上传镜像。
先决条件
- 您必须在 AWS IAM account manager 中配置了一个 Access Key ID。
- 您必须具有一个可写的 S3 存储桶。
流程
安装 Python 3 和
pip
工具:# yum install python3 # yum install python3-pip
使用
pip
安装 AWS 命令行工具 :# pip3 install awscli
运行以下命令设定您的配置集。终端提示您提供凭证、地区和输出格式:
$ aws configure AWS Access Key ID [None]: AWS Secret Access Key [None]: Default region name [None]: Default output format [None]:
为存储桶定义名称,并使用以下命令创建存储桶:
$ BUCKET=bucketname $ aws s3 mb s3://$BUCKET
使用实际存储桶名称替换 bucketname。它必须是全局唯一的名称。因此,您的存储桶会被创建。
要授予访问 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
11.2. 使用 CLI 将 AMI 镜像上传到 AWS
您可以使用镜像构建器来构建 ami
镜像,并使用 CLI 将其直接推送到 Amazon AWS Cloud 服务供应商。
流程
使用文本编辑器,使用以下内容创建配置文件:
provider = "aws" [settings] accessKeyID = "AWS_ACCESS_KEY_ID" secretAccessKey = "AWS_SECRET_ACCESS_KEY" bucket = "AWS_BUCKET" region = "AWS_REGION" key = "IMAGE_KEY"
将字段中的值替换为您的
accessKeyID
、secretAccessKey
、bucket
和region
的凭证。IMAGE_KEY
值是要上传到 EC2 的虚拟机镜像的名称。- 将文件保存为 CONFIGURATION-FILE.toml,然后关闭文本编辑器。
启动 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 设置。在将镜像上传到存储桶前,您必须对存储桶设置策略。
检查镜像构建的状态,并将其上传到 AWS:
# composer-cli compose status
完成镜像上传过程后,您可以看到"FINISHED"状态。
验证
要确认镜像上传成功:
-
访问菜单中的 EC2,并在 AWS 控制台中选择正确的区域。镜像必须具有
available
状态,以指示它已被成功上传。 -
在控制面板中,选择您的镜像并点
Launch
。
其它资源
11.3. 将镜像推送到 AWS Cloud AMI
您可以将您创建的输出镜像推送到 Amazon AWS Cloud AMI 服务供应商。
先决条件
-
您必须有访问系统的
root
或wheel
组用户权限。 - 您已在浏览器中打开了 RHEL web 控制台的镜像构建器界面。
- 您已创建了蓝图。请参阅在 web 控制台界面中创建镜像构建程序蓝图。
- 您必须在 AWS IAM account manager 中配置了一个 Access Key ID。
- 您必须具有一个可写的 S3 存储桶。
流程
- 点蓝图名称。
- 选择选项卡 Images。
点 Create Image 创建自定义镜像。
此时会打开弹出窗口。
-
在 Type 下拉菜单中选择
Amazon Machine Image Disk (.raw)
。 - 选中 "Upload to AWS" 复选框,将您的镜像上传到 AWS 云,并点击 Next。
要验证您是否可以访问 AWS ,请在对应的字段中输入您的
"AWS access key ID"
和"AWS secret access key"
。点击 Next。注意您只能在创建新 Access Key ID 时查看 AWS secret access key 。如果您不知道您的 Secret Key,请生成一个新的 Access Key ID。
-
在
Image name
字段中输入镜像名称,在Amazon S3 bucket name
字段中输入 Amazon bucket 名称,并为您要添加自定义镜像的存储桶输入AWS region
字段。点击 Next。 查看信息并点 Finish。
(可选)您可以点击 Back 来修改任何不正确的详情。
注意您必须具有要发送自定义镜像的存储桶的正确 IAM 设置。此流程使用 IAM 导入和导出,因此您必须在将镜像上传到存储桶前为存储桶设置 策略。如需更多信息,请参阅 IAM 用户所需的权限。
-
在 Type 下拉菜单中选择
右上角的一个小弹窗会通知您保存的进度。它还告知镜像创建过程、创建此镜像的过程以及后续的上传到 AWS Cloud。
完成这个过程后,您可以看到 镜像构建完成状态。
-
点菜单中的 Service→EC2,然后在 AWS 控制台中选择 正确的区域。镜像必须具有
Available
状态,以指示它已被上传。 -
在控制面板中,选择您的镜像并点
Launch
。 -
此时会打开一个新窗口。根据启动镜像所需的资源选择实例类型。点 Review and
Launch
。 -
查看您的实例启动详情。如果需要进行任何更改,您可以编辑任何部分。点
Launch
在启动实例之前,选择一个访问它的公钥。
您可以使用您已有的密钥对,也可以创建一个新的密钥对。
按照以下步骤在 EC2 中创建新的密钥对,并将它连接到新实例。
- 在下拉菜单中选择 "Create a new key pair"。
- 输入新密钥对名称。它生成一个新的密钥对。
- 点 "下载密钥对" 在您的本地系统中保存新密钥对。
然后,您可以点
Launch Instance
来启动您的实例。您可以检查实例的状态,它显示为 Initializing。
- 实例状态变为 running 后,连接按钮将变为可用。
点 连接。此时会出现一个弹出窗口,其中包含有关如何使用 SSH 连接的说明。
- 选择 A standalone SSH client 作为首选连接方法并打开终端。
在您存储私钥的位置,确保您的密钥是公开可见的,以便 SSH 可以正常工作。要做到这一点,请运行以下命令:
$ chmod 400 <your-instance-name.pem>_
使用其公共 DNS 连接到您的实例:
$ ssh -i "<_your-instance-name.pem_"> ec2-user@<_your-instance-IP-address_>
键入
yes
以确认您要继续连接。因此,您使用 SSH 连接到实例。
验证
- 检查在使用 SSH 连接到实例后您是否能够执行任何操作。
11.4. 准备上传 Microsoft Azure VHD 镜像
您可以使用镜像构建器准备可上传到 Microsoft Azure
云的 VHD 镜像。
先决条件
- 您必须具有可用的 Microsoft Azure 资源组和存储帐户。
-
已安装 python2,因为
AZ CLI
工具依赖于 python 2.7。
流程
导入 Microsoft 存储库密钥:
# rpm --import https://packages.microsoft.com/keys/microsoft.asc
创建本地
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'
安装 Microsoft Azure CLI:
# yumdownloader azure-cli # rpm -ivh --nodeps azure-cli-2.0.64-1.el7.x86_64.rpm
注意下载的 Microsoft Azure CLI 软件包版本可能会因当前可用的版本而异。
运行 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 并输入要进行身份验证的设备代码。
列出 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
记录上一个命令输出中的
key1
值,并将其分配给环境变量:$ KEY1=value
创建存储容器:
$ CONTAINER=storage-account-name $ az storage container create --account-name $ACCOUNT \ --account-key $KEY1 --name $CONTAINER
将 storage-account-name 替换为存储帐户的名称。
其他资源
11.5. 将 VHD 镜像上传到 Microsoft Azure 云
创建了自定义 VHD 镜像后,您可以将其上传到 Microsoft Azure 云。
先决条件
- 必须设置您的系统以上传 Microsoft Azure VHD 镜像。请参阅 准备上传 Microsoft Azure VHD 镜像。
您必须有镜像构建器创建的 Microsoft Azure VHD 镜像。
-
在 CLI 中,使用
vhd
输出类型。 在 GUI 中,使用
Azure Disk Image (.vhd)
镜像类型。流程
将镜像推送到 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 ...
上传到 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 ...
-
在 CLI 中,使用
验证
使用 Microsoft Azure 门户创建实例,或者使用以下命令:
$ az vm create --resource-group $GROUP --location eastus --name $VHD --image $VHD --admin-username azure-user --generate-ssh-keys - Running ...
-
通过 SSH 使用您的私钥访问生成的实例。以
azure-user
用户身份登录。
其它资源
11.6. 将 VHD 镜像推送到 Microsoft Azure 云
您可以使用镜像构建器创建 .vhd
镜像。然后,您可以将输出 .vhd
镜像推送到 Microsoft Azure Cloud 服务提供商的 Blob 存储。
先决条件
- 有对系统的 root 访问权限。
- 您可以访问 RHEL web 控制台的镜像构建器界面。
- 您创建了蓝图。请参阅在 web 控制台界面中创建镜像构建程序蓝图。
- 您已创建了 Microsoft 存储帐户。
- 您有一个可写入 Blob Storage。
流程
- 在镜像构建器仪表盘中,选择您要使用的蓝图。
- 点 Images 选项卡。
点 Create Image 创建自定义的
.vhd
镜像。Create image 向导将打开。
-
从 Type 下拉菜单中选择
Microsoft Azure (.vhd)
。 - 选中 Upload to Azure 复选框,将您的镜像上传到 Microsoft Azure Cloud。
- 输入 Image Size ,并点 Next。
-
从 Type 下拉菜单中选择
在 Upload to Azure 页面行,输入以下信息:
在 Authentication 页面上,输入:
- 您的 存储帐户 名称。您可以在 Microsoft Azure 门户中 中的 Storage account 页面上找到它。
- 您的 存储访问密钥 :您可以在 Access Key 存储页面上找到它。
- 点击 Next。
在 Authentication 页面上,输入:
- 镜像名称。
- 存储容器.它是您将镜像上传到的 blob 容器。您可以在 Microsoft Azure 门户 的 Blob service 部分中找到它。
- 点击 Next。
- 在 Review 页面上,点 Create。镜像构建和上传过程开始。
后续步骤
- 要访问推送到 Microsoft Azure Cloud 的镜像,请访问 Microsoft Azure 门户。
- 在搜索栏中,输入"storage account",然后从列表中单击 Storage accounts。
- 在搜索栏中输键入"Images",然后在 Services 下选择第一个条目。您将被重定向到 镜像仪表盘。
- 在导航面板上,单击 Containers。
-
查找您创建的容器。在容器内,是您创建和推送的
your_image_name.vhd
文件。
验证
验证您能否创建虚拟机镜像并启动它。
- 在搜索栏中,输入镜像帐户,并单击列表中的 Images。
- 单击 +Create。
- 从下拉列表中,选择您之前使用的资源组。
- 输入镜像的名称。
- 对于 OS type,请选择 Linux。
- 对于 VM generation,请选择 Gen 2。
- 在 Storage Blob 下,点 Browse ,并点存储账户和容器,直到您到达 VHD 文件。
- 点页面末尾的 Select。
- 选择一个帐户类型,例如 Standard SSD。
- 点 Review + Create,然后点 Create。等待几分钟,以便创建镜像。
要启动虚拟机,请按照以下步骤执行:
- 点 Go to resource。
- 从标题的菜单栏中,单击 + Create VM。
- 输入虚拟机的名称。
- 完成 Size 和 Administrator account 部分。
点 Review + Create,然后点 Create。您可以查看部署进度。
部署完成后,单击虚拟机名称,以检索使用 SSH 连接的实例的公用 IP 地址。
- 打开一个终端,以创建连接到虚拟机的 SSH 连接。
11.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
流程
-
导航到您下载
.vmdk
镜像的目录。 按照以下步骤在 vSphere 上启动镜像:
将
.vmdk
镜像导入到 vSphere :$ govc import.vmdk ./composer-api.vmdk foldername
在 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
打开虚拟机:
govc vm.power -on vmname
检索虚拟机 IP 地址:
HOST=$(govc vm.ip vmname)
使用您在蓝图中指定的用户名和密码,使用 SSH 登录到虚拟机:
$ ssh admin@HOST
注意如果您使用
govc datastore.upload
命令将.vmdk
镜像从本地主机复制到目的地,则不支持使用该镜像。在 vSphere GUI 中没有选项来使用import.vmdk
命令,因此 vSphere GUI 不支持直接上传,因此.vmdk
镜像无法直接从 vSphere GUI 使用。
11.8. 使用镜像构建器将镜像上传到 GCP
使用镜像构建器,您可以构建 gce
镜像,为用户或 GCP 服务帐户提供凭证,然后将 gce
镜像直接上传到 GCP 环境。
11.8.1. 使用 CLI 将 gce 镜像上传到 GCP
按照以下步骤使用凭证设置配置文件,将 gce
镜像上传到 GCP。
先决条件
有用户或服务帐户 Google 凭证,以便将镜像上传到 GCP。与凭证关联的帐户必须至少分配以下 IAM 角色:
-
roles/storage.admin
- 用于创建和删除存储对象 -
roles/compute.storageAdmin
- 将虚拟机镜像导入到 Compute Engine。
-
- 您有一个现有的 GCP 存储桶。
流程
使用文本编辑器,创建包含以下内容的
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 进行身份验证。
-
使用附加镜像名称和云供应商配置集创建 compose:
$ sudo composer-cli compose start BLUEPRINT-NAME gce IMAGE_KEY gcp-config.toml
备注:镜像构建、上传和云注册过程最多可能需要十分钟才能完成。
验证
验证镜像状态为 FINISHED:
$ sudo composer-cli compose status
11.8.2. 使用 GCP 进行身份验证
您可以在镜像构建器中使用几种不同类型的凭证来使用 GCP 进行身份验证。如果将镜像构建器配置被设置为使用多个凭证通过 GCP 进行身份验证,它会按以下首选顺序使用凭证:
-
在配置文件中,使用
composer-cli
命令指定的凭证。 -
凭证在
osbuild-composer
worker 配置中被配置。 Google GCP SDK
库中的应用程序默认凭证,它尝试使用以下选项自动找到身份验证的方法:- 如果设置了 GOOGLE_APPLICATION_CREDENTIALS 环境变量,应用程序默认凭据会尝试加载并从文件中使用由变量指向的凭证。
应用默认凭据尝试使用附加到运行代码的资源的服务帐户进行身份验证。例如,Google Compute Engine 虚拟机。
注意您必须使用 GCP 凭证来决定将镜像上传到的 GCP 项目。因此,除非要将所有镜像上传到同一 GCP 项目,您必须使用
composer-cli
命令指定gcp-config.toml
配置文件中的凭证。
11.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}"
11.8.2.2. 在 osbuild-composer worker 配置中指定凭证
您可以将 GCP 身份验证凭据配置为全局用于 GCP 用于所有镜像构建。这样,如果您想要将镜像导入到同一 GCP 项目,则所有镜像都可以使用相同的凭证来上传到 GCP。
流程
在
/etc/osbuild-worker/osbuild-worker.toml
worker 配置中,设置以下凭证值:[gcp] credentials = "PATH_TO_GCP_ACCOUNT_CREDENTIALS"
11.9. 使用 GUI 镜像构建器工具将 VMDK 镜像推送到 vSphere
您可以使用 GUI 镜像构建器工具构建 VMware 镜像,并将镜像直接推送到 vSphere 实例,以避免下载镜像文件并手动推送它。要使用镜像构建器直接为 vSphere 实例服务提供商创建 .vmdk
镜像,请按照以下步骤执行:
先决条件
-
您有可以访问系统的
root
或wheel
组用户权限。 - 您已在浏览器中打开了 RHEL web 控制台的 https://localhost:9090/ 界面。
- 您已创建了蓝图。请参阅在 web 控制台界面中创建镜像构建程序蓝图。
- 您有 vSphere 帐户。
流程
- 对于您创建的蓝图,点 Images 选项卡。
点 Create Image 创建自定义镜像。
此时将打开镜像类型窗口。
在 Image type 窗口中:
- 从下拉菜单中选择 Type: VMware vSphere (.vmdk)。
- 选中 Upload to VMware 复选框,来将镜像上传到 vSphere。
- 可选:设置您要实例化的镜像的大小。最小的默认大小为 2GB。
- 点击 Next。
在 Upload to VMware 窗口中,在 Authentication 下输入以下详情:
- Username :vSphere 帐户的用户名。
- Password :vSphere 帐户的密码。
在 Upload to VMware 窗口中,在 Destination 下输入以下详情:
- Image name:要上传的镜像的名称。
- Host :镜像将要上传到的 VMware vSphere 的 URL。
- Cluster :镜像将要上传到的集群的名称。
- Data center :镜像将要上传到的数据中心的名称。
- Data store :镜像将要上传到的数据存储的名称。
- 点 Next。
在 Review 窗口中,查看镜像创建的详情并点 Finish。
您可以点击 Back 来修改任何不正确的详情。
镜像构建器将 RHEL vSphere 镜像的组成添加到队列中,创建镜像并将其上传到您指定的 vSphere 实例的集群上。
注意镜像构建和上传过程需要几分钟时间才能完成。
完成这个过程后,您可以看到 镜像构建完成状态。
验证
成功完成镜像上传后,您可以从上传的镜像创建虚拟机(VM),并登录到虚拟机。要做到这一点:
- 访问 VMware vSphere 客户端。
- 在您指定的 vSphere 实例上的集群中搜索镜像。
您可以从上传的镜像创建一个新虚拟机:
- 选择您上传的镜像。
- 右键点所选镜像。
点
New Virtual Machine
。此时 New Virtual Machine 窗口打开。
New Virtual Machine 窗口中提供了以下详情:
-
选择
New Virtual Machine
。 - 为您的虚拟机选择一个名称和文件夹。
- 选择计算资源:为此操作选择一个目标计算资源。
- 选择存储: 例如,选择 NFS-Node1
- 选择兼容性:镜像应仅限于 BIOS。
- 选择一个客户机操作系统:例如,选择 Linux 和 Red Hat Fedora (64 位)。
- 自定义硬件 :创建虚拟机时,在右上角的 Device Configuration按钮,删除默认的 New Hard Disk,并使用下拉菜单来选择 Existing Hard Disk 磁盘镜像:
- 准备完成:查看详情并点击 Finish 来创建镜像。
-
选择
导航至 VMs 选项卡。
- 从列表中选择您创建的虚拟机。
- 单击面板上的 Start 按钮。此时会显示一个新窗口,显示正在加载 VM 镜像。
- 使用您为蓝图创建的凭证登录。
您可以验证添加到蓝图中的软件包是否已安装。例如:
$ rpm -qa | grep firefox
其他资源
11.10. 将自定义镜像推送到 OCI
使用镜像构建器,您可以构建自定义镜像,并将它们直接推送到 Oracle Cloud Infrastructure (OCI)实例。然后,您可以从 OCI 仪表盘中启动镜像实例。
先决条件
-
您有可以访问系统的
root
或wheel
组用户权限。 - 您有一个 Oracle Cloud 帐户。
- 您必须为管理员授予 OCI 策略中的安全访问权限。
-
您已在您选择的
OCI_REGION
中创建了 OCI Bucket。
流程
- 在浏览器中打开 Web 控制台的镜像构建器界面。
- 点击 Create blueprint。Create blueprint 向导将打开。
- 在 Details 页面中,输入蓝图的名称,以及可选的描述。点击 Next。
- 在 Packages 页面中,选择要在镜像中包含的组件和软件包。点击 Next。
- 在 Customizations 页面中,配置您要用于蓝图的自定义。点击 Next。
- 在 Review 页面上,点 Create。
- 要创建镜像,请单击 Create Image。Create image 向导将打开。
在 Image 输出页面中完成以下步骤:
- 在 "Select a blueprint" 下拉菜单中选择您想要的蓝图。
-
从 "Image output type" 下拉菜单中选择
Oracle Cloud Infrastructure (.qcow2)
。 - 选中 "Upload OCI 复选框,将镜像上传到 OCI。
- 输入 "镜像大小 "。点击 Next。
在 Upload to OCI - Authentication 页面中,输入以下强制详情:
- 用户 OCID:您可以在显示用户详情的页面的控制台中找到它。
- 私钥
在 Upload to OCI - Destination 页面中,输入以下强制详情并点 Next。
- 镜像名称:要上传的镜像的名称。
- OCI 存储桶
- bucket 命名空间
- bucket 区域
- bucket 划分
- bucket 租户
- 查看向导中的详情并点 Finish。
镜像构建器将 RHEL .qcow2
镜像的组合添加到队列中。
验证
- 访问 OCI 仪表板 → Custom Images。
-
选择您为镜像指定的
Compartment
,并在 Import image 表中找到镜像。 - 点镜像名称并验证镜像信息。
11.11. 将 QCOW2 镜像上传到 OpenStack
使用镜像构建器工具,您可以创建适合上传到 OpenStack 云部署的自定义 .qcow2
镜像,并在那里启动实例。
不要将您使用镜像构建器创建的通用 QCOW2
命令类型输出格式与 OpenStack 镜像类型的相混淆,后者虽然也是 QCOW2 格式,但包含了针对 OpenStack 的进一步更改。
先决条件
- 您已创建了蓝图。
-
使用镜像构建器创建一个
QCOW2
镜像。查看
流程
启动
QCOW2
镜像的 compose。# composer-cli compose start blueprint_name openstack
检查构建的状态。
# composer-cli compose status
镜像构建完成后,您可以下载镜像。
下载
QCOW2
镜像:# composer-cli compose image UUID
- 访问 OpenStack 仪表板,再单击 +Create Image。
在左侧菜单中,选择
Admin
选项卡。从
系统面板
中,点镜像
。Create An Image
向导将打开。
在
Create An Image
向导中:- 输入镜像的名称
-
点
Browse
,上传QCOW2
镜像。 -
从
格式
下拉列表中,选择QCOW2 - QEMU Emulator
。 点 Create Image。
在左侧菜单中,选择
Project
选项卡。-
从
Compute
菜单中,选择Instances
。 点
启动实例
按钮。此时会打开
Launch Instance
向导。-
在
Details
页面中,输入实例的名称。点击 Next。 -
在
Source
页面中,选择您上传的镜像的名称。点击 Next。 在
Flavor
页面中,选择最适合您的需要的机器资源。点Launch
。
-
从
-
您可以使用任何机制(CLI 或 OpenStack Web UI)来从镜像运行镜像实例。通过 SSH 使用您的私钥访问生成的实例。以
cloud-user
用户身份登录。
11.12. 准备将自定义 RHEL 镜像上传到 Alibaba
要将自定义 RHEL 镜像部署到 Alibaba Cloud
,首先需要验证自定义镜像。镜像需要特定的配置才能成功引导,因为 Alibaba Cloud 在使用前需要自定义镜像来满足某些要求。
镜像构建器生成符合 Alibaba 要求的镜像。但是,红帽建议使用 Alibaba image_check 工具来验证镜像的格式合规性。
先决条件
- 您必须使用镜像构建器创建 Alibaba 镜像。
流程
- 使用 Alibaba image_check 工具连接到含您要检查的镜像的系统。
下载 image_check 工具:
$ curl -O http://docs-aliyun.cn-hangzhou.oss.aliyun-inc.com/assets/attach/73848/cn_zh/1557459863884/image_check
更改镜像合规工具的文件权限:
# chmod +x image_check
运行命令启动镜像合规工具检查:
# ./image_check
该工具会验证系统配置,并生成在屏幕上显示的报告。image_check 工具会在运行镜像合规工具的同一目录中保存此报告。
故障排除
如果任何检测项失败,请按照终端中的说明进行更正。请参阅链接:Detection items 部分。
其他资源
11.13. 将自定义 RHEL 镜像上传到 Alibaba
您可以使用镜像构建器将您创建的自定义 AMI
镜像上传到对象存储服务 (OSS)。
先决条件
- 设置您的系统以上传 Alibaba 镜像。请参阅准备将镜像上传到 Alibaba。
-
已使用镜像构建器创建了
ami
镜像。 - 您有一个存储桶。请参阅创建存储桶。
- 您有一个活跃的 Alibaba 帐户。
- 已激活了 OSS。
流程
- 登录到 OSS 控制台。
- 在左侧的 Bucket 菜单中,选择要向其上传镜像的存储桶。
- 在右菜单中点 Files 标签页。
点 Upload。一个对话框窗口会在右侧打开。配置以下内容:
- Upload To:选择将文件上传到 Current 目录或一个指定的目录。
- 文件 ACL:选择上传的文件的权限类型。
- 点 Upload。
- 选择您要上传的镜像。
- 点击 Open。
因此,自定义的 AMI
镜像会上传到 OSS 控制台。
其他资源
11.14. 将镜像导入到 Alibaba
要将使用镜像构建器创建的自定义 Alibaba RHEL 镜像导入到 Elastic Cloud Console (ECS),请按照以下步骤执行:
先决条件
- 设置您的系统以上传 Alibaba 镜像。请参阅准备将镜像上传到 Alibaba。
-
已使用镜像构建器创建了
ami
镜像。 - 您有一个存储桶。请参阅创建存储桶。
- 您有一个活跃的 Alibaba 帐户。
- 已激活了 OSS。
- 您已将镜像上传到对象存储服务(OSS)。请参阅将镜像上传到 Alibaba。
流程
登录到 ECS 控制台。
- 在左侧菜单中,点 Images。
- 在右上角,点 Import Image。此时会打开一个对话框窗口。
确认您已设置了镜像所在的正确区域。输入以下信息:
-
OSS 对象地址
:了解如何获取 OSS 对象地址。 -
镜像名称
-
操作系统
-
系统磁盘大小
-
系统架构
-
Platform
: Red Hat
-
另外,还可提供以下详情:
-
镜像格式
:qcow2
或ami
,具体取决于上传的镜像格式。 -
镜像描述
添加数据磁盘的镜像
地址可以在 OSS 管理控制台中确定。在左侧菜单中选择所需的存储桶之后:
-
-
选择
Files
部分。 点相应镜像右侧的 Details 链接。
窗口会出现在屏幕右侧,显示镜像详情。
OSS
对象地址位于URL
框中。点击 OK。
注意导入过程的时间可能因镜像大小而异。
自定义镜像导入到 ECS
控制台。
其他资源
11.15. 使用 Alibaba 创建自定义 RHEL 镜像实例
您可以使用 Alibaba ECS 控制台
创建自定义 RHEL 镜像的实例。
先决条件
- 您已激活了 OSS 并上传您的自定义镜像。
- 您已成功将镜像导入到 ECS 控制台。请参阅 将镜像导入到 Alibaba。
流程
因此,您有一个活跃的实例准备好从 Alibaba ECS 控制台进行部署
。