流程

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-composer 和 cockpit 服务在第一次访问时自动启动。

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

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

流程

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

流程

1. 创建存储库源文件：

   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

2. 以 TOML 格式保存文件。

3. 使用以下命令添加新的第三方源：

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

流程

1. 创建存储库源文件：

   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/"

2. 以 TOML 格式保存文件。

流程

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

   $ cd repo/

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

   $ createrepo_c .

3. 访问 repodata 所在的目录：

   $ cd repodata/

4. 通过签名 repomd.xml 文件来设置存储库：

   $ gpg -u YOUR-GPG-KEY-EMAIL --yes --detach-sign --armor repomd.xml

5. 检查 GPG 签名。

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

   2. 如果您的密钥可以通过 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"]

   3. 可选：您可以将整个密钥嵌入到 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"]

流程

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

流程

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 源则用于所有其他存储库。

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

流程

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

   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 替换为一个版本号。

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

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

   使用软件包名称替换 package-name，比如 httpd、gdb-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 命令创建镜像，请将您的用户添加到 weldr 或 root 组中。

   # usermod -a -G weldr user
   $ newgrp weldr

流程

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

流程

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。

流程

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

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

2. 以 root 用户身份登录 Web 控制台。

3. 要显示镜像构建器控制，请单击窗口左上角的 镜像构建器 图标。

   镜像构建器仪表盘会打开，列出现有的蓝图（若有的话）。

流程

1. 点右上角的 Create Blueprint。

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

2. 在 Details 页面中：

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

3. 可选：在 Packages 页面中：

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

      注意

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

4. 在 Kernel 页面中，输入内核名称和命令行参数。

5. 在 File system 页面中，您可以对镜像文件系统选择 Use automatic partitioning 或 Manually configure partitions 。要手动配置分区，请完成以下步骤：

   1. 点 Manually configure partitions 按钮。

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

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

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

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

         • /usr/local

           您还可以向 Mount point 添加额外的路径，如 /tmp。例如：/var 作为前缀，/tmp 作为附加路径会产生 /var/tmp。

           注意

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

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

         注意

         Minimum size 意味着镜像构建器在分区太小以致不能创建工作镜像的情况下，仍然可以增加分区大小。

   3. 要添加更多分区，请点击 Add partition 按钮。如果您看到以下出错信息："Duplicate partitions: Only one partition at each mount point can be created.”，您可以：

      1. 点 Remove 按钮删除重复的分区。
      2. 为您要创建的分区选择一个新的挂载点。
   4. 完成分区配置后，点 Next。

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

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

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

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

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

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

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

   1. 点 Add groups 按钮：

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

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

    1. 点 Add key 按钮。

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

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

    1. 在 Timezone 字段中输入您要添加到系统镜像的时区。例如，添加以下时区格式："US/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 device onboardin 页面上，完成以下步骤：

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

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

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

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

16. 仅在构建 Ignition 镜像时必需：在 Ignition 页面上，完成以下步骤：

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

流程

1. 在镜像构建器仪表盘上，单击 Import blueprint。此时会打开 Import blueprint 向导。
2. 在 Upload 字段中，拖放或上传现有的蓝图。此蓝图可以是 TOML 或 JSON 格式。

3. 点 Import。仪表盘列出了您导入的蓝图。

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

流程

1. 在镜像构建器仪表盘上，选择您要导出的蓝图。
2. 点 Export blueprint。此时会打开 Export blueprint 向导。

3. 要保存 导出的蓝图，请点击 Export 按钮。

   1. （可选）点击 Copy 按钮来复制蓝图。

验证

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

流程

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

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

   1. 从 Select a blueprint 列表中，选择您想要的镜像类型。

   2. 从 Image output type 列表中，选择您想要的镜像输出类型。

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

6. 点击 Next。

7. 在 Review 页面上，查看关于镜像创建的详情，并点 Create image。

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

流程

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

流程

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

3. 在蓝图的右侧，点对应的 Create Image 按钮。

   Create image 对话框向导将打开。

4. 在 Create image 对话框向导中：

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

1. 点 Download 将 "RHEL Installer (.iso) " 镜像保存到您的系统中。
2. 进入您下载 "RHEL Installer(.iso)" 镜像的文件夹。
3. 找到您下载的 .tar 镜像。

4. 提取 "RHEL 安装程序(.iso)" 镜像内容。

   $ tar -xf content.tar

流程

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 安装。

流程

1. 在您的系统上安装 OpenSCAP：

   # *yum install openscap-scanner*

2. 安装 scap-security-guide 软件包：

   # *yum install scap-security-guide*

   安装完成后，您可以使用 oscap 命令行工具开始。SCAP 内容将安装在 /usr/share/xml/scap/ssg/content/ 目录中。

流程

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。

流程

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

验证

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

流程

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-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)

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 访问虚拟机。

流程

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 值以构建您要嵌入容器的镜像。

流程

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 软件包路径。

流程

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

流程

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

   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 的虚拟机镜像的名称。

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。

流程

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 连接到实例后您是否能够执行任何操作。

流程

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 替换为存储帐户的名称。

验证

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 用户身份登录。

流程

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. 您的 存储帐户 名称。您可以在 Microsoft Azure 门户中 中的 Storage account 页面上找到它。
      2. 您的 存储访问密钥 ：您可以在 Access Key 存储页面上找到它。
      3. 点击 Next。

   2. 在 Authentication 页面上，输入：

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

后续步骤

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

1. 在搜索栏中，输入镜像帐户，并单击列表中的 Images。
2. 单击 +Create。
3. 从下拉列表中，选择您之前使用的资源组。
4. 输入镜像的名称。
5. 对于 OS type，请选择 Linux。
6. 对于 VM generation，请选择 Gen 2。
7. 在 Storage Blob 下，点 Browse ，并点存储账户和容器，直到您到达 VHD 文件。
8. 点页面末尾的 Select。
9. 选择一个帐户类型，例如 Standard SSD。
10. 点 Review + Create，然后点 Create。等待几分钟，以便创建镜像。

1. 点 Go to resource。
2. 从标题的菜单栏中，单击 + Create VM。
3. 输入虚拟机的名称。
4. 完成 Size 和 Administrator account 部分。

5. 点 Review + Create，然后点 Create。您可以查看部署进度。

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

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

流程

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 使用。

流程

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. Username ：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 实例的集群上。

   注意

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

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

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. 选择一个客户机操作系统：例如，选择 Linux 和 Red 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

流程

1. 在浏览器中打开 Web 控制台的镜像构建器界面。
2. 点击 Create blueprint。Create blueprint 向导将打开。
3. 在 Details 页面中，输入蓝图的名称，以及可选的描述。点击 Next。
4. 在 Packages 页面中，选择要在镜像中包含的组件和软件包。点击 Next。
5. 在 Customizations 页面中，配置您要用于蓝图的自定义。点击 Next。
6. 在 Review 页面上，点 Create。
7. 要创建镜像，请单击 Create Image。Create image 向导将打开。

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

   1. 在 "Select a blueprint" 下拉菜单中选择您想要的蓝图。
   2. 从 "Image output type" 下拉菜单中选择 Oracle Cloud Infrastructure (.qcow2) 。
   3. 选中 "Upload OCI 复选框，将镜像上传到 OCI。
   4. 输入 "镜像大小 "。点击 Next。

9. 在 Upload to OCI - Authentication 页面中，输入以下强制详情：

   1. 用户 OCID：您可以在显示用户详情的页面的控制台中找到它。
   2. 私钥

10. 在 Upload to OCI - Destination 页面中，输入以下强制详情并点 Next。

    1. 镜像名称：要上传的镜像的名称。
    2. OCI 存储桶
    3. bucket 命名空间
    4. bucket 区域
    5. bucket 划分
    6. bucket 租户
11. 查看向导中的详情并点 Finish。

验证

1. 访问 OCI 仪表板 → Custom Images。
2. 选择您为镜像指定的 Compartment，并在 Import image 表中找到镜像。
3. 点镜像名称并验证镜像信息。

流程

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。

      

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

   1. 从 Compute 菜单中，选择 Instances。

   2. 点启动实例按钮。

      此时会打开 Launch Instance 向导。

   3. 在 Details 页面中，输入实例的名称。点击 Next。
   4. 在 Source 页面中，选择您上传的镜像的名称。点击 Next。

   5. 在 Flavor 页面中，选择最适合您的需要的机器资源。点 Launch。

      

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

流程

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 工具会在运行镜像合规工具的同一目录中保存此报告。

流程

1. 登录到 OSS 控制台。
2. 在左侧的 Bucket 菜单中，选择要向其上传镜像的存储桶。
3. 在右菜单中点 Files 标签页。

4. 点 Upload。一个对话框窗口会在右侧打开。配置以下内容：

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

流程

1. 登录到 ECS 控制台。

   1. 在左侧菜单中，点 Images。
   2. 在右上角，点 Import Image。此时会打开一个对话框窗口。

   3. 确认您已设置了镜像所在的正确区域。输入以下信息：

      1. OSS 对象地址 ：了解如何获取 OSS 对象地址。
      2. 镜像名称
      3. 操作系统
      4. 系统磁盘大小
      5. 系统架构
      6. Platform: Red Hat

   4. 另外,还可提供以下详情：

      7. 镜像格式:qcow2 或 ami，具体取决于上传的镜像格式。
      8. 镜像描述

      9. 添加数据磁盘的镜像

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

2. 选择 Files 部分。

3. 点相应镜像右侧的 Details 链接。

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

4. 点击 OK。

   注意

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

流程

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

5. 点 Create Instance 并确认顺序。

   注意

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