使用 RHEL 的镜像模式构建、部署和管理操作系统

流程

1. 创建 Containerfile ：

   $ cat Containerfile
   FROM registry.redhat.io/rhel9/rhel-bootc:latest
   RUN dnf -y install cloud-init && \
       ln -s ../cloud-init.target /usr/lib/systemd/system/default.target.wants && \
       dnf clean all

   这个 Containerfile 示例添加了 cloud-init 工具，因此它可以自动获取 SSH 密钥，并运行基础设施中的脚本，也可以从实例元数据中收集配置和 secret。例如，您可以将此容器镜像用于预生成的 AWS 或 KVM 客户机操作系统。

2. 使用当前目录中的 Containerfile 构建 <image> 镜像：

   $ podman build -t quay.io/<namespace>/<image>:<tag> .

1. 获取新的基础镜像。
2. 读取新的基础镜像 root 文件系统，以发现逻辑上绑定的镜像。
3. 将任何发现的、逻辑绑定的镜像拉取到 bootc-owned /usr/lib/bootc/storage 中。

流程

1. 创建 Containerfile ：

   $ cat Containerfile
   FROM quay.io/<namespace>/<image>:latest
   COPY ./<app_1>.image /usr/share/containers/systemd/<app_1>.image
   COPY ./<app_2>.container /usr/share/containers/systemd/<app_2>.container
   
   RUN ln -s /usr/share/containers/systemd/<app_1>.image /usr/lib/bootc/bound-images.d/<app_1>_image && \ ln -s /usr/share/containers/systemd/<app_2>_.image /usr/lib/bootc/bound-images.d/my-app.image

2. 在 .container 定义中，使用：

   GlobalArgs=--storage-opt=additionalimagestore=/usr/lib/bootc/storage

   在这个 Containerfile 示例中，通过在 /usr/lib/bootc/bound-images.d 目录中创建一个指向 .image 或 .container 文件的符号链接，选择镜像以逻辑方式绑定。

   创建符号链接后，您可以使用 引导升级或 bootc 开关。新 bootc 镜像中定义的绑定镜像会自动拉取到 bootc 镜像存储中，并可用于 Podman 等容器运行时。

3. 使用以下命令，明确将镜像配置为指向 bootc 存储作为额外镜像存储：

   podman --storage-opt=additionalimagestore=/usr/lib/bootc/storage run <image>

流程

1. 登录以认证到 registry.redhat.io ：

   $ sudo podman login registry.redhat.io

2. 安装 bootc-image-builder 工具：

   $ sudo podman pull registry.redhat.io/rhel9/bootc-image-builder

流程

1. 可选：创建一个 config.toml 来配置用户访问，例如：

   [[customizations.user]]
   name = "user"
   password = "pass"
   key = "ssh-rsa AAA ... user@email.com"
   groups = ["wheel"]

2. 运行 bootc-image-builder。另外，如果您想要使用用户访问配置，请将 config.toml 作为参数传递。

   注意

   如果您没有容器存储挂载和 本地镜像 选项，则您的镜像必须是公共镜像。

   1. 以下是创建公共 QCOW2 镜像的示例：

      $ sudo podman run \
          --rm \
          -it \
          --privileged \
          --pull=newer \
          --security-opt label=type:unconfined_t \
          -v ./config.toml:/config.toml \
          -v ./output:/output \
          registry.redhat.io/rhel9/bootc-image-builder:latest \
          --type qcow2 \
          --config /config.toml \
        quay.io/<namespace>/<image>:<tag>

   2. 以下是创建私有 QCOW2 镜像的示例：

      $ sudo podman run \
          --rm \
          -it \
          --privileged \
          --pull=newer \
          --security-opt label=type:unconfined_t \
          -v $(pwd)/config.toml:/config.toml:ro \
          -v $(pwd)/output:/output \
          -v /var/lib/containers/storage:/var/lib/containers/storage \
          registry.redhat.io/rhel9/bootc-image-builder:latest \
          --local
          --type qcow2 \
          quay.io/<namespace>/<image>:<tag>

      您可以在 output 文件夹中找到 .qcow2 镜像。

流程

1. 使用以下内容创建一个 Containerfile ：

   FROM registry.redhat.io/rhel9/rhel-bootc:9.4
   RUN dnf -y install cloud-init open-vm-tools && \
   ln -s ../cloud-init.target /usr/lib/systemd/system/default.target.wants && \
   rm -rf /var/{cache,log} /var/lib/{dnf,rhsm} && \
   systemctl enable vmtoolsd.service

2. 构建 bootc 镜像：

   # podman build . -t localhost/rhel-bootc-vmdk

3. 从之前创建的 bootc 镜像创建 VMDK 文件：

   # podman run \
   --rm \
   -it \
   --privileged \
   -v /var/lib/containers/storage:/var/lib/containers/storage \
   -v ./output:/output \
   --security-opt label=type:unconfined_t \
   --pull newer \
   registry.redhat.io/rhel9/bootc-image-builder:9.4
   --local \
   --type vmdk \
   localhost/rhel-bootc-vmdk:latest

   --local 选项使用本地容器存储来源原始镜像来生成 VMDK，而不是远程存储库。

流程

1. 可选：创建一个 config.toml 来配置用户访问，例如：

   [[customizations.user]]
   name = "user"
   password = "pass"
   key = "ssh-rsa AAA ... user@email.com"
   groups = ["wheel"]

2. 运行 bootc-image-builder。另外，如果您想要使用用户访问配置，请将 config.toml 作为参数传递。

   注意

   如果您没有容器存储挂载和 本地镜像 选项，则您的镜像必须是公共镜像。

   1. 以下是创建 gce 镜像的示例：

      $ sudo podman run \
          --rm \
          -it \
          --privileged \
          --pull=newer \
          --security-opt label=type:unconfined_t \
          -v ./config.toml:/config.toml \
          -v ./output:/output \
          registry.redhat.io/rhel9/bootc-image-builder:latest \
          --type gce \
          --config /config.toml \
        quay.io/<namespace>/<image>:<tag>

      您可以在输出文件夹中找到 gce 镜像。

流程

1. 从 bootc 镜像创建磁盘镜像。

   • 在 Containerfile 中配置用户详情。确保为它分配了 sudo 访问权限。
   • 使用 Containerfile 配置中的用户构建一个自定义操作系统镜像。它会创建一个具有无密码 sudo 访问权限的默认用户。

2. 可选：使用 cloud-init 配置机器镜像。请参阅 用户和组配置 - 使用 cloud-init 注入用户和 SSH 密钥。以下是一个示例：

   FROM registry.redhat.io/rhel9/rhel-bootc:9.4
   
   RUN dnf -y install cloud-init && \
       ln -s ../cloud-init.target /usr/lib/systemd/system/default.target.wants && \
       rm -rf /var/{cache,log} /var/lib/{dnf,rhsm}

   注意

   您还可以使用 cloud-init ，使用实例元数据添加用户和其他配置。

3. 构建 bootc 镜像。例如，要将镜像部署到 x86_64 AWS 机器，请使用以下命令：

   $ podman build -t quay.io/<namespace>/<image>:<tag> .
   $ podman push quay.io/<namespace>/<image>:<tag> .

4. 使用 bootc-image-builder 工具从 bootc 容器镜像创建一个 AMI。

   $ sudo podman run \
     --rm \
     -it \
     --privileged \
     --pull=newer \
     -v $HOME/.aws:/root/.aws:ro \
     --env AWS_PROFILE=default \
     registry.redhat.io/rhel9/bootc-image-builder:latest \
     --type ami \
     --aws-ami-name rhel-bootc-x86 \
     --aws-bucket rhel-bootc-bucket \
     --aws-region us-east-1 \
   quay.io/<namespace>/<image>:<tag>

   注意

   以下标记必须一起指定。如果没有指定任何标记，AMI 被导出到 output 目录中。

   • --AWS-ami-name - AWS 中 AMI 镜像的名称
   • --AWS-bucket - 创建 AMI 时中间存储的目标 S3 存储桶名称

   • --AWS-region - 用于AWS 上传的目标区域

     bootc-image-builder 工具构建一个 AMI 镜像，并使用 AWS 凭证将其上传到 AWS s3 存储桶，以便在构建后推送并注册一个 AMI 镜像。

流程

1. 可选：创建一个 config.toml 来配置用户访问，例如：

   [[customizations.user]]
   name = "user"
   password = "pass"
   key = "ssh-rsa AAA ... user@email.com"
   groups = ["wheel"]

2. 运行 bootc-image-builder。如果要使用用户访问配置，请将 config.toml 作为参数传递：

   $ sudo podman run \
       --rm \
       -it \
       --privileged \
       --pull=newer \
       --security-opt label=type:unconfined_t \
       -v /var/lib/containers/storage:/var/lib/containers/storage \
       -v ./config.toml:/config.toml \
       -v ./output:/output \
       registry.redhat.io/rhel9/bootc-image-builder:latest \
       --local \
       --type raw \
       --config /config.toml \
     quay.io/<namespace>/<image>:<tag>

   您可以在 output 文件夹中找到 .raw 镜像。

流程

1. 可选：创建一个 config.toml 来配置用户访问，例如：

   [[customizations.user]]
   name = "user"
   password = "pass"
   key = "ssh-rsa AAA ... user@email.com"
   groups = ["wheel"]

2. 运行 bootc-image-builder。如果您不想添加任何配置，请省略 the -v $(pwd)/config.toml:/config.toml 参数。

   $ sudo podman run \
       --rm \
       -it \
       --privileged \
       --pull=newer \
       --security-opt label=type:unconfined_t \
       -v /var/lib/containers/storage:/var/lib/containers/storage \
       -v $(pwd)/config.toml:/config.toml \
       -v $(pwd)/output:/output \
       registry.redhat.io/rhel9/bootc-image-builder:latest \
       --type iso \
       --config /config.toml \
     quay.io/<namespace>/<image>:<tag>

   您可以在 output 文件夹中找到 .iso 镜像。

流程

1. 创建 Kickstart 文件。以下 Kickstart 文件是一个完全无人值守的 Kickstart 文件配置示例，其中包含用户创建和分区说明。

   [customizations.installer.kickstart]
   contents = """
   lang en_GB.UTF-8
   keyboard uk
   timezone CET
   
   user --name <user> --password <password> --plaintext --groups <groups>
   sshkey --username <user> ssh-<type> <public key>
   rootpw --lock
   
   zerombr
   clearpart --all --initlabel
   autopart --type=plain
   reboot --eject
   """

2. 以 toml 格式保存 Kickstart 配置，以注入 Kickstart 内容。例如，config.toml。

3. 运行 bootc-image-builder，并包含您要添加到 ISO 构建的 Kickstart 文件配置。bootc-image-builder 会自动添加安装 容器镜像的 ostree container 命令。

   $ sudo podman run \
       --rm \
       -it \
       --privileged \
       --pull=newer \
       --security-opt label=type:unconfined_t \
       -v /var/lib/containers/storage:/var/lib/containers/storage \
       -v $(pwd)/config.toml:/config.toml \
       -v $(pwd)/output:/output \
       registry.redhat.io/rhel9/bootc-image-builder:latest \
       --type iso \
       --config /config.toml \
     quay.io/<namespace>/<image>:<tag>

   您可以在 output 文件夹中找到 .iso 镜像。

流程

1. 创建 Containerfile ：

   FROM <internal_repository>/<image>
   RUN  mkdir -p /etc/pki/ca-trust/extracted/pem/
   COPY tls-ca-bundle.pem /etc/pki/ca-trust/extracted/pem/
   RUN  rm -rf /etc/yum.repos.d/*
   COPY echo-rhel9_4.repo /etc/yum.repos.d/

2. 构建自定义镜像：

   # podman build -t <your_image> .

3. 运行 &lt ;your_image>:

   # podman run -it --rm <your_image>

流程

1. 在浏览器中，访问 Service→EC2 并登录。
2. 在 AWS 控制台仪表盘菜单中，选择正确的地区。镜像必须具有 Available 状态，以表示它已被正确上传。
3. 在 AWS 仪表盘上，选择您的镜像并点 Launch。
4. 在打开的新窗口中，根据您要启动镜像所需的资源来选择一个实例类型。点击 Review and Launch。
5. 查看您的实例详情。如果需要进行任何更改，您可以编辑任何部分。点 Launch。
6. 在启动实例之前，选择一个访问它的公钥。您可以使用您已有的密钥对，也可以创建一个新的密钥对。

7. 点 Launch Instance 来启动您的实例。您可以检查实例的状态，它显示为 Initializing。

   实例状态变为 Running 后，Connect 按钮变为可用。

8. 点 Connect。此时会出现一个窗口，其中包含有关如何使用 SSH 进行连接的说明。

9. 运行以下命令来设置私钥文件的权限，以便只有您可以读取它。请参阅 连接到您的 Linux 实例。

   $ chmod 400 <your-instance-name.pem>

10. 使用其公共 DNS 连接到您的实例：

    $ ssh -i <your-instance-name.pem>ec2-user@<your-instance-IP-address>

流程

1. 创建一个 ostreecontainer Kickstart 文件。例如：

   # Basic setup
   text
   network --bootproto=dhcp --device=link --activate
   # Basic partitioning
   clearpart --all --initlabel --disklabel=gpt
   reqpart --add-boot
   part / --grow --fstype xfs
   
   # Reference the container image to install - The kickstart
   # has no %packages section. A container image is being installed.
   ostreecontainer --url registry.redhat.io/rhel9/rhel-bootc:9.4
   
   firewall --disabled
   services --enabled=sshd
   
   # Only inject a SSH key for root
   rootpw --iscrypted locked
   sshkey --username root "<your key here>"
   reboot

2. 使用 9.4 Boot ISO 安装介质引导系统。

   1. 将具有以下内容的 Kickstart 文件附加到内核参数中：

      inst.ks=http://<path_to_your_kickstart>

3. 按 CTRL+X 引导系统。

流程

1. 将您的 ISO 磁盘镜像复制到 USB 闪存驱动器中。
2. 使用 USB 盘中的内容在断开连接的环境中执行裸机安装。

流程

1. 将 RHEL 安装 ISO 镜像导出到 HTTP 服务器中。PXE 引导服务器现在可以提供 PXE 客户端。
2. 引导客户端并开始安装。
3. 当提示指定引导源时选择 PXE 引导。如果没有显示引导选项，请按键盘上的 Enter 键，或等待引导窗口打开。
4. 在 Red Hat Enterprise Linux 引导窗口中，选择您想要的引导选项，然后按 Enter 键。
5. 启动网络安装。

流程

1. 创建一个磁盘镜像。以下示例演示了如何将用户添加到磁盘镜像中。

   [[blueprint.customizations.user]]
   name = "user"
   password = "pass"
   key = "ssh-rsa AAA ... user@email.com"
   groups = ["wheel"]

   • Name - 用户名。必需
   • password - 未加密的密码。不是必需的
   • Key - SSH 公钥内容。不是必需的
   • groups - 要将用户添加到其中的组的数组。不是必需的

2. 运行 bootc-image-builder ，并传递以下参数：

   $ sudo podman run \
       --rm \
       -it \
       --privileged \
       --pull=newer \
       --security-opt label=type:unconfined_t \
       -v $(pwd)/config.toml:/config.toml \
       -v $(pwd)/output:/output \
       registry.redhat.io/rhel9/bootc-image-builder:latest \
       --type qcow2 \
       --config config.toml \
       quay.io/<namespace>/<image>:<tag>

3. 启动虚拟机，例如使用 virt-install ：

   $ sudo virt-install \
     --name bootc \
     --memory 4096 \
     --vcpus 2 \
     --disk qcow2/disk.qcow2 \
     --import \
     --os-variant rhel9

流程

1. 创建一个 01-fips.toml 来配置 FIPS 启用，例如：

   # Enable FIPS
   kargs = ["fips=1"]

2. 使用以下说明创建 Containerfile，以启用 fips=1 内核参数：

   FROM registry.redhat.io/rhel9/rhel-bootc:latest
   # Enable fips=1 kernel argument: https://containers.github.io/bootc/building/kernel-arguments.html
   COPY 01-fips.toml /usr/lib/bootc/kargs.d/
   # Enable the FIPS crypto policy
   # crypto-policies-scripts is not installed by default in RHEL-10
   RUN dnf install -y crypto-policies-scripts && update-crypto-policies --no-reload --set FIPS

3. 使用当前目录中的 Containerfile 创建 bootc & lt;image> 兼容基本磁盘镜像：

   $ podman build -t quay.io/<namespace>/<image>:<tag> .

流程

1. 创建一个 01-fips.toml 来配置 FIPS 启用，例如：

   # Enable FIPS
   kargs = ["fips=1"]

2. 使用以下说明创建 Containerfile，以启用 fips=1 内核参数：

   FROM registry.redhat.io/rhel9/rhel-bootc:latest
   # Enable fips=1 kernel argument: https://containers.github.io/bootc/building/kernel-arguments.html
   COPY 01-fips.toml /usr/lib/bootc/kargs.d/
   # Install and enable the FIPS crypto policy
   RUN dnf install -y crypto-policies-scripts && update-crypto-policies --no-reload --set FIPS

3. 使用当前目录中的 Containerfile 创建 bootc & lt;image> 兼容基本磁盘镜像：

   $ sudo podman run \
       --rm \
       -it \
       --privileged \
       --pull=newer \
       --security-opt label=type:unconfined_t \
       -v $(pwd)/config.toml:/config.toml:ro \
       -v $(pwd)/output:/output \
       -v /var/lib/containers/storage:/var/lib/containers/storage \
       registry.redhat.io/rhel9/bootc-image-builder:latest \
       --local
       --type qcow2 \
       quay.io/<namespace>/<image>:<tag>

4. 在系统安装过程中启用 FIPS 模式：

   1. 引导 RHEL Anaconda 安装程序时，在安装屏幕上，按 TAB 键并添加 fips=1 内核参数。

      安装后，系统会自动以 FIPS 模式启动。

流程

1. 编写 drop-in 配置文件。例如：

   dracutmodules = "module"

2. 将置入配置文件放在 dracut 通常使用的位置： /usr。例如：

   /usr/lib/dracut/dracut.conf.d/50-custom-added-modules.conf

3. 作为容器构建的一部分，重新生成 initrd。您必须将内核版本明确传递给 dracut，因为它会尝试拉取运行的内核版本，这会导致错误。以下是一个示例：

   FROM <baseimage>
   COPY 50-custom-added-modules.conf /usr/lib/dracut/dracut.conf.d
   RUN set -x; kver=$(cd /usr/lib/modules && echo *); dracut -vf /usr/lib/modules/$kver/initramfs.img $kver

1. 将 registry.access.redhat.com/ubi9/toolbox:latest 镜像拉取到本地系统
2. 从镜像启动容器
3. 在容器内运行 shell，您可以通过它访问主机系统

流程

1. 使用 toolbox create 命令启动 Toolbx 容器，并使用 toolbox enter 命令输入容器。

   • 以无根用户身份：

     $ toolbox create <mytoolbox>

   • 以 root 用户身份：

     $ sudo toolbox create <mytoolbox>
     Created container: <mytoolbox>
     Enter with: toolbox enter

   • 验证您是否拉取了正确的镜像：

     [user@toolbox ~]$ toolbox list
     IMAGE ID      IMAGE NAME    CREATED
     fe0ae375f149   registry.access.redhat.com/ubi{ProductVersion}/toolbox 5 weeks ago
     
     CONTAINER ID  CONTAINER NAME  CREATED         STATUS   IMAGE NAME
     5245b924c2cb  <mytoolbox>       7 minutes ago   created  registry.access.redhat.com/ubi{ProductVersion}/toolbox:8.9-6

     1. 进入 Toolbx 容器：

        [user@toolbox ~]$ toolbox enter <mytoolbox>

     2. 可选：检查是否拉取了正确的镜像

   • 在 <mytoolbox> 容器中输入命令，并显示容器和镜像的名称：

     ⬢ [user@toolbox ~]$ cat /run/.containerenv
     engine="podman-4.8.2"
     name="<mytoolbox>"
     id="5245b924c2cb..."
     image="registry.access.redhat.com/ubi{ProductVersion}/toolbox"
     imageid="fe0ae375f14919cbc0596142e3aff22a70973a36e5a165c75a86ea7ec5d8d65c"

2. 使用 Toolbx 安装开发工具：

   1. 安装您选择的工具，例如 Emacs 文本编辑器、GCC 编译器和 GNU 调试器 (GDB)：

      ⬢[user@toolbox ~]$ sudo dnf install emacs gcc gdb

   2. 可选：验证是否安装了工具：

      ⬢[user@toolbox ~]$  dnf repoquery --info --installed <package_name>

      安装后，您可以继续以无根用户身份使用这些工具。

3. 使用 Toolbx 对主机系统进行故障排除，而无需在主机系统上安装它们。

   1. 安装 systemd 套件，以便能够运行 journalctl 命令：

      ⬢[root@toolbox ~]# dnf install systemd

   2. 显示主机上运行的所有进程的日志消息：

      ⬢[root@toolbox ~]# j journalctl --boot -0
      Jan 02 09:06:48 user-thinkpadp1gen4i.brq.csb kernel: microcode: updated ear>
      Jan 02 09:06:48 user-thinkpadp1gen4i.brq.csb kernel: Linux version 6.6.8-10>
      Jan 02 09:06:48 user-thinkpadp1gen4i.brq.csb kernel: Command line: BOOT_IMA>
      Jan 02 09:06:48 user-thinkpadp1gen4i.brq.csb kernel: x86/split lock detecti>
      Jan 02 09:06:48 user-thinkpadp1gen4i.brq.csb kernel: BIOS-provided physical>

   3. 显示内核的日志消息：

      ⬢[root@toolbox ~]# journalctl --boot -0 --dmesg
      Jan 02 09:06:48 user-thinkpadp1gen4i.brq.csb kernel: microcode: updated ear>
      Jan 02 09:06:48 user-thinkpadp1gen4i.brq.csb kernel: Linux version 6.6.8-10>
      Jan 02 09:06:48 user-thinkpadp1gen4i.brq.csb kernel: Command line: BOOT_IMA>
      Jan 02 09:06:48 user-thinkpadp1gen4i.brq.csb kernel: x86/split lock detecti>
      Jan 02 09:06:48 user-thinkpadp1gen4i.brq.csb kernel: BIOS-provided physical>
      Jan 02 09:06:48 user-thinkpadp1gen4i.brq.csb kernel: BIOS-e820: [mem 0x0000>

   4. 安装 nmap 网络扫描工具：

      ⬢[root@toolbox ~]# dnf install nmap

   5. 扫描网络中的 IP 地址和端口：

      ⬢[root@toolbox ~]# nmap -sS scanme.nmap.org
      Starting Nmap 7.93 ( https://nmap.org ) at 2024-01-02 10:39 CET
      Stats: 0:01:01 elapsed; 0 hosts completed (0 up), 256 undergoing Ping Scan
      Ping Scan Timing: About 29.79% done; ETC: 10:43 (0:02:24 remaining)
      Nmap done: 256 IP addresses (0 hosts up) scanned in 206.45 seconds

      • -sS 选项执行 TCP SYN 扫描。大多数 Nmap 的扫描类型仅对特权用户提供，因为它们发送和接收原始数据包，这在 UNIX 系统上需要 root 访问权限。

4. 停止 Toolbx bootc 容器。

   1. 离开容器，并返回到主机：

      ⬢ [user@toolbox ~]$ exit

   2. 停止 toolbox 容器：

      ⬢ [user@toolbox ~]$ podman stop <mytoolbox>

   3. 可选：删除 toolbox 容器：

      ⬢ [user@toolbox ~]$ toolbox rm <mytoolbox>

      或者，您也可以使用 podman rm 命令删除 bootc 容器。

1. 使用内核参数在 /usr/lib/bootc/kargs.d 中创建文件。
2. 获取容器镜像以获取 OSTree 提交。
3. 使用 OSTree 提交返回文件树。
4. 导航到 /usr/lib/bootc/kargs.d。
5. 读取目录中每个文件。
6. 将每个 kargs 文件的内容推送到包含所有所需 kargs 的文件中。
7. 将 kargs 传递给 stage （） 函数。
8. 应用这些参数以切换、升级或编辑。

流程

1. 在 bootc 和 Podman 之间创建一个符号链接以使用单个 pull secret。通过创建符号链接，您可以确保两个位置都存在于嵌入在容器镜像中的通用持久文件中。

2. 创建 /usr/lib/container-auth.json 文件。

   FROM quay.io/<namespace>/<image>:_<tag>_
   COPY containers-auth.conf /usr/lib/tmpfiles.d/link-podman-credentials.conf
   RUN --mount=type=secret,id=creds,required=true cp /run/secrets/creds /usr/lib/container-auth.json && \
       chmod 0600 /usr/lib/container-auth.json && \
       ln -sr /usr/lib/container-auth.json /etc/ostree/auth.json

   运行 Containerfile 时，会出现以下操作：

   • Containerfile 使 /run/containers/0/auth.json 成为临时运行时文件。
   • 它创建一个指向 /usr/lib/container-auth.json 的符号链接。
   • 它还会创建一个持久文件，该文件也从 /etc/ostree/auth.json 链接。

流程

1. 配置 pull secret：

   %pre
   mkdir -p /etc/ostree
   cat > /etc/ostree/auth.json << 'EOF'
   {
           "auths": {
                   "quay.io": {
                           "auth": "<your secret here>"
                   }
           }
   }
   EOF
   %end

   使用这个配置，系统使用提供的身份验证凭据从 quay.io 拉取镜像，这些凭证存储在 /etc/ostree/auth.json 中。

2. 为不安全的 registry 禁用 TLS：

   %pre
   mkdir -p /etc/containers/registries.conf.d/
   cat > /etc/containers/registries.conf.d/local-registry.conf << 'EOF'
   
   [[registry]]
   location="[IP_Address]:5000"
   insecure=true
   EOF
   %end

   使用这个配置，系统会从没有使用 TLS 保护的 registry 中拉取容器镜像。您可以在开发或内部网络中使用它。