构建、运行和管理容器

大约 160 分钟

构建、运行和管理容器

来源：官方文档原始多页入口：构建、运行和管理容器内容规模：约 171,541 字符，176 个章节标题，459 个命令/代码块，54 条提示框

阅读提要

副标题：在 Red Hat Enterprise Linux 上使用 Podman、Buildah 和 Skopeo
摘要：Red Hat Enterprise Linux (RHEL)提供了很多用于容器镜像的命令行工具。您可以使用 Podman 管理 pod 和容器镜像。要构建、更新和管理容器镜像，您可以使用 Buildah。要复制并检查远程存储库中的镜像，您可以使用 Skopeo。除了命令行工具外，您还可以使用 Podman Desktop、图形界面来管理容器、镜像、Pod 和注册表。
主要章节：在 Red Hat Enterprise Linux 上使用 Podman、Buildah 和 Skopeo；对红帽文档提供反馈；第 1 章容器简介；第 2 章容器镜像的类型；第 3 章使用容器注册中心；第 4 章使用容器镜像；第 5 章操作容器；第 6 章可重复生成的容器构建简介；第 7 章将软件添加到 UBI 容器中；第 8 章签名容器镜像；第 9 章使用 pod；第 10 章管理容器网络
推荐阅读顺序：先看“阅读提要”和目录，再按章节查看“关键点/命令/注意”；需要原文细节时点击来源链接。

章节笔记

概览

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

在 Red Hat Enterprise Linux 上使用 Podman、Buildah 和 Skopeo

要点：摘要

对红帽文档提供反馈

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

第 1 章容器简介

要点：Linux 容器将轻量级应用程序隔离与基于镜像的部署方法的灵活性相结合。它们使用 RHEL 核心技术来降低安全风险并提供企业级质量的环境。
要点：RHEL 使用如下技术实现 Linux 容器：
列表：控制组（cgroups）用于资源管理
列表：命名空间（namespace）用于进程隔离
列表：SELinux 用于安全性
列表：安全多租户
列表：podman - 用于直接管理 pod 和容器镜像（run、stop、start、ps、attach 和exec ，等等）
列表：buildah - 用于构建、推送和签名容器镜像

1.1. 有关容器命令行工具的信息

要点：Red Hat OpenShift 提供了强大的命令行和 Web UI 工具，用于在称为 pod 的单元中构建、管理和运行容器。您可以在 OpenShift 外部构建和管理单个容器和容器镜像。
要点：您可以使用以下工具直接在 RHEL 系统上执行这些任务。红帽提供了一组命令行工具，无需容器引擎即可操作。它们是：
列表：Podman - 用于直接管理 pod 和容器镜像 (run, stop, start, ps, attach, exec 等)
列表：buildah - 用于构建、推送和签名容器镜像
列表：skopeo - 用于复制、检查、删除和签名镜像
列表：runc - 为 Podman 和 buildah 提供容器运行和构建功能
列表：crun - 可选运行时，可以配置，并为 rootless 容器提供更大的灵活性、控制和安全性
列表：使用 CRI-O 容器引擎

1.2. Podman、Podman Desktop、Buildah 和 Skopeo 的特性

要点：Podman、Podman Desktop、Skopeo 和 Buildah 这些工具是为了替代 Docker 的部分命令功能而开发的。这种场景中的每个工具都是非常轻量级的，并专注于功能的子集。
要点：Podman、Podman Desktop、Skopeo 和 Buildah 工具的主要优点包括：
列表：以 rootless 模式运行 - rootless 容器更安全，因为它们在运行时不需要添加任何特权
列表：不需要守护进程 - 这些工具在空闲时对资源的要求要低得多，因为如果您没有运行容器，Podman 就不会运行。相反，Docker 始终依赖一个持续运行的守护进程。
列表：原生 systemd 集成 - Podman 允许您创建 systemd 单元文件，并作为系统服务运行容器
列表：Podman、Buildah 和 CRI-O 容器引擎都使用相同的后端存储目录 /var/lib/containers，而不是默认使用 Docker 存储位置 /var/lib/docker。
列表：虽然 Podman、Buildah 和 CRI-O 共享相同的存储目录，但它们不能相互交互。这些工具可以共享镜像。
列表：要以编程方式与 Podman 进行交互，您可以使用 Podman v2.0 RESTful API，它可以在有根和无根的环境中工作。

1.3. 不使用 Docker 运行容器

要点：您可以使用 Podman 在 RHEL 上运行容器化应用程序，消除中央守护进程的依赖关系，并通过无根操作提高系统安全性。
要点：podman-docker 软件包还提供兼容的环境来管理 Docker 格式的镜像，同时确保系统占用较小的系统占用空间和更好的隔离。
列表：您可以安装 podman-docker 软件包，每次运行 docker 命令时，它实际上是运行 podman 命令。
列表：Podman 还支持 Docker Socket API，因此 podman-docker 软件包还在 /var/run/docker.sock 和 /var/run/podman/podman.sock 之间建立了一个链接。因此，您可以继续使用 docker-py 和 docker-compose 工具运行 Docker API 命令，而无需 Docker 守护进程。
列表：podman 命令（如 docker 命令）可以从 Containerfile 或 Dockerfile 构建容器镜像。可以在 Containerfile 和 Dockerfile 中使用的命令一样。
列表：使用 podman 时，您不能使用 docker 命令中提供的一些选项，包括 network、node、secret、service、stack 和 swarm。您也不能使用 plugin 选项，因为 Podman 不支持插件。如果要使用 Podman 重命名容器，则必须使用 rm，然后使用 create 而不是 rename 选项。您直接在 Podman 中运行子命令，而不是使用容器和镜像选项。

1.4. RHEL 中支持的用于容器部署的架构

要点：在 RHEL 中支持的硬件构架上部署容器化应用程序，以确保不同环境的工作负载兼容性。通过识别适当的平台，您可以保持容器镜像的一致性能和可移动性。
要点：红帽为以下计算机架构提供了容器镜像和容器相关的软件：* AMD64 和 Intel 64 （基础和层次镜像；不支持 32 位架构），在 32 位构架中不支持 9 个 64 位和 9 64 位（基础镜像和大多数层次镜像）* 64 位 IBM Z（基本镜像和大多数层次镜像）* ARM 64 位（基本镜像和大多数层次镜像）
列表：通用基础镜像(UBI)：镜像、存储库和软件包

1.5. 安装容器工具

要点：安装 container-tools meta-package 以获取 Podman、Buildah、Skopeo、CRIU、Udica 以及所有必需的库。这为在 RHEL 上使用容器提供了完整的环境。
要点：流程
列表：安装 RHEL。
列表：注册 RHEL：输入您的用户名和密码。用户名和密码与您红帽客户门户网站的登录凭证相同： # subscription-manager register Registering to: subscription.rhsm.redhat.com:443/subscription Username: <username> Password: <password>
列表：安装 container-tools meta-package： # dnf install container-tools 如果您愿意，您也可以单独安装 podman、buildah 和 skopeo。
列表：可选：安装 podman-docker 软件包： # dnf install podman-docker podman-docker 软件包使用匹配的 Podman 命令替换 Docker 命令行界面和 docker-api。
命令/配置摘录：

# subscription-manager register Registering to: subscription.rhsm.redhat.com:443/subscription Username: <username> Password: <password>
# dnf install container-tools

注意：注意 RHEL 10 中不提供稳定的流。要获得对 Podman 的稳定访问、Buildah、Skopeo 等，请使用 RHEL EUS 订阅。

1.6. 安装 Podman 桌面

要点：安装 Podman 桌面以视觉化和管理您的开发环境，包括 pod 和容器。此 GUI 工具在 Podman 引擎上运行，并简化了构建镜像并部署到 Kubernetes 等任务。
要点：Podman Desktop 可帮助您执行开发任务并视觉化您的开发环境，如运行的 pod 或容器的数量。您可以在三个不同的操作系统中运行此工具：macOS、Windows 和 Linux。Podman Desktop 在 Podman 引擎上运行工作负载，因此为您提供了与容器化应用程序交互的 Podman 原生功能。作为开发者，您可以：
列表：创建和管理容器或 pod
列表：管理容器镜像
列表：使用 Kind、Lima、Minikube 或 OpenShift 将容器或 pod 部署到 Kubernetes
列表：管理 Docker 兼容性，以在 Podman 引擎上运行 Docker 工作负载
列表：使用扩展集成您的工具
列表：您有一个 RHEL 10 机器。
命令/配置摘录：

# subscription-manager repos --enable rhel-10-for-$(arch)-extensions-rpms
# dnf install podman-desktop

注意：注意 Podman 包含在 RHEL 订阅中，应用程序会自动检测并运行它。

1.7. 对 rootless 容器的特别考虑

要点：以非 root 用户身份运行容器时，了解配置差异和限制。Rootless 容器使用不同的存储路径，且无法修改某些系统功能，或者在没有配置的情况下绑定到特权端口。
要点：以非 root 用户身份运行容器时，需要考虑以下事项：
列表：对于 root 用户(/var/lib/containers/storage)和非 root 用户($HOME/.local/share/containers/storage)，主机容器存储的路径是不同的。
列表：运行无根容器的用户被授予在主机系统上作为用户和组群 ID 运行的特殊权限。但是，它们对主机上的操作系统没有 root 特权。
列表：如果您手动更改 /etc/subuid 或 /etc/subgid，则必须运行 podman system migrate 命令，以允许应用新的更改。
列表：如果您需要配置 rootless 容器环境，请在主目录($HOME/.config/containers)中创建配置文件。配置文件包括 storage.conf （用于配置存储）和 containers.conf （用于各种容器设置）。您还可以创建 registry.conf 文件，以标识使用 Podman 进行拉取、搜索或运行镜像时可用的容器注册表。
列表：有些系统功能在没有 root 特权的情况下无法更改。例如，您无法通过在容器内设置 SYS_TIME 功能并运行网络时间服务(ntpd)来更改系统时钟。您必须以 root 用户身份运行该容器，绕过 rootless 容器环境，并使用 root 用户的环境。例如： # podman run -d --cap-add SYS_TIME docker.io/ntpd/ntpd 请注意，这个示例允许 ntpd 为整个系统调整时间，而不只是在容器内调整。
列表：rootless 容器无法访问端口号小于 1024 的端口。在 rootless 容器命名空间中，它可以启动一个服务，该服务从容器中公开 httpd 服务的端口 80 ，但它不能在命名空间外访问： $ podman run -d httpd 但是，容器需要 root 权限，使用 root 用户的容器环境向主机系统公开该端口： # podman run -d -p 80:80 httpd
命令/配置摘录：

# podman run -d --cap-add SYS_TIME docker.io/ntpd/ntpd
$ podman run -d httpd

1.8. 使用模块进行高级 Podman 配置

要点：您可以使用 Podman 模块加载预定的一组配置。Podman 模块是 Tom 的 Obvious Minimal Language (TOML)格式的 containers.conf 文件。
要点：这些模块位于以下目录或其子目录中：
列表：对于无根用户：$HOME/.config/containers/containers.conf.modules
列表：对于 root 用户：/etc/containers/containers.conf.modules 或 /usr/share/containers/containers.conf.modules
列表：您可以使用 --module 选项多次指定模块。
列表：如果 <your_module_name> 是绝对路径，则配置文件将被直接加载。
列表：相对路径是相对于前面提到的三个模块目录而解析的。
列表：$HOME 中的模块覆盖 /etc/ 和 /usr/share/ 目录中的模块。

第 2 章容器镜像的类型

要点：您可以在 RHEL 上识别标准和多架构容器镜像格式，以便为工作负载选择正确的镜像类型。选择正确的格式通过 Podman 等工具在不同的硬件平台间确保应用程序兼容性和优化交付。

2.1. RHEL 容器镜像的一般特征

要点：查看 RHEL 基础镜像和 UBI 镜像的共享特征。这些受官方支持、已纳入镜像目录并持续维护更新的镜像，为您的应用程序提供了一个安全的基础。
要点：容器镜像有两种类型：
列表：Red Hat Enterprise Linux 基础镜像（RHEL 基础镜像）
列表：红帽通用基础镜像（UBI 镜像）这两种类型的容器镜像都是从 Red Hat Enterprise Linux 的部分内容构建的。通过使用这些容器，用户可以从出色的可靠性、安全性、性能和生命周期中受益。两种类型的容器镜像的主要区别在于 UBI 镜像可在各种平台（包括非红帽）间共享和部署容器化应用程序。它们充当云原生和 Web 应用程序的基础。
列表：受支持的：红帽支持用于容器化的应用程序。它们包含与 Red Hat Enterprise Linux 中具有相同的安全性、经过测试并认证的软件包。
列表：已收录的：在红帽容器目录中列出，其中包含每个镜像的描述、技术详情和健康索引。
列表：可更新的：提供明确的更新计划，以便获取最新的软件进行更新。
列表：可跟踪的：由红帽产品勘误表跟踪，以帮助了解每次更新中添加的更改。

2.2. UBI 镜像的特点

要点：要基于 RHEL 软件构建可重新分发的容器镜像，您可以使用通用基础镜像(UBI)。UBI 提供各种镜像类型，如微型和标准，以满足不同的应用程序需求。
要点：以下特点适用于 UBI 镜像：
列表：基于 RHEL 内容的子集构建: 红帽通用基础镜像由普通 Red Hat Enterprise Linux 内容的子集构建。
列表：可重新分发：UBI 镜像允许对红帽客户、合作伙伴、ISV 和其他人进行标准化。使用 UBI 镜像，您可以在可自由共享和部署的官方红帽软件的基础上构建容器镜像。
列表：提供一组四个基础镜像：micro、minima、standard 和 init。
列表：提供一组预构建的语言运行时容器镜像：基于 Application Stream 的运行时镜像为应用程序提供了一个基础，可受益于标准的、支持的运行时，如 python、perl、PHP、.NET、Node.js 和 ruby。
列表：提供一组关联的 DNF 存储库：DNF 存储库包括允许您添加应用程序依赖项并重建 UBI 容器镜像的 RPM 软件包和更新。 ubi-10-baseos 存储库保存了您可以在容器中包含的可重新分发的 RHEL 软件包的子集。 ubi-10-appstream 存储库包含您可以添加到 UBI 镜像中的应用程序流软件包。这些软件包可帮助您标准化用于需要特定运行时的应用程序的环境。添加 UBI RPM：您可以从预先配置的 UBI 软件仓库将 RPM 软件包添加到 UBI 镜像中。如果您应该在断开连接的环境中，则必须将 UBI Content Delivery Network 列入白名单才能使用该功能。
列表：ubi-10-baseos 存储库保存了您可以在容器中包含的可重新分发的 RHEL 软件包的子集。
注意：注意所有层次的镜像都基于 UBI 镜像。要检查您的镜像是基于哪个 UBI 镜像，请查看 Red Hat Container Catalog 中的 Containerfile，并确保 UBI 镜像包含所有需要的内容。

2.3. 了解 UBI 标准镜像

要点：您可以使用 UBI 标准镜像作为 RHEL 上容器化应用程序的可靠、高性能的基础。通过这些可自由重新分发的镜像，您可以构建和共享安全工作负载，这些工作负载从 RHEL 生态系统的稳定性和广泛的软件包库中受益。
要点：标准镜像(名为 ubi)专为在 RHEL 上运行的任何应用程序而设计。Red Hat Universal Base Image (UBI)标准镜像的主要功能包括：
列表：init system ：您管理 systemd 服务所需的 systemd 初始化系统的所有功能都在标准基础镜像中提供。这些初始化系统允许您安装已经预配置为自动启动服务的 RPM 软件包，如 Web 服务器(httpd)或 FTP 服务器(vsftpd)。
列表：dnf ：您可以访问免费 DNF 存储库来添加和更新软件。您可以使用 dnf 命令的标准集合（ dnf、dnf-config-manager、dnfdownloader 等等）。
列表：实用程序：实用程序包括 tar、dmidecode、gzip、getfacl 和其他 ACL 命令，dmsetup 和进一步的设备映射器命令，以及其他实用程序在此未提及。

2.4. 了解 UBI init 镜像

要点：UBI init 镜像（名为 ubi-init）包含 systemd 初始化系统，这有助于构建您要在其中运行 systemd 服务的镜像，如 web 服务器或文件服务器。init 镜像包含的内容比最小镜像多，但比标准镜像少。
要点：由于 ubi10-init 镜像构建在 ubi10 镜像之上，因此它们的内容基本相同。但是，有几个关键的区别：
列表：ubi10-init: CMD 设置为 /sbin/init，以默认启动 systemd Init 服务包括 ps 和进程相关的命令（procps-ng 软件包）将 SIGRTMIN+3 设为 StopSignal，因为 ubi10-init 中的 systemd 会忽略正常信号退出(SIGTERM 和 SIGKILL)，但如果它收到 SIGRTMIN+3，则会终止
列表：CMD 设置为 /sbin/init，以默认启动 systemd Init 服务
列表：包括 ps 和进程相关的命令（procps-ng 软件包）
列表：将 SIGRTMIN+3 设为 StopSignal，因为 ubi10-init 中的 systemd 会忽略正常信号退出(SIGTERM 和 SIGKILL)，但如果它收到 SIGRTMIN+3，则会终止
列表：ubi10: CMD 设为 /bin/bash 不包含 ps 和进程相关的命令（procps-ng 软件包）不要忽略正常信号退出（SIGTERM 和 SIGKILL）
列表：CMD 设为 /bin/bash

2.5. 了解 UBI 最小镜像

要点：UBI 最小镜像（名为 ubi-minimal ）提供最小的预安装的内容集和软件包管理器(microdnf)。因此，您可以在最小化镜像中包含的依赖项时使用 Containerfile。
要点：UBI 最小镜像的主要功能包括：
列表：小尺寸：最小映像在磁盘上约 92M，压缩时为 32M。这比标准镜像小了多一半。
列表：软件安装(microdnf) ：最小镜像包含 microdnf 工具，而不是完全开发的 dnf 工具来使用软件存储库和 RPM 软件包。microdnf 允许您启用和禁用存储库，删除和更新软件包，并在安装软件包后清除缓存。
列表：基于 RHEL 打包：最小映像包含常规的 RHEL 软件 RPM 软件包，但删除了一些功能。最小镜像不包括初始化和服务管理系统，如 systemd 或 System V init、Python 运行时环境和一些 shell 工具。您可以依赖 RHEL 存储库来构建镜像，同时承担尽可能少的开销。
列表：支持 microdnf 的模块：microdnf 命令所使用的模块可让您安装同一软件的多个版本（如果提供的话）。您可以使用 microdnf module enable,microdnf module disable, 和 microdnf module reset 来启用、禁用和重置模块流。例如，要在 UBI 最小容器中启用 nodejs:14 模块流，请输入： # microdnf module enable nodejs:14 Downloading metadata... ... Enabling module streams: nodejs:14 Running transaction test... 红帽只支持 U…
列表：例如，要在 UBI 最小容器中启用 nodejs:14 模块流，请输入： # microdnf module enable nodejs:14 Downloading metadata... ... Enabling module streams: nodejs:14 Running transaction test... 红帽只支持 UBI 的最新版本，不支持在点版本上的 parking。
列表：扩展更新支持特定的点版本发布
命令/配置摘录：

# microdnf module enable nodejs:14 Downloading metadata... ... Enabling module streams:  nodejs:14 Running transaction test...

2.6. 了解 UBI 微镜像

要点：ubi-micro 是最小的 UBI 镜像，它通过排除软件包管理器及其所有依赖项（这些组件通常都会包含在容器镜像中）来实现尽可能小的镜像体积。这可最小化基于 ubi-micro 镜像的容器镜像的攻击面。
要点：您还可以将 ubi-micro 用于最小应用程序，即使您对其他应用程序使用的是 UBI standard、minimal 或 init 镜像。没有 Linux 发行包的容器镜像称为 Distroless 容器镜像。

第 3 章使用容器注册中心

要点：要存储和检索容器镜像和工件，您可以配置容器镜像 registry。系统范围的 /etc/containers/registries.conf 文件管理使用哪些 registry 工具，如 Podman 和 Buildah。

3.1. 容器注册中心

要点：容器注册表是用来存储容器镜像和基于容器的应用工件的存储库或存储库的集合。
要点：红帽提供的注册表是：
列表：registry.redhat.io (需要身份验证)
列表：registry.access.redhat.com（不需要身份验证）
列表：registry.connect.redhat.com（保留 Red Hat Partner Connect 程序镜像）
列表：Red Hat Container Registry 身份验证
命令/配置摘录：

# podman pull <registry>[:<port>]/[<namespace>/]<name>:<tag>

注意：注意使用包括注册中心、命名空间、镜像名称和标签的完全限定镜像名称。在使用短名称时，通常会存在欺骗风险。添加受信任的注册表，也就是不允许未知或匿名用户创建任意名称帐户的注册表。
表格样本（共 4 行）：
- 命名空间 | 示例（<namespace>/<name>）
- 机构 | redhat/kubernetes，google/kubernetes
- login（用户名） | alice/application，bob/application
- role | devel/database、test/database、prod/database

3.2. 配置容器注册表

要点：要控制 Podman 如何搜索和检索镜像，您可以在 RHEL 上配置容器 registry。定义可信源和搜索优先级，可以确保在整个基础设施中实现可预测的应用程序部署。
要点：您可以使用 podman info --format 命令显示容器注册中心：
列表：使用 Podman 桌面设置容器 registry
命令/配置摘录：

$ podman info -f json | jq '.registries["search"]' [  "registry.access.redhat.com",  "registry.redhat.io",  "docker.io" ]
unqualified-search-registries = ["registry.access.redhat.com", "registry.redhat.io", "docker.io"] short-name-mode = "enforcing"

注意：注意 podman info 命令在 Podman 4.0.0 或更高版本中提供。
注意：注意 prefix 是可选的，默认值与 location 值相同。

3.3. 搜索容器镜像

要点：您可以使用 podman search 命令在容器注册表中搜索镜像。您还可以在 Red Hat Container Catalog 中搜索镜像。目录包括镜像描述、内容、健康索引和其他信息。
要点：要在 quay.io 注册中心中搜索 postgresql-10 镜像，请按照以下步骤操作：
列表：container-tools 元数据包已安装。
列表：注册中心已配置。
列表：向注册中心进行身份验证： # podman login quay.io
列表：搜索镜像：要搜索特定注册中心中的特定镜像，请输入： # podman search quay.io/postgresql-10 INDEX NAME DESCRIPTION STARS OFFICIAL AUTOMATED redhat.io registry.redhat.io/rhel10/postgresql-10 This container image ... 0 redhat.io registry.redhat.io/rhscl/postgresql-10-rhel7 PostgreSQL is an ... 0 另外，要显示特定注册中心提供的所有镜像，请输入： # podman search quay.io/* …
列表：要搜索特定注册中心中的特定镜像，请输入： # podman search quay.io/postgresql-10 INDEX NAME DESCRIPTION STARS OFFICIAL AUTOMATED redhat.io registry.redhat.io/rhel10/postgresql-10 This container image ... 0 redhat.io registry.redhat.io/rhscl/postgresql-10-rhel7 PostgreSQL is an ... 0
列表：另外，要显示特定注册中心提供的所有镜像，请输入： # podman search quay.io/*
命令/配置摘录：

# podman login quay.io
# podman search quay.io/postgresql-10 INDEX NAME DESCRIPTION STARS OFFICIAL AUTOMATED redhat.io registry.redhat.io/rhel10/postgresql-10 This container image ... 0 redhat.io registry.redhat.io/rhscl/postgresql-10-rhel7 PostgreSQL is an ... 0

注意：注意 podman search 命令不是确定镜像是否存在的可靠方法。v1 和 v2 Docker 分发 API 的 podman search 行为是特定于每个注册中心的实现的。有些 registry 可能根本不支持搜索。在没有搜索词的情况下的搜索仅适用于实现 v2 API 的注册表。docker search 命令也是如此。

3.4. 配置短名称别名

要点：在 registry.conf 中配置短名称别名，以将短名称（如 ubi10 ）映射到完全限定的镜像名称。这提供了对镜像源的控制，有助于防止与短名称关联的风险。
要点：始终通过其完全限定名称拉取镜像。但是，通常按短名称拉取镜像。例如，您可以使用 ubi10 而不是 registry.access.redhat.com/ubi10:latest。
列表：enforcing ：如果在镜像拉取过程中未找到匹配的别名，Podman 会提示用户选择一个非限定搜索注册表。如果所选镜像拉取成功，Podman 将自动在 $HOME/.cache/containers/short-name-aliases.conf 文件（非 root 用户）或在 /var/cache/containers/short-name-aliases.conf （root 用户）中记录一个新的短名称别名。如果无法提示用户（例如，stdin 或 stdout 而不是 TTY），则 Podman 会失败。请注意，如果都指定了同一别名，short-name-aliases.conf 文件优先于 registries.conf…
列表：permissive ：与 enforcing 模式类似，但如果用户无法得到提示，Podman 不会失败。相反，Podman 会按照指定顺序搜索所有非限定 registry。请注意，没有记录别名。
列表：disabled ：以给定顺序尝试所有非限定搜索注册表，不会记录任何别名。
命令/配置摘录：

unqualified-search-registries=["registry.fedoraproject.org", "quay.io"] [aliases] "fedora"="registry.fedoraproject.org/fedora"

3.5. 使用 policy.json 文件进行容器签名验证

要点：您可以通过修改 policy.json 文件将 RHEL 配置为验证容器镜像签名。这样可确保 podman、buildah 和 skopeo 等工具仅从可信且未修改的源拉取镜像。
要点：对于系统范围的配置，您可以修改 /etc/containers/policy.json 文件。对于无根用户，您可以在 $HOME/.config/containers/policy.json 文件中应用这些规则。
列表：default ：default 数组指定了回退策略，该策略适用于镜像不匹配任何已定义作用域的情况。
列表：transport ：您可以在 transports 对象中定义自定义策略。对于容器注册表，您可以在 docker 传输下定义自定义策略。
列表：registry 和 namespace ：您可以使用 transport 部分在不同的机构级别配置信任策略。您以以下任一方式对策略进行范围限定：将策略应用到整个注册表，例如，用于单一公司专用注册表的<registry>。将策略缩小到特定命名空间或存储库，例如用于公共注册表的 <registry>/<namespace> 。
列表：将策略应用到整个注册表，例如，用于单一公司专用注册表的<registry>。
列表：将策略缩小到特定命名空间或存储库，例如用于公共注册表的 <registry>/<namespace> 。
列表：type:signedBy：指定容器工具仅接受具有有效签名的镜像。
命令/配置摘录：

{  "default": [  {  "type": "insecureAcceptAnything"  }  ],  "transports": {  "docker": {  "localhost:5003/simple-sq-signed-centos": [  {  "type": "signedBy",  "keyType": "GPGKeys",  "keyPath": "testdata/sequoia-key.pgp"  }  ]  }  } }

注意：注意配置处于活跃状态后，您必须运行 podman pull <registry>/<namespace>/<image> 命令。Podman 会按照您在 policy.json 文件中配置的策略，自动强制要求镜像必须存在签名。如果您试图从配置的注册表中拉取未签名或使用错误密钥的镜像，命令会失败。

第 4 章使用容器镜像

要点：使用 Podman 工具管理容器镜像。您可以使用此工具来拉取镜像、检查、打标签、保存、加载、重新分发和定义镜像签名。

4.1. 从 registry 中拉取镜像

要点：使用 podman pull 命令，从远程注册中心下载容器镜像到本地系统。这使得镜像可用于创建和运行容器。
要点：先决条件
列表：container-tools 元数据包已安装。
列表：登录到 registry.redhat.io 注册表： $ podman login registry.redhat.io Username: <username> Password: <password> Login Succeeded!
列表：拉取 registry.redhat.io/ubi10/ubi 容器镜像： $ podman pull registry.redhat.io/ubi10/ubi
列表：列出拉取到本地系统的所有镜像： $ podman images REPOSITORY TAG IMAGE ID CREATED SIZE registry.redhat.io/ubi10/ubi latest 3269c37eae33 7 weeks ago 208 MB 如需更多信息，请参阅系统中的 podman-pull (1) 手册页。
列表：使用 Podman 桌面拉取镜像
命令/配置摘录：

$ podman login registry.redhat.io Username: <username> Password: <password> Login Succeeded!
$ podman pull registry.redhat.io/ubi10/ubi

4.2. 使用短名称别名拉取容器镜像

要点：您可以使用短名称别名而不是完全限定镜像路径从 Red Hat Enterprise Linux 中的可信 registry 中拉取容器镜像。此方法允许您将工件安全地检索到本地系统。
要点：先决条件
列表：container-tools 元数据包已安装。
列表：拉取 fedora 容器镜像： $ podman pull fedora Resolved "fedora" as an alias (/etc/containers/registries.conf.d/000-shortnames.conf) Trying to pull registry.fedoraproject.org/fedora:latest… ... Storing signatures ... 找到别名，并且安全地拉取 registry.fedoraproject.org/fedora 镜像。非限定搜索注册表列表不用于解析 fedora 镜像名称。
列表：拉取 nginx 容器镜像： $ podman pull nginx ? Please select an image: registry.access.redhat.com/nginx:latest registry.redhat.io/nginx:latest ▸ docker.io/library/nginx:latest ✔ docker.io/library/nginx:latest Trying to pull docker.io/library/nginx:latest… ... Storing signatures ... 如果没有找到匹配的别名，系统会提示您从 unqualified-search-regist…
列表：列出拉取到本地系统的所有镜像： $ podman images REPOSITORY TAG IMAGE ID CREATED SIZE registry.fedoraproject.org/fedora latest 28317703decd 12 days ago 184 MB docker.io/library/nginx latest 08b152afcfae 13 days ago 137 MB
命令/配置摘录：

$ podman pull fedora Resolved "fedora" as an alias (/etc/containers/registries.conf.d/000-shortnames.conf) Trying to pull registry.fedoraproject.org/fedora:latest… ... Storing signatures ...
$ podman pull nginx ? Please select an image: registry.access.redhat.com/nginx:latest registry.redhat.io/nginx:latest  ▸ docker.io/library/nginx:latest ✔ docker.io/library/nginx:latest Trying to pull docker.io/library/nginx:latest… ... Storing signatures ...

4.3. 列出镜像

要点：您可以使用 Podman 列出本地存储的容器镜像，以验证版本可用性并管理系统存储。查看镜像列表可确保您为工作负载选择适当的基础，同时保持对本地环境的可见性。
要点：先决条件
列表：container-tools 元数据包已安装。
列表：本地系统上提供了拉取的镜像。
列表：列出本地存储中的所有镜像： $ podman images REPOSITORY TAG IMAGE ID CREATED SIZE registry.access.redhat.com/ubi10/ubi latest 3269c37eae33 6 weeks ago 208 MB 如需更多信息，请参阅系统中的 podman-images (1) 手册页。
命令/配置摘录：

$ podman images REPOSITORY TAG IMAGE ID CREATED SIZE registry.access.redhat.com/ubi10/ubi latest 3269c37eae33 6 weeks ago 208 MB

4.4. 检查本地镜像

要点：将镜像拉取到本地系统并运行后，您可以使用 podman inspect 命令来调查镜像。例如，使用它来了解镜像是做什么的，并检查镜像内有什么软件。
要点：先决条件
列表：container-tools 元数据包已安装。
列表：本地系统上提供了拉取的镜像。
列表：检查 registry.redhat.io/ubi10/ubi 镜像： $ podman inspect registry.redhat.io/ubi10/ubi … "Cmd": [ "/bin/bash" ], "Labels": { "architecture": "x86_64", "build-date": "2020-12-10T01:59:40.343735", "com.redhat.build-host": "cpt-1002.osbs.prod.upshift.rdu2.redhat.com", "com.redhat.component": "ubi10-container", "com.r…
命令/配置摘录：

$ podman inspect registry.redhat.io/ubi10/ubi …  "Cmd": [  "/bin/bash"  ],  "Labels": {  "architecture": "x86_64",  "build-date": "2020-12-10T01:59:40.343735",  "com.redhat.build-host": "cpt-1002.osbs.prod.upshift.rdu2.redhat.com",  "com.redhat.component": "ubi10-container",  "com.redhat.license_terms": "https://www.redhat.com/...,  "description": "The Universal Base Image is ...  } ...

4.5. 检查远程镜像

要点：在将镜像拉取到系统之前，请使用 skopeo inspect 命令显示远程容器注册中心中的镜像信息。这显示了默认命令、环境变量和架构等详情。
要点：先决条件
列表：container-tools 元数据包已安装。
列表：检查 registry.redhat.io/ubi10/ubi-init 镜像： # skopeo inspect docker://registry.redhat.io/ubi10/ubi-init { "Name": "registry.redhat.io/ubi10/ubi10-init", "Digest": "sha256:c6d1e50ab...", "RepoTags": [ ... "latest" ], "Created": "2020-12-10T07:16:37.250312Z", "DockerVersion": "1.13.1", "Labels": { "architecture":…
命令/配置摘录：

# skopeo inspect docker://registry.redhat.io/ubi10/ubi-init {  "Name": "registry.redhat.io/ubi10/ubi10-init",  "Digest": "sha256:c6d1e50ab...",  "RepoTags": [  ...  "latest"  ],  "Created": "2020-12-10T07:16:37.250312Z",  "DockerVersion": "1.13.1",  "Labels": {  "architecture": "x86_64",  "build-date": "2020-12-10T07:16:11.378348",  "com.redhat.build-host": "cpt-1007.osbs.prod.upshift.rdu2.redhat.com",  "com.redhat.component": "ubi10-init-container",  "com.redhat.license_terms": "https://www.redhat.com/en/about/red-hat-end-user-license-agreements#UBI",  "description": "The Universal Base Image Init is designed to run an init system as PID 1 …

4.6. 复制容器镜像

要点：您可以使用 skopeo copy 命令将容器镜像从一个注册中心复制到另一个注册中心。例如，您可以使用外部注册表的镜像填充内部存储库，或者在两个不同的地方同步镜像注册表。
要点：先决条件
列表：container-tools 元数据包已安装。
列表：将 skopeo 容器镜像从 docker://quay.io 复制到 docker://registry.example.com ： $ skopeo copy docker://quay.io/skopeo/stable:latest docker://registry.example.com/skopeo:latest 如需更多信息，请参阅系统中的 skopeo-copy (1) 手册页。
命令/配置摘录：

$ skopeo copy docker://quay.io/skopeo/stable:latest docker://registry.example.com/skopeo:latest

4.7. 将镜像层复制到本地目录中

要点：您可以使用 Skopeo 将容器镜像层复制到本地目录，以审查镜像内容或排查文件系统变化。在本地存储层可帮助您检查镜像结构并在不部署容器的情况下验证安全合规性。
要点：先决条件
列表：container-tools 元数据包已安装。
列表：创建 /var/lib/images/nginx 目录： $ mkdir -p /var/lib/images/nginx
列表：将 docker://docker.io/nginx:latest 镜像的层复制到新创建的目录中： $ skopeo copy docker://docker.io/nginx:latest dir:/var/lib/images/nginx
列表：显示 /var/lib/images/nginx 目录的内容： $ ls /var/lib/images/nginx 08b11a3d692c1a2e15ae840f2c15c18308dcb079aa5320e15d46b62015c0f6f3 ... 4fcb23e29ba19bf305d0d4b35412625fea51e82292ec7312f9be724cb6e31ffd manifest.json version 如需更多信息，请参阅系统中的 skopeo-copy (1) 手册页。
命令/配置摘录：

$ mkdir -p /var/lib/images/nginx
$ skopeo copy docker://docker.io/nginx:latest dir:/var/lib/images/nginx

4.8. 标记镜像

要点：使用 podman tag 命令为本地镜像分配附加名称或标签。为镜像添加标签有助于管理镜像，并准备将其推送到指定的注册表。
要点：先决条件
列表：container-tools 元数据包已安装。
列表：本地系统上提供了拉取的镜像。
列表：列出所有镜像： $ podman images REPOSITORY TAG IMAGE ID CREATED SIZE registry.redhat.io/ubi10/ubi latest 3269c37eae33 7 weeks ago 208 MB
列表：使用以下选项之一将 myubi 名称分配给 registry.redhat.io/ubi10/ubi 镜像：镜像名称： $ podman tag registry.redhat.io/ubi10/ubi myubi 镜像 ID： $ podman tag 3269c37eae33 myubi 两个命令会给出同样的结果。
列表：镜像名称： $ podman tag registry.redhat.io/ubi10/ubi myubi
列表：镜像 ID： $ podman tag 3269c37eae33 myubi 两个命令会给出同样的结果。
命令/配置摘录：

$ podman images REPOSITORY TAG IMAGE ID CREATED SIZE registry.redhat.io/ubi10/ubi latest 3269c37eae33 7 weeks ago 208 MB
$ podman tag registry.redhat.io/ubi10/ubi myubi

4.9. 构建多架构镜像

要点：通过在 RHEL 上使用 Podman 构建多架构容器镜像，以确保应用程序在不同硬件平台间持续运行。使用单个镜像清单即可支持多种架构，而无需为每种环境进行独立的构建。
要点：先决条件
列表：container-tools 元数据包已安装。
列表：为您要支持的每个架构创建 Containerfiles。
列表：为每个架构构建镜像。例如： $ podman build --platform linux/arm64,linux/amd64 --manifest <registry>/<image> . --platform linux/arm64,linux/amd64 选项指定构建容器镜像的目标平台。 --manifest <registry>/<image> 选项创建一个具有指定名称的清单列表，即 <registry>/<image>，并将新构建的镜像添加到其中。清单列表是镜像清单的一个集合，每个针对不同的架构。
列表：--platform linux/arm64,linux/amd64 选项指定构建容器镜像的目标平台。
列表：--manifest <registry>/<image> 选项创建一个具有指定名称的清单列表，即 <registry>/<image>，并将新构建的镜像添加到其中。清单列表是镜像清单的一个集合，每个针对不同的架构。
列表：将清单列表推送到注册中心： $ podman manifest push <registry>/<image> 此清单列表充当拉取多架构容器的单个入口点。因此，您可以根据单个清单列表，为平台拉取合适的容器镜像。您还可以使用 podman manifest remove <manifest_list> <digest_ID> 命令从清单列表中删除条目，其中 <digest_ID> 是容器镜像的 SHA-256 校验和。例如：podman manifest remove <registry>/<image> sha256:cb8a924afdf… 。
命令/配置摘录：

$ podman build --platform linux/arm64,linux/amd64 --manifest <registry>/<image> .
$ podman manifest push <registry>/<image>

4.10. 保存并加载镜像

要点：使用 podman save 命令将镜像保存到容器存档中。稍后您可以将其恢复到其他容器环境，或将其发送给其他人。
要点：您可以使用 --format 选项来指定归档格式。支持的格式有：
列表：docker-archive
列表：oci-archive
列表：oci-dir （带有 oci 清单类型的目录）
列表：docker-archive （带有 v2s2 清单类型的目录）
列表：container-tools 元数据软件包已安装。
列表：本地系统上提供了拉取的镜像。
命令/配置摘录：

$ podman save -o mysupport-tools.tar registry.redhat.io/rhel10/support-tools:latest
$ podman save -o mysupport-tools-oci.tar --format=oci-archive registry.redhat.io/rhel10/support-tools

4.11. 重新分发 UBI 镜像

要点：使用 podman push 命令将其推送到注册表来共享您的基于 UBI 的自定义镜像。这可让其他人下载和使用您修改的镜像。
要点：先决条件
列表：container-tools 元数据软件包已安装。
列表：本地系统上提供了拉取的镜像。
列表：可选：对 ubi 镜像添加一个额外的名称： # podman tag registry.redhat.io/ubi10/ubi registry.example.com:5000/ubi10/ubi
列表：将 registry.example.com:5000/ubi10/ubi 镜像从本地存储推送到注册中心： # podman push registry.example.com:5000/ubi10/ubi 重要虽然对这些镜像的使用方式的限制不多，但对于如何引用这些镜像会有一些限制。例如，您不能调用这些红帽认证的或红帽支持的镜像，除非您通过 Red Hat Partner Connect Program (Red Hat Container Certification 或 Red Hat OpenShift Operator Certification)进行了认证。
命令/配置摘录：

# podman tag registry.redhat.io/ubi10/ubi registry.example.com:5000/ubi10/ubi
# podman push registry.example.com:5000/ubi10/ubi

注意：重要虽然对这些镜像的使用方式的限制不多，但对于如何引用这些镜像会有一些限制。例如，您不能调用这些红帽认证的或红帽支持的镜像，除非您通过 Red Hat Partner Connect Program (Red Hat Container Certification 或 Red Hat OpenShift Operator Certification)进行了认证。

4.12. 删除镜像

要点：使用 podman rmi 命令从本地存储中删除未使用的容器镜像。删除旧镜像会释放系统中的磁盘空间。
要点：先决条件
列表：container-tools 元数据包已安装。
列表：列出本地系统上的所有镜像： $ podman images REPOSITORY TAG IMAGE ID CREATED SIZE registry.redhat.io/rhel10/support-tools latest 4b32d14201de 7 weeks ago 228 MB registry.redhat.io/ubi10/ubi latest 3269c37eae33 7 weeks ago 208 MB localhost/myubi X.Y 3269c37eae33 7 weeks ago 208 MB
列表：列出所有容器： $ podman ps -a CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 7ccd6001166e registry.redhat.io/rhel10/support-tools:latest usr/bin/bash 6 seconds ago Up 5 seconds ago my-support-tools 要删除 registry.redhat.io/rhel10/support-tools 镜像，您必须使用 podman stop 命令停止运行该镜像的所有容器。您可以通过其 ID 或名称来停止容器。
列表：停止 my-support-tools 容器： $ podman stop my-support-tools 7ccd6001166e9720c47fbeb077e0afd0bb635e74a1b0ede3fd34d09eaf5a52e9
列表：删除 registry.redhat.io/rhel10/support-tools 镜像： $ podman rmi registry.redhat.io/rhel10/support-tools 要删除多个镜像： $ podman rmi registry.redhat.io/rhel10/support-tools registry.redhat.io/ubi10/ubi 要从您的系统中删除所有镜像： $ podman rmi -a 要删除与其有多个名称（标记）关联的镜像，请添加 -f 选项来删除它们： $ podman rmi -f 1de7d7b3f531 1de7d7b3f531...
列表：要删除多个镜像： $ podman rmi registry.redhat.io/rhel10/support-tools registry.redhat.io/ubi10/ubi
命令/配置摘录：

$ podman images REPOSITORY TAG IMAGE ID CREATED SIZE registry.redhat.io/rhel10/support-tools latest 4b32d14201de 7 weeks ago 228 MB registry.redhat.io/ubi10/ubi latest 3269c37eae33 7 weeks ago 208 MB localhost/myubi X.Y 3269c37eae33 7 weeks ago 208 MB
$ podman ps -a CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 7ccd6001166e registry.redhat.io/rhel10/support-tools:latest usr/bin/bash 6 seconds ago Up 5 seconds ago my-support-tools

第 5 章操作容器

要点：容器代表从解压缩的容器镜像中的文件创建的一个正在运行中或已停止的进程。您可以使用 Podman 工具来操作容器。

5.1. Podman run 命令概述

要点：使用 podman run 命令从镜像启动新容器。如果需要，该命令会拉取镜像，并使用其自身的隔离文件系统和网络启动容器进程。
要点：podman run 命令在基于容器镜像的新容器中运行进程。如果容器镜像尚未加载，podman run 从存储库中拉取镜像及其所有依赖项，就像在使用该镜像启动容器前运行 podman pull image 一样。容器进程具有自己的文件系统、网络和隔离的进程树。
列表：--detach(-d) ：在后台运行容器，并打印新的容器 ID。
列表：--attach(-a) ：以前台模式运行容器。
列表：--name(-n) ：为容器分配一个名称。如果没有使用 --name 为容器分配名称，则它会生成一个随机字符串名称。这适用于后台和前台容器。
列表：--rm ：退出时自动删除容器。请注意，当容器无法成功创建或启动时，不能删除容器。
列表：--tty (-t) ：分配和附加 pseudo-command 行到容器的标准输入中。
列表：--interactive (-i)：对于交互式进程，请使用 -i 和 -t 为容器进程分配命令行。-i -t 通常写为 -it。
命令/配置摘录：

podman run [options] image [command [arg ...]]

5.2. 在主机的容器中运行命令

要点：使用 podman run，您可以从主机直接在容器中运行命令。通过此命令，您可以在不输入交互式 shell 的情况下检查容器环境或运行工具。
要点：先决条件
列表：container-tools 元数据包已安装。
列表：使用 cat /etc/os-release 命令显示基于 registry.access.redhat.com/ubi10/ubi 容器镜像的容器的操作系统类型： $ podman run --rm registry.access.redhat.com/ubi10/ubi cat /etc/os-release NAME="Red Hat Enterprise Linux" ... ID="rhel" ... HOME_URL="https://www.redhat.com/" BUG_REPORT_URL="https://bugzilla.redhat.com/" REDHAT_BUGZILLA_PRODUCT=" Red …
列表：可选：列出所有容器。 $ podman ps CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 由于 --rm 选项，您应该看不到任何容器。容器已被删除。
命令/配置摘录：

$ podman run --rm registry.access.redhat.com/ubi10/ubi cat /etc/os-release NAME="Red Hat Enterprise Linux" ... ID="rhel" ... HOME_URL="https://www.redhat.com/" BUG_REPORT_URL="https://bugzilla.redhat.com/" REDHAT_BUGZILLA_PRODUCT=" Red Hat Enterprise Linux 10" ...
$ podman ps CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES

5.3. 在容器内运行命令

要点：使用 podman run -it 在容器内启动交互式会话。使用此命令后，您可以在容器的 shell 中工作，输入命令并进行故障排除。
要点：先决条件
列表：container-tools 元数据包已安装。
列表：运行基于 registry.redhat.io/ubi10/ubi 镜像的名为 myubi 的容器： $ podman run --name=myubi -it registry.access.redhat.com/ubi10/ubi /bin/bash [root@6ccffd0f6421 /]# -i 选项创建一个交互式会话。如果不使用 -t 选项，shell 将保持打开状态，但您无法对 shell 输入任何东西。 -t 选项打开命令行会话。如果不使用 -i 选项，shell 会打开，然后退出。
列表：-i 选项创建一个交互式会话。如果不使用 -t 选项，shell 将保持打开状态，但您无法对 shell 输入任何东西。
列表：-t 选项打开命令行会话。如果不使用 -i 选项，shell 会打开，然后退出。
列表：安装 procps-ng 软件包，其包含一组系统工具（如 ps、top 和 uptime ，等等）： [root@6ccffd0f6421 /]# dnf install procps-ng
列表：使用 ps -ef 命令列出当前的进程： # ps -ef UID PID PPID C STIME TTY TIME CMD root 1 0 0 12:55 pts/0 00:00:00 /bin/bash root 31 1 0 13:07 pts/0 00:00:00 ps -ef
命令/配置摘录：

$ podman run --name=myubi -it registry.access.redhat.com/ubi10/ubi /bin/bash [root@6ccffd0f6421 /]#
[root@6ccffd0f6421 /]# dnf install procps-ng

5.4. 构建容器

要点：要将应用程序及其所需依赖项打包成单个可移植单元，您可以在 Red Hat Enterprise Linux 中构建一个新容器。您可以在 Containerfile 中定义镜像指令，以自动执行软件安装和配置。
要点：先决条件
列表：container-tools 元数据包已安装。
列表：安装容器工具：确保 RHEL 系统上已安装必要的容器工具。container-tools 模块提供 Buildah、Podman 和 Skopeo。 $ sudo dnf install container-tools
列表：创建 Containerfile： Containerfile 定义构建容器镜像的说明。此文件指定基础镜像、要安装的任何软件、要应用的配置以及要运行的应用程序。例如： FROM registry.redhat.io/ubi10/ubi-minimal RUN microdnf -y update && microdnf -y install COPY index.html /var/www/html/ EXPOSE 80 CMD ["httpd", "-DFOREGROUND"]
列表：使用 Buildah 构建容器镜像：在进入包含 Container 文件的目录后，使用 buildah bud （或 podman build）构建镜像。 $ cd /<path_to_container_file> $ buildah bud -t your_image_name:tag . your_image_name：您的镜像的名称。 tag：镜像的标签（如 latest、1.0）。 .: 表示 Containerfile 位于当前目录中。
列表：your_image_name：您的镜像的名称。
列表：tag：镜像的标签（如 latest、1.0）。
命令/配置摘录：

$ sudo dnf install container-tools
FROM registry.redhat.io/ubi10/ubi-minimal RUN microdnf -y update && microdnf -y install COPY index.html /var/www/html/ EXPOSE 80 CMD ["httpd", "-DFOREGROUND"]

5.5. 列出容器

要点：使用 podman ps 命令查看系统中的容器状态。您可以列出当前运行的容器，或使用 -a 选项查看所有容器，包括已停止的容器。
要点：先决条件
列表：container-tools 元数据包已安装。
列表：运行基于 registry.redhat.io/rhel10/support-tools 镜像的容器： $ podman run -dt registry.redhat.io/rhel10/support-tools
列表：列出所有容器：要列出所有正在运行的容器： $ podman ps CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 74b1da000a11 rhel10/support-tools /usr/bin/bash 2 minutes ago Up About a minute musing_brown 要列出所有运行或停止的容器： $ podman ps -a CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES IS INFRA d65aecc325a4 ubi10/ubi /bin/bash 3 secs ago E…
列表：要列出所有正在运行的容器： $ podman ps CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 74b1da000a11 rhel10/support-tools /usr/bin/bash 2 minutes ago Up About a minute musing_brown
列表：要列出所有运行或停止的容器： $ podman ps -a CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES IS INFRA d65aecc325a4 ubi10/ubi /bin/bash 3 secs ago Exited (0) 5 secs ago peaceful_hopper false 74b1da000a11 rhel10/support-tools /usr/bin/bash 2 mins ago Up About a minute musing_brown false 如果没有使用 --rm 选项删除容器，您可以重启没有运行的容器。如需更多信息，请参…
命令/配置摘录：

$ podman run -dt registry.redhat.io/rhel10/support-tools
$ podman ps CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 74b1da000a11 rhel10/support-tools /usr/bin/bash 2 minutes ago Up About a minute musing_brown

5.6. 启动容器

要点：当您运行容器时，然后在不删除它的情况下停止该容器，容器会保留在本地系统中，准备好再次运行。您可以使用 podman start 命令来重新运行容器，并根据容器 ID 或名称指定容器。
要点：先决条件
列表：container-tools 元数据包已安装。
列表：至少一个容器已经停止。
列表：启动 myubi 容器：在非互动模式中： $ podman start myubi 在交互模式中，使用 -a (--attach)和 -i (--interactive)选项来使用容器 bash shell： $ podman start -a -i myubi
列表：在非互动模式中： $ podman start myubi
列表：在交互模式中，使用 -a (--attach)和 -i (--interactive)选项来使用容器 bash shell： $ podman start -a -i myubi
列表：输入 exit 退出容器并返回到主机： [root@6ccffd0f6421 /]# exit 如需更多信息，请参阅系统中的 podman-start (1) 手册页。
命令/配置摘录：

$ podman start myubi
$ podman start -a -i myubi

5.7. 检查主机的容器

要点：使用 podman inspect 命令，来检查 JSON 格式的现有容器的元数据。您可以根据其容器 ID 或名称来指定容器。
要点：先决条件
列表：container-tools 元数据包已安装。
列表：检查 ID 64ad95327c74 定义的容器：要获取所有元数据： $ podman inspect 64ad95327c74 [ { "Id": "64ad95327c740ad9de468d551c50b6d906344027a0e645927256cd061049f681", "Created": "2025-05-05T18:15:56.743553292+02:00", "Path": "/usr/bin/bash", "Args": [ "/usr/bin/bash" ], "State": { "OciVersion": "1.2.0", "Status": "running", ... 要…
列表：要获取所有元数据： $ podman inspect 64ad95327c74 [ { "Id": "64ad95327c740ad9de468d551c50b6d906344027a0e645927256cd061049f681", "Created": "2025-05-05T18:15:56.743553292+02:00", "Path": "/usr/bin/bash", "Args": [ "/usr/bin/bash" ], "State": { "OciVersion": "1.2.0", "Status": "running", ...
列表：要从 JSON 文件中获取特定的内容，如 StartedAt 时间戳： $ podman inspect --format='{{.State.StartedAt}}' 64ad95327c74 2021-03-02 11:23:54.945071961 +0100 CET 这些信息保存在层次结构中。要查看容器 StartedAt 时间戳（StartedAt 在 State下），请使用 --format 选项以及容器 ID 或名称。您想要检查的其他内容示例包括：
列表：.Path 来查看容器运行的命令
列表：.Args 命令的参数
命令/配置摘录：

$ podman inspect 64ad95327c74 [  {  "Id": "64ad95327c740ad9de468d551c50b6d906344027a0e645927256cd061049f681",  "Created": "2025-05-05T18:15:56.743553292+02:00",  "Path": "/usr/bin/bash",  "Args": [  "/usr/bin/bash"  ],  "State": {  "OciVersion": "1.2.0",  "Status": "running",  ...
$ podman inspect --format='{{.State.StartedAt}}' 64ad95327c74 2021-03-02 11:23:54.945071961 +0100 CET

5.8. 将 localhost 上的目录挂载到容器

要点：您可以通过在容器内挂载主机 /dev/log 设备，来将容器内的日志消息提供给主机系统。
要点：先决条件
列表：container-tools 元数据包已安装。
列表：运行名为 log_test 的容器，并在容器内挂载主机 /dev/log 设备： # podman run --name="log_test" -v /dev/log:/dev/log --rm \ registry.redhat.io/ubi10/ubi logger "Testing logging to the host"
列表：使用 journalctl 工具来显示日志： # journalctl -b | grep Testing Dec 09 16:55:00 localhost.localdomain root[14634]: Testing logging to the host --rm 选项会在容器退出时删除容器。
命令/配置摘录：

# podman run --name="log_test" -v /dev/log:/dev/log --rm \  registry.redhat.io/ubi10/ubi logger "Testing logging to the host"
# journalctl -b | grep Testing Dec 09 16:55:00 localhost.localdomain root[14634]: Testing logging to the host

5.9. 挂载容器文件系统

要点：您可以通过挂载容器来与容器共享主机目录或设备。例如，挂载 /dev/log 允许容器将日志直接写入主机的系统日志。
要点：先决条件
列表：container-tools 元数据包已安装。
列表：运行名为 mysyslog 的容器： # podman run -dt --name=mysyslog registry.redhat.io/rhel10/support-tools
列表：运行 podman mount 命令，将正常工作的容器根文件系统挂载到主机可访问的位置。例如，挂载 mysyslog 容器： # podman mount mysyslog /var/lib/containers/storage/overlay/990b5c6ddcdeed4bde7b245885ce4544c553d108310e2b797d7be46750894719/merged
列表：使用 ls 命令显示挂载点的内容： # ls /var/lib/containers/storage/overlay/990b5c6ddcdeed4bde7b245885ce4544c553d108310e2b797d7be46750894719/merged bin boot dev etc home lib lib64 lost+found media mnt opt proc root run sbin srv sys tmp usr var
列表：显示 OS 版本： # cat /var/lib/containers/storage/overlay/990b5c6ddcdeed4bde7b245885ce4544c553d108310e2b797d7be46750894719/merged/etc/os-release NAME="Red Hat Enterprise Linux" VERSION="10 (Ootpa)" ID="rhel" ID_LIKE="fedora" ... 如需更多信息，请参阅系统中的 podman-mount (1) 手册页。
命令/配置摘录：

# podman run -dt --name=mysyslog registry.redhat.io/rhel10/support-tools
# podman mount mysyslog /var/lib/containers/storage/overlay/990b5c6ddcdeed4bde7b245885ce4544c553d108310e2b797d7be46750894719/merged

5.10. 将服务作为使用静态 IP 的守护进程运行

要点：使用 podman mount 命令从主机访问容器的根文件系统。通过此命令，您可以直接从主机检查或修改容器内的文件。
要点：以下示例将 support-tools 服务作为守护进程在后台运行。--ip 选项将容器网络接口设为特定的 IP 地址（如 10.88.0.44）。之后，您可以运行 podman inspect 命令来检查是否正确设置了 IP 地址。
列表：container-tools 元数据包已安装。
列表：将容器网络接口设为 IP 地址 10.88.0.44： # podman run -d --ip=10.88.0.44 registry.redhat.io/rhel10/support-tools efde5f0a8c723f70dd5cb5dc3d5039df3b962fae65575b08662e0d5b5f9fbe85
列表：检查是否正确设置了 IP 地址： # podman inspect efde5f0a8c723 | grep 10.88.0.44 "IPAddress": "10.88.0.44", 如需更多信息，请参阅系统中的 podman-inspect (1) 和 podman-run (1) 手册页。
命令/配置摘录：

# podman run -d --ip=10.88.0.44 registry.redhat.io/rhel10/support-tools efde5f0a8c723f70dd5cb5dc3d5039df3b962fae65575b08662e0d5b5f9fbe85
# podman inspect efde5f0a8c723 | grep 10.88.0.44 "IPAddress": "10.88.0.44",

5.11. 在运行中的容器中执行命令

要点：要在正在运行的容器中运行命令并调查该容器，您可以使用 podman exec 命令。使用 podman exec 而不是 podman run 命令的原因是，您可以在不中断容器活动的情况下调查正在运行的容器。
要点：先决条件
列表：container-tools 元数据包已安装。
列表：容器正在运行。
列表：在 my-support-tools 容器内输入 rpm -qa 命令来列出所有安装的软件包： $ podman exec -it my-support-tools rpm -qa gpg-pubkey-fd431d51-4ae0493b gpg-pubkey-5a6340b3-6229229e libgcc-11.5.0-2.el9.x86_64 setup-2.13.7-10.el9.noarch ...
列表：在 my-support-tools 容器中输入 /bin/bash 命令： $ podman exec -it my-support-tools /bin/bash
列表：安装 procps-ng 软件包，其包含一组系统工具（如 ps、top 和 uptime ，等等）： # dnf install procps-ng
列表：检查容器：要列出系统上的每个进程： # ps -ef UID PID PPID C STIME TTY TIME CMD root 8 0 0 11:07 pts/0 00:00:00 /bin/bash root 47 8 0 11:13 pts/0 00:00:00 ps -ef 要显示文件系统磁盘空间使用情况： # df -h Filesystem Size Used Avail Use% Mounted on tmpfs 6.3G 448K 6.3G 1% /etc/hosts shm 63M 0 63M 0% /dev/shm overlay 953G 76G 877G 8% / tmpfs 64M 0 64M 0% …
命令/配置摘录：

$ podman exec -it my-support-tools rpm -qa gpg-pubkey-fd431d51-4ae0493b gpg-pubkey-5a6340b3-6229229e libgcc-11.5.0-2.el9.x86_64 setup-2.13.7-10.el9.noarch ...
$ podman exec -it my-support-tools /bin/bash

5.12. 在两个容器间共享文件

要点：即使容器被删除，您可以使用卷来持久保留容器中的数据。卷是保存在主机机器上的文件夹，不会增加容器大小，并可在多个容器间共享，从而更轻松地备份或迁移数据。
要点：先决条件
列表：container-tools 元数据包已安装。
列表：创建卷： $ podman volume create hostvolume
列表：显示卷的信息： $ podman volume inspect hostvolume [ { "name": "hostvolume", "labels": {}, "mountpoint": "/home/username/.local/share/containers/storage/volumes/hostvolume/_data", "driver": "local", "options": {}, "scope": "local" } ] 请注意，它会在卷目录中创建一个卷。您可以将挂载点路径保存到变量，以便更轻松地操作： $ mntPoint=$(podman volume inspect hostvol…
列表：使用存储在 mntPoint 变量中的路径来在目录中创建一个文本文件： $ echo "Hello from host" >> $mntPoint/host.txt
列表：列出 mntPoint 变量所定义的目录中的所有文件： $ ls $mntPoint/ host.txt
列表：运行名为 myubi1 的容器，并将主机上 hostvolume 卷名定义的目录映射到容器上的 /containervolume1 目录： $ podman run -it --name myubi1 -v hostvolume:/containervolume1 registry.access.redhat.com/ubi10/ubi /bin/bash 请注意，如果您使用 mntPoint 变量定义的卷路径(-v $mntPoint:/containervolume1)，则在运行 podman volume prune 命令时数据可能会丢失，因为这会删除未使用的卷。始终使用 -v hostvolume_name:/contai…
命令/配置摘录：

$ podman volume create hostvolume
$ podman volume inspect hostvolume [  {  "name": "hostvolume",  "labels": {},  "mountpoint": "/home/username/.local/share/containers/storage/volumes/hostvolume/_data",  "driver": "local",  "options": {},  "scope": "local"  } ]

5.13. 导出和导入容器

要点：要在不同的主机环境之间轻松传输文件系统，您可以导出和导入 Red Hat Enterprise Linux 容器。将容器打包为一个存档(tar 文件)可帮助您备份基本数据、与团队共享配置，并无缝迁移隔离的工作负载。
要点：先决条件
列表：container-tools 元数据包已安装。
列表：运行基于 registry.access.redhat.com/ubi10/ubi 镜像的 myubi 容器： $ podman run -dt --name=myubi registry.access.redhat.com/10/ubi
列表：可选：列出所有容器： $ podman ps -a CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES a6a6d4896142 registry.access.redhat.com/10:latest /bin/bash 7 seconds ago Up 7 seconds ago myubi
列表：附加到 myubi 容器： $ podman attach myubi
列表：创建名为 testfile 的文件： [root@a6a6d4896142 /]# echo "hello" > testfile
列表：使用 CTRL+p 和 CTRL+q 从容器分离。
命令/配置摘录：

$ podman run -dt --name=myubi registry.access.redhat.com/10/ubi
$ podman ps -a CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES a6a6d4896142 registry.access.redhat.com/10:latest /bin/bash 7 seconds ago Up 7 seconds ago myubi

5.14. 停止容器

要点：使用 podman stop 命令来停止正在运行的容器。您可以根据其容器 ID 或名称来指定容器。
要点：先决条件
列表：container-tools 元数据包已安装。
列表：至少有一个容器正在运行。
列表：停止 myubi 容器：使用容器名称： $ podman stop myubi 使用容器 ID: $ podman stop 1984555a2c27 要停止附加到命令行会话的正在运行的容器，您可以在容器内输入 exit 命令。 podman stop 命令发送 SIGTERM 信号来停止正在运行的容器。如果容器在定义的时间段后没有停止（默认为 10 秒），Podman 会发送一个 SIGKILL 信号。您还可以使用 podman kill 命令来终止一个容器(SIGKILL)，或向容器发送不同的信号。以下示例命令向容器发送 SIGHUP 信号。如果应用程序支持，则信号会导致应用程序重新读取其配置文件： # podman ki…
列表：使用容器名称： $ podman stop myubi
列表：使用容器 ID: $ podman stop 1984555a2c27 要停止附加到命令行会话的正在运行的容器，您可以在容器内输入 exit 命令。 podman stop 命令发送 SIGTERM 信号来停止正在运行的容器。如果容器在定义的时间段后没有停止（默认为 10 秒），Podman 会发送一个 SIGKILL 信号。您还可以使用 podman kill 命令来终止一个容器(SIGKILL)，或向容器发送不同的信号。以下示例命令向容器发送 SIGHUP 信号。如果应用程序支持，则信号会导致应用程序重新读取其配置文件： # podman kill --signal="SIGHUP" 74b1da000a11 74b1da0…
命令/配置摘录：

$ podman stop myubi
$ podman stop 1984555a2c27

5.15. 删除容器

要点：使用 podman rm 命令来删除容器。您可以使用容器 ID 或名称指定容器。
要点：先决条件
列表：container-tools 元数据包已安装。
列表：至少一个容器已经停止。
列表：列出所有运行或停止的容器： $ podman ps -a CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES IS INFRA d65aecc325a4 ubi10/ubi /bin/bash 3 secs ago Exited (0) 5 secs ago peaceful_hopper false 74b1da000a11 rhel10/support-tools usr/bin/bash 2 mins ago Up About a minute musing_brown false
列表：删除容器：要删除 peaceful_hopper 容器： $ podman rm peaceful_hopper 请注意，peaceful_hopper 容器处于 Exited 状态，这表示它已停止，可以立即删除。要删除 musing_brown 容器，首先停止容器，然后将其删除： $ podman stop musing_brown $ podman rm musing_brown 要删除多个容器： $ podman rm clever_yonath furious_shockley 要从本地系统中删除所有容器： $ podman rm -a
列表：要删除 peaceful_hopper 容器： $ podman rm peaceful_hopper 请注意，peaceful_hopper 容器处于 Exited 状态，这表示它已停止，可以立即删除。
列表：要删除 musing_brown 容器，首先停止容器，然后将其删除： $ podman stop musing_brown $ podman rm musing_brown
命令/配置摘录：

$ podman ps -a CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES IS INFRA d65aecc325a4 ubi10/ubi /bin/bash 3 secs ago Exited (0) 5 secs ago peaceful_hopper false 74b1da000a11 rhel10/support-tools usr/bin/bash 2 mins ago Up About a minute musing_brown false
$ podman rm peaceful_hopper

5.16. 容器的 SELinux 策略

要点：要为容器生成 SELinux 策略，请使用 Udica 工具。如需更多信息，请参阅为容器创建 SELinux 策略。

5.17. 在 Podman 中配置预执行钩子

要点：您可以创建插件脚本来定义对容器操作的精细控制，特别是阻止未经授权的操作，如拉取、运行或列出容器镜像。
要点：以下规则适用于插件脚本：
列表：必须是 root 所有且不可写。
列表：必须位于 /usr/libexec/podman/pre-exec-hooks 和 /etc/containers/pre-exec-hooks 目录中。
列表：按字母数字顺序依次执行。
列表：如果所有插件脚本都返回零值，则您可以运行 podman 命令。
列表：如果任何插件脚本返回非零值，这表示失败。podman 命令退出，并返回第一个失败脚本的非零值。
列表：红帽建议使用以下命名约定以正确的顺序运行脚本： DDD_name.lang，其中： DDD 是指示脚本执行顺序的十进制数字。如有必要，使用一个或多个前导零。 name 是插件脚本的名称。 lang （可选）是给定编程语言的文件扩展。例如，插件脚本的名称可以是：001-check-groups.sh。
命令/配置摘录：

#!/bin/bash if id -nG "$USER" 2> /dev/null | grep -qw "$GROUP" 2> /dev/null ; then  exit 0 else  exit 1 fi
$ podman run image ...

注意：注意文件 /etc/containers/podman_preexec_hooks.txt 必须由管理员创建，可为空。如果 /etc/containers/podman_preexec_hooks.txt 不存在，则不会运行插件脚本。
注意：注意插件脚本在创建时有效。在插件脚本之前创建的容器不会受到影响。

5.18. 在容器中调试应用程序

要点：您可以使用针对故障排除的不同方面量身定做的各种命令行工具。如需更多信息，请参阅调试容器中的应用程序。

第 6 章可重复生成的容器构建简介

要点：使用 Podman 和 Buildah 的可重现构建，从同一源代码创建相同的容器镜像。这种一致性有助于确保供应链安全性并减少存储和带宽的使用。
要点：减少镜像之间的差异，可以降低从一个镜像版本迁移到更新版本时需要从仓库拉取的数据量。可重复的容器构建对于确保供应链安全性、促进可靠的软件部署以及促进有效的调试至关重要。

6.1. 可复现容器构建的好处

要点：RHEL 容器的可复现构建会减少 registry 存储，创建较小的更新有效负载，并通过确保在源代码和构建环境没有改变时镜像层保持一致来实现更快的下载。
要点：这个过程可最大化层缓存的效率，防止冗余存储和相同数据的传输。可复现容器构建的主要优点是：
列表：减少 registry 存储：当镜像被更新时，只会存储更改的层。可复现构建可确保相同源代码生成一致的镜像，通过消除时间戳、文件顺序和元数据等非确定性因素引起的差异，从而避免额外的存储占用。
列表：高效和较小的更新负载：对于容器的次要更新，如安全补丁，只需要下载更改的层，而不是整个镜像。可复现构建还可确保源代码更新时只有受影响的层发生变化，而非可复现构建可能因为微小的代码修改导致多个层发生变化。
列表：更快的下载：容器的可复现构建可以优化构建系统和最终用户，方法是通过高效的缓存实现更快的下载并减少网络流量。

6.2. 可重现容器构建对不同环境的影响

要点：借助可重现构建，确保在 Konflux、bootc 等不同环境中构建出一致且完全相同的容器镜像。此验证有助于维护供应链的完整性，并简化了合规性和调试。
要点：在 RHEL 上可重现容器构建可确保无论构建时间或位置如何，都完全相同的容器镜像。可重复生成的容器对不同环境的影响有：
列表：增强的软件供应链完整性：可复现容器构建强化了 Konflux 提供安全且透明的软件供应链的使命。Konflux 使用可复现构建来验证构建是否完全来源于其源代码。任何第三方都可以从同一输入重建容器，并验证输出结果是否逐位完全一致。另外，RHEL 可重现容器构建可防止 "in-transit" 漏洞，即攻击者可以破坏发布镜像，或将恶意代码注入构建过程。Konflux 可以证明发布的二进制文件与其源相匹配，从而减轻对其自身构建基础架构的攻击。
列表：更高的合规性和透明性：Konflux 强制执行 SLSA 安全策略。它验证可复现 RHEL 镜像的来源和来源证明信息，简化了合规性管理。Konflux 使用 Tekton 链创建不可变且经过签名的证明文件，用于记录完整的构建过程。RHEL 的可复现容器通过确保基础镜像的可靠性和可验证性，为该证明机制增加了一层基础信任。
列表：开发和安全工作流：可重现构建可确保多次构建运行之间的容器镜像摘要保持一致，简化了测试和调试。Konflux 利用它有效地扫描和更新 RHEL 容器中存在安全漏洞的软件包。Konflux 使用经过验证的证明机制来自动阻止不合规的构建并强制实施安全策略，而不会降低灵活性。
列表：可验证的供应链和增强的安全性：可重现的 RHEL 容器构建通过为可引导操作系统镜像创建更安全、可靠和透明的构建过程来增强 rhel-bootc。您可以验证特定的 bootc 镜像是否是从其声明的源代码构建的，这使得攻击者通过损害构建管道将恶意代码注入容器镜像变得更为困难。
列表：简化的 CI/CD 和 GitOps 工作流：您可以使用可重复生成的功能，使用基于 Git 的工作流(GitOps)管理整个操作系统配置和应用程序堆栈。对 Containerfile 的更改保证了所有环境中一致的可引导镜像。可重现的构建构成自动化 CI/CD 管道的基石。
列表：可重现的容器构建对于 RHEL AI 至关重要，它们为 AI 模型开发和部署提供了所需的基础一致性、安全性和效率。RHEL AI 提供可引导的容器镜像，这意味着它将操作系统本身作为容器工件进行管理。可重复性可确保此基础 AI 环境始终一致且可信。

6.3. 在 RHEL 容器工具中实现可复现性。

要点：要在构建过程中控制时间戳和其他非确定因素，您可以使用 RHEL 容器工具（如 Buildah、Podman 和 Skopeo）来实现构建可重复性。
要点：RHEL 容器工具提供标准化、无守护进程和脚本化的工作流，以实现可重复性。这种方法可确保容器构建一次即可在任何位置一致运行，解决与依赖项、环境和版本相关的潜在问题。
列表：--rewrite-timestamp：此选项会将镜像层内容的时间戳重写为不晚于 -source-date-epoch 的时间。另外，控制镜像创建的时间戳以及其层中文件的时间戳，主要用于实现确定性构建。
列表：--source-date-epoch：此选项比旧的 timestamp 选项更灵活，允许您为镜像层中的所有文件定义一个特定的、可重现的时间戳。它会影响镜像元数据中的创建和历史记录日期。您可以使用 CLI 标志、环境变量或 build-arg 来设置它。设置标志后，已声明的 ARG 会公开在 RUN 指令环境中，并获取静态主机名。另外，容器 ID 字段会在提交的镜像中被清除。 Podman podman build 命令虽然是面向用户的接口，但实际的镜像创建过程由 Buildah 库负责执行。Podman 采用了与 Buildah 相同的核心构建能力，而 Buildah 的设计重点是控制构建过程中各种非确定性因素，因此可实现可重现…
注意：注意使用 --source-date-epoch 和 --rewrite-timestamp 选项可以提高构建可重复性。但是，完全的可重复性无法保证。使用 COPY 指令的 --from 选项从其他镜像添加的内容可通过 RUN 指令的 --mount=from= 选项进行访问。您还可以使用 ADD 指令下载，但如果引用的镜像标签随后发生移动，或指定 URL 的内容发生变化，则构建结果可能会发生改变。

6.4. 使用可复现成的容器构建

要点：通过在 Podman 或 Buildah 中指定时间戳选项来构建可复现的容器镜像。通过使用 --source-date-epoch 和 --rewrite-timestamp 选项，您可以创建在不同构建之间保持完全一致的确定性镜像。
要点：流程
列表：您可以在运行 Buildah 命令时设置选项。例如，要从 Containerfile 构建镜像，并将所有时间戳强制到特定时间点： Use a specific, immutable image. FROM registry.access.redhat.com/ubi10/ubi:10.0 AS builder # Set the SOURCE_DATE_EPOCH for deterministic timestamps ARG SOURCE_DATE_EPOCH ENV SOURCE_DATE_EPOCH=${SOURCE_DATE_EPOCH:-1} # Build the image using the build-arg …
列表：运行带有一致时间戳的 podman build 命令，以创建可复现的镜像： # Set a consistent timestamp using the last Git commit date export SOURCE_DATE_EPOCH=$(git log -1 --pretty=%ct)
列表：使用指定时间戳构建镜像： podman build --source-date-epoch=${SOURCE_DATE_EPOCH} --rewrite-timestamp -t my-reproducible-app .
列表：构建后，再次运行可重复生成的命令。如果构建真正可重复生成，buildah inspect 命令应显示相同的镜像摘要。 buildah bud --source-date-epoch=${SOURCE_DATE_EPOCH} \ --rewrite-timestamp \ -f Containerfile \ -t my-reproducible-image-2 .
列表：比较摘要： buildah inspect --format '{{.Digest}}' my-reproducible-image buildah inspect --format '{{.Digest}}' my-reproducible-image-2
命令/配置摘录：

Use a specific, immutable image. FROM registry.access.redhat.com/ubi10/ubi:10.0 AS builder # Set the SOURCE_DATE_EPOCH for deterministic timestamps ARG SOURCE_DATE_EPOCH ENV SOURCE_DATE_EPOCH=${SOURCE_DATE_EPOCH:-1} # Build the image using the build-arg and rewrite-timestamp options buildah bud --source-date-epoch=${SOURCE_DATE_EPOCH} \  --rewrite-timestamp \  -f Containerfile \  -t my-reproducible-image .
# Set a consistent timestamp using the last Git commit date export SOURCE_DATE_EPOCH=$(git log -1 --pretty=%ct)

第 7 章将软件添加到 UBI 容器中

要点：通过从红帽软件仓库安装其他软件来增强通用基础镜像(UBI)。您可以根据镜像类型，使用 dnf 或 microdnf 将软件包添加到正在运行的容器中。
要点：红帽从 RHEL 内容的子集构建 UBI。UBI 还提供 RHEL 软件包的子集，可自由安装它们以用于 UBI。您可以使用 DNF 软件仓库（包括 RPM 软件包和更新）为正在运行的容器添加或更新软件。UBIs 提供了一组预构建的语言运行时容器镜像，如 Python、Perl、Node.js、Ruby 等。
列表：在 UBI init 和 UBI 标准镜像中，使用 dnf 命令
列表：在 UBI 最小镜像上，请使用 microdnf 命令

7.1. 使用 UBI init 镜像

要点：构建使用 UBI init 镜像运行系统服务的容器。您可以将应用程序（如 Web 服务器）配置为使用 systemd 在容器中自动启动。
要点：您可以使用 Containerfile 构建容器。当容器在主机系统上运行时，它将安装和配置 Web 服务器(httpd)，使其由 systemd 服务(/sbin/init)自动启动。podman build 命令使用一个或多个 Containerfile 中的指令和指定的构建上下文目录构建镜像。
列表：container-tools 元数据包已安装。
列表：在新目录中创建一个包含以下内容的 Containerfile ： FROM registry.access.redhat.com/ubi10/ubi-init RUN dnf -y install httpd; dnf clean all; systemctl enable httpd; RUN echo "Successful Web Server Test" > /var/www/html/index.html RUN mkdir /etc/systemd/system/httpd.service.d/; echo -e '[Service]\nRestart=always' > /etc/systemd/system/htt…
列表：构建容器： # podman build --format=docker -t mysysd .
列表：可选：如果要使用 systemd 运行容器，且在您的系统上启用了 SELinux，您必须设置 container_manage_cgroup 布尔值变量： # setsebool -P container_manage_cgroup 1
列表：运行名为 mysysd_run 的容器： # podman run -d --name=mysysd_run -p 80:80 mysysd mysysd 镜像作为守护进程运行 mysysd_run 容器，容器的端口 80 公开给主机系统上的端口 80。注意在 rootless 模式中，您必须选择主机端口号 >= 1024。例如： $ podman run -d --name=mysysd -p 8081:80 mysysd 要使用 < 1024 的端口号，您必须修改 net.ipv4.ip_unprivileged_port_start 变量： # sysctl net.ipv4.ip_unprivileged_port_…
列表：检查容器是否正在运行： # podman ps a282b0c2ad3d localhost/mysysd:latest /sbin/init 15 seconds ago Up 14 seconds ago 0.0.0.0:80->80/tcp mysysd_run
命令/配置摘录：

FROM registry.access.redhat.com/ubi10/ubi-init RUN dnf -y install httpd; dnf clean all; systemctl enable httpd; RUN echo "Successful Web Server Test" > /var/www/html/index.html RUN mkdir /etc/systemd/system/httpd.service.d/; echo -e '[Service]\nRestart=always' > /etc/systemd/system/httpd.service.d/httpd.conf EXPOSE 80 CMD [ "/sbin/init" ]
# podman build --format=docker -t mysysd .

注意：注意在 rootless 模式中，您必须选择主机端口号 >= 1024。例如： $ podman run -d --name=mysysd -p 8081:80 mysysd 要使用 < 1024 的端口号，您必须修改 net.ipv4.ip_unprivileged_port_start 变量： # sysctl net.ipv4.ip_unprivileged_port_start=80

7.2. 使用 UBI 微镜像

要点：使用 UBI micro 镜像和 Buildah 构建超轻量级容器。该流程通过将镜像挂载到主机，然后由主机向镜像安装软件来完成，因为镜像本身没有软件包管理器。
要点：先决条件
列表：container-tools 元数据包已安装。
列表：拉取并构建 registry.access.redhat.com/ubi10/ubi-micro 镜像： # microcontainer=$(buildah from registry.access.redhat.com/ubi10/ubi-micro)
列表：挂载可正常工作的容器根文件系统： # micromount=$(buildah mount $microcontainer)
列表：将 httpd 服务安装到 micromount 目录中： # dnf install \ --installroot $micromount \ --releasever=/ \ --setopt install_weak_deps=false \ --setopt=reposdir=/etc/yum.repos.d/ \ --nodocs -y \ httpd # dnf clean all \ --installroot $micromount
列表：在工作容器中卸载根文件系统： # buildah umount $microcontainer
列表：从工作容器创建 ubi-micro-httpd 镜像： # buildah commit $microcontainer ubi-micro-httpd
命令/配置摘录：

# microcontainer=$(buildah from registry.access.redhat.com/ubi10/ubi-micro)
# micromount=$(buildah mount $microcontainer)

7.3. 在订阅的主机上将软件添加到 UBI 容器中

要点：在订阅的 RHEL 主机上运行时，可以访问 UBI 容器中的完整 RHEL 软件仓库。这样可以安装比标准 UBI 软件仓库中所提供的更多的软件包。
要点：如果您在注册和订阅的 RHEL 主机上运行 UBI 容器，会在标准 UBI 容器以及所有 UBI 软件仓库中启用 RHEL Base 和 AppStream 存储库。
列表：红帽权利从订阅的红帽主机传递，作为在运行 Podman 的主机上的 /usr/share/containers/mounts.conf 中定义的 secret 挂载。验证挂载配置： $ cat /usr/share/containers/mounts.conf /usr/share/rhel/secrets:/run/secrets
列表：yum、dnf 和 microdnf 命令应该在此路径中搜索授权数据。
列表：如果路径不存在，命令无法使用红帽授权的内容，如 RHV 存储库，因为它们缺少主机拥有的密钥或内容访问权限。
列表：这只适用于 RHEL 主机上红帽附带或提供的 Podman。
列表：如何将订阅数据附加到不是由红帽提供的 Docker 中运行的容器？
命令/配置摘录：

$ cat /usr/share/containers/mounts.conf /usr/share/rhel/secrets:/run/secrets

7.4. 在标准 UBI 容器中添加软件

要点：要在标准 UBI 容器中添加软件，请禁用非 UBI DNF 存储库，以确保您构建的容器可以被重新分发。
要点：先决条件
列表：container-tools 元数据包已安装。
列表：拉取并运行 registry.access.redhat.com/ubi10/ubi 镜像： $ podman run -it --name myubi registry.access.redhat.com/ubi10/ubi
列表：将软件包添加到 myubi 容器。要添加在 UBI 存储库中的软件包，请禁用除 UBI 软件仓库以外的所有 dnf 软件仓库。例如，要添加 bzip2 软件包： # dnf install --disablerepo==* --enablerepo=ubi-10-for-x86_64-appstream-rpms --enablerepo=ubi-10-for-x86_64-baseos-rpms bzip2 要添加不在 UBI 存储库中的软件包，请不要禁用任何存储库。例如，要添加 zsh 软件包： # dnf install zsh 要添加位于不同主机存储库中的软件包，请明确启用您需要的存储库。例如，要从 codeready-…
列表：要添加在 UBI 存储库中的软件包，请禁用除 UBI 软件仓库以外的所有 dnf 软件仓库。例如，要添加 bzip2 软件包： # dnf install --disablerepo==* --enablerepo=ubi-10-for-x86_64-appstream-rpms --enablerepo=ubi-10-for-x86_64-baseos-rpms bzip2
列表：要添加不在 UBI 存储库中的软件包，请不要禁用任何存储库。例如，要添加 zsh 软件包： # dnf install zsh
列表：要添加位于不同主机存储库中的软件包，请明确启用您需要的存储库。例如，要从 codeready-builder-for-ubi-10-x86_64-rpms 存储库中安装 python3-devel 软件包： # dnf install --enablerepo=codeready-builder-for-ubi-10-x86_64-rpms python3-devel
命令/配置摘录：

$ podman run -it --name myubi registry.access.redhat.com/ubi10/ubi
# dnf install --disablerepo==* --enablerepo=ubi-10-for-x86_64-appstream-rpms --enablerepo=ubi-10-for-x86_64-baseos-rpms bzip2

注意：注意安装不在 Red Hat UBI 存储库中的红帽软件包可以限制在订阅的 RHEL 系统外分发容器的能力。

7.5. 在最小的 UBI 容器中添加软件

要点：使用 microdnf 命令，在最小 UBI 容器中安装软件。此命令提供基本的软件包管理功能，同时尽可能减小容器镜像的体积。
要点：先决条件
列表：container-tools 元数据包已安装。
列表：拉取并运行 registry.access.redhat.com/ubi10/ubi-minimal 镜像： $ podman run -it --name myubimin registry.access.redhat.com/ubi10/ubi-minimal
列表：将软件包添加到 myubimin 容器：要添加 UBI 存储库中的软件包，请不要禁用任何存储库。例如，要添加 bzip2 软件包： # microdnf install bzip2 --setopt install_weak_deps=0 要添加位于不同主机存储库中的软件包，请明确启用您需要的存储库。例如，要从 codeready-builder-for-rhel-10-x86_64-rpms 存储库中安装 python3-devel 软件包： # microdnf install --enablerepo=codeready-builder-for-rhel-10-x86_64-rpms python3-devel --set…
列表：要添加 UBI 存储库中的软件包，请不要禁用任何存储库。例如，要添加 bzip2 软件包： # microdnf install bzip2 --setopt install_weak_deps=0
列表：要添加位于不同主机存储库中的软件包，请明确启用您需要的存储库。例如，要从 codeready-builder-for-rhel-10-x86_64-rpms 存储库中安装 python3-devel 软件包： # microdnf install --enablerepo=codeready-builder-for-rhel-10-x86_64-rpms python3-devel --setopt install_weak_deps=0 --setopt install_weak_deps=false 选项禁用弱依赖项的安装。弱依赖项包括建议或推荐的软件包，这些软件包不是严格要求的，但通常被默认安装。
列表：列出容器内所有启用的存储库： # microdnf repolist
命令/配置摘录：

$ podman run -it --name myubimin registry.access.redhat.com/ubi10/ubi-minimal
# microdnf install bzip2 --setopt install_weak_deps=0

注意：注意安装不在 Red Hat UBI 存储库中的红帽软件包可以限制在订阅的 RHEL 系统外分发容器的能力。

7.6. 将软件添加到未订阅的主机上的 UBI 容器中

要点：使用默认 UBI 软件仓库将软件添加到未订阅的主机上的 UBI 容器中。这些软件仓库可自由使用，不需要 RHEL 订阅才能访问。
要点：先决条件
列表：container-tools 元数据包已安装。
列表：将软件包添加到基于 UBI standard 或 UBI init 镜像的正在运行的容器中。不要禁用任何存储库。使用 podman run 命令运行容器。然后在容器中使用 dnf install 命令。例如，要将 bzip2 软件包添加到基于 UBI 标准的容器中： $ podman run -it --name myubi registry.access.redhat.com/ubi10/ubi # dnf install bzip2 例如，要将 bzip2 软件包添加到基于 UBI init 的容器中： $ podman run -it --name myubimin registry.access.redhat.com/u…
列表：例如，要将 bzip2 软件包添加到基于 UBI 标准的容器中： $ podman run -it --name myubi registry.access.redhat.com/ubi10/ubi # dnf install bzip2
列表：例如，要将 bzip2 软件包添加到基于 UBI init 的容器中： $ podman run -it --name myubimin registry.access.redhat.com/ubi10/ubi-init # microdnf install bzip2
列表：列出所有启用的存储库：要列出基于 UBI standard 或 UBI init 镜像的容器中所有已启用的存储库： # dnf repolist 要列出基于 UBI minimal 镜像的容器中所有已启用的存储库： # microdnf repolist
列表：要列出基于 UBI standard 或 UBI init 镜像的容器中所有已启用的存储库： # dnf repolist
命令/配置摘录：

$ podman run -it --name myubi registry.access.redhat.com/ubi10/ubi # dnf install bzip2
$ podman run -it --name myubimin registry.access.redhat.com/ubi10/ubi-init # microdnf install bzip2

7.7. 构建基于 UBI 的镜像

要点：您可以使用 Buildah 工具从 Containerfile 创建基于 UBI 的 web 服务器容器。您必须禁用所有非 UBI dnf 软件仓库，以确保您的镜像只包含可重新分发的红帽软件。
要点：先决条件
列表：container-tools 元数据包已安装。
列表：创建 Containerfile ： FROM registry.access.redhat.com/ubi10/ubi USER root LABEL maintainer="John Doe" # Update image RUN dnf update --disablerepo=* --enablerepo=ubi-10-appstream-rpms --enablerepo=ubi-10-baseos-rpms -y && rm -rf /var/cache/yum RUN dnf install --disablerepo=* --enablerepo=ubi-10-appstream-rpms --enablerepo…
列表：构建容器镜像： # buildah bud -t johndoe/webserver . STEP 1: FROM registry.access.redhat.com/ubi10/ubi:latest STEP 2: USER root STEP 3: LABEL maintainer="John Doe" STEP 4: RUN dnf update --disablerepo=* --enablerepo=ubi-10-appstream-rpms --enablerepo=ubi-10-baseos-rpms -y ... Writing manifest to image destination Storing sign…
列表：运行 web 服务器： # podman run -d --name=myweb -p 80:80 johndoe/webserver bbe98c71d18720d966e4567949888dc4fb86eec7d304e785d5177168a5965f64
列表：测试 Web 服务器： # curl http://localhost/index.html The Web Server is Running
命令/配置摘录：

FROM registry.access.redhat.com/ubi10/ubi USER root LABEL maintainer="John Doe" # Update image RUN dnf update --disablerepo=* --enablerepo=ubi-10-appstream-rpms --enablerepo=ubi-10-baseos-rpms -y && rm -rf /var/cache/yum RUN dnf install --disablerepo=* --enablerepo=ubi-10-appstream-rpms --enablerepo=ubi-10-baseos-rpms httpd -y && rm -rf /var/cache/yum # Add default Web page and expose port RUN echo "The Web Server is Running" > /var/www/html/index.html EXPOSE 80 # Start the service CMD ["-D", "FOREGROUND"] ENTRYPOINT ["/usr/sbin/httpd"]
# buildah bud -t johndoe/webserver . STEP 1: FROM registry.access.redhat.com/ubi10/ubi:latest STEP 2: USER root STEP 3: LABEL maintainer="John Doe" STEP 4: RUN dnf update --disablerepo=* --enablerepo=ubi-10-appstream-rpms --enablerepo=ubi-10-baseos-rpms -y ... Writing manifest to image destination Storing signatures --> f9874f27050 f9874f270500c255b950e751e53d37c6f8f6dba13425d42f30c2a8ef26b769f2

注意：注意对于 UBI 最小镜像，请使用 microdnf 而不是 dnf:RUN microdnf update -y && rm -rf /var/cache/yum 和 RUN microdnf install httpd -y && microdnf clean all 命令。

7.8. 使用 Application Stream 运行时镜像

要点：使用 Application Stream 运行时镜像作为应用程序的基础。这些镜像为 Python、Ruby 和 Node.js 等语言提供预构建环境。
要点：支持的运行时镜像有 Python、Ruby、s2-core、s2i-base、.NET Core、PHP。运行时镜像在 Red Hat Container Catalog 中提供。
列表：红帽容器镜像目录
列表：红帽容器镜像更新
列表：使用 Red Hat Software Collections Container Images 指南
注意：注意由于这些 UBI 镜像与其传统镜像版本包含相同的基础软件，所以您可以从 Red Hat Software Collections Container Images 指南中了解这些镜像。

7.9. 获取 UBI 容器镜像源代码

要点：通过下载对应的源容器镜像来访问 UBI 镜像的源代码。使用 Skopeo 检索和解包这些镜像，以检查其底层内容。
要点：源代码以可下载容器镜像的形式提供给所有基于 UBI 的红帽镜像。虽然源容器镜像被打包为容器，但无法运行。要在您的系统上安装红帽源容器镜像，请使用 skopeo 命令，而不是 podman pull 命令。
列表：container-tools 元数据包已安装。
列表：使用 skopeo copy 命令将源容器镜像复制到本地目录中： $ skopeo copy \ docker://registry.access.redhat.com/ubi10:8.1-397-source \ dir:$HOME/TEST ... Copying blob 477bc8106765 done Copying blob c438818481d3 done ... Writing manifest to image destination Storing signatures
列表：使用 skopeo inspect 命令检查源容器镜像： $ skopeo inspect dir:$HOME/TEST { "Digest": "sha256:7ab721ef3305271bbb629a6db065c59bbeb87bc53e7cbf88e2953a1217ba7322", "RepoTags": [], "Created": "2020-02-11T12:14:18.612461174Z", "DockerVersion": "", "Labels": null, "Architecture": "amd64", "Os": "linux", "Layers": [ "sha256:1ae7…
列表：解包所有内容： $ cd $HOME/TEST $ for f in $(ls); do tar xvf $f; done
列表：检查结果： $ find blobs/ rpm_dir/ blobs/ blobs/sha256 blobs/sha256/10914f1fff060ce31388f5ab963871870535aaaa551629f5ad182384d60fdf82 rpm_dir/ rpm_dir/gzip-1.9-4.el8.src.rpm 如果结果正确，则镜像可以使用。注意发布容器镜像后可能需要几小时时间才能使用其相关源容器。如需更多信息，请参阅系统中的 skopeo-copy (1) 和 skopeo-inspect (1) 手册页。
命令/配置摘录：

$ skopeo copy \ docker://registry.access.redhat.com/ubi10:8.1-397-source \ dir:$HOME/TEST ... Copying blob 477bc8106765 done Copying blob c438818481d3 done ... Writing manifest to image destination Storing signatures
$ skopeo inspect dir:$HOME/TEST {  "Digest": "sha256:7ab721ef3305271bbb629a6db065c59bbeb87bc53e7cbf88e2953a1217ba7322",  "RepoTags": [],  "Created": "2020-02-11T12:14:18.612461174Z",  "DockerVersion": "",  "Labels": null,  "Architecture": "amd64",  "Os": "linux",  "Layers": [  "sha256:1ae73d938ab9f11718d0f6a4148eb07d38ac1c0a70b1d03e751de8bf3c2c87fa",  "sha256:9fe966885cb8712c47efe5ecc2eaa0797a0d5ffb8b119c4bd4b400cc9e255421",  "sha256:61b2527a4b836a4efbb82dfd449c0556c0f769570a6c02e112f88f8bbcd90166",  ...  "sha256:cc56c782b513e2bdd2cc2af77b69e13df4ab624ddb856c4d086206b46b9b9e5f",  "sha256:dcf9396fdada4e6c1ce667b306b7f08a83c9e6b39d0955c481b8ea…

注意：注意发布容器镜像后可能需要几小时时间才能使用其相关源容器。

第 8 章签名容器镜像

要点：您可以使用 Podman 和 sigstore 签名在 Red Hat Enterprise Linux 中签署容器镜像，以确保符合 OCI 兼容的容器 registry 中的镜像真实性和完整性，而无需单独的查找服务器。签名容器镜像有助于防止供应链攻击。

8.1. 使用私钥通过 sigstore 签名签名容器镜像

要点：要使用 Red Hat Enterprise Linux (RHEL)上的私钥通过 sigstore 签名为容器镜像签名，您可以使用带有本地管理的密钥对的 Podman 工具。
要点：先决条件
列表：container-tools 元数据包已安装。
列表：生成 sigstore 公钥或私钥对： $ skopeo generate-sigstore-key --output-prefix myKey.private
列表：在 /etc/containers/registries.d/default.yaml 文件中添加以下内容： docker: <registry>: use-sigstore-attachments: true 通过设置 use-sigstore-attachments 选项，Podman 和 Skopeo 可以将容器 sigstore 签名与镜像一起读写，并将它们保存在与签名镜像相同的存储库中。您可以在 /etc/containers/registries.d/default.yaml 文件中编辑系统范围的注册中心配置。您还可以编辑 /etc/containers/registries.d 目录中任何 YAML 文件中的注…
列表：使用当前目录中的 Containerfile 构建容器镜像： $ podman build -t <registry>/<namespace>/<image>
列表：为镜像签名并将其推送到注册中心： $ podman push --sign-by-sigstore-private-key ./myKey.private <registry>/<namespace>/<image> podman push 命令将 <registry>/<namespace>/<image> 本地镜像推送到远程的注册中心作为 <registry>/<namespace>/<image>。--sign-by-sigstore-private-key 选项使用 myKey.private 私钥向 < registry>/<namespace>/<image> 镜像添加一个 sigstore 签名。镜像和 sigsto…
列表：拉取镜像： $ podman pull <registry>/<namespace>/<image> 您需要运行 podman pull 命令，以确保按照我们的配置要求强制镜像签名。如果您尝试从配置的 registry 中拉取未签名或使用错误密钥签名的镜像，命令将失败。
命令/配置摘录：

$ skopeo generate-sigstore-key --output-prefix myKey.private
docker:  <registry>:  use-sigstore-attachments: true

注意：注意如果您需要在容器注册中心间移动现有镜像时为现有镜像签名，您可以使用 skopeo copy 命令。

8.2. 使用 Fulcio 和 Rekor 使用 sigstore 签名签名容器镜像

要点：使用 Fulcio 和 Rekor 服务器，您可以使用基于 OpenID Connect (OIDC)服务器身份验证的短期证书来创建签名，而不是手动管理私钥。
要点：先决条件
列表：container-tools 元数据包已安装。
列表：您有 Fulcio (https:// <your-fulcio-server>)和 Rekor (https://<your-rekor-server>)服务器正在运行，且配置了。
列表：podman 已安装。
列表：在 /etc/containers/registries.conf.d/default.yaml 文件中添加以下内容： docker: <registry>: use-sigstore-attachments: true 通过设置 use-sigstore-attachments 选项，Podman 和 Skopeo 可以将容器 sigstore 签名与镜像一起读写，并将它们保存在与签名镜像相同的存储库中。您可以编辑 /etc/containers/registries.d/ 目录中任何 YAML 文件中的 registry 或存储库配置部分。在 /etc/containers/registries.d/ 目录里，每个作用域…
列表：创建 /etc/containers/registries.d/file.yml 文件： fulcio: fulcioURL: "https://<your-fulcio-server>" oidcMode: "interactive" oidcIssuerURL: "https://<your-OIDC-provider>" oidcClientID: "sigstore" rekorURL: "https://<your-rekor-server>" file.yml 是 sigstore 签名参数 YAML 文件，其用于存储创建 sigstore 签名所需的选项。
列表：为镜像签名并将其推送到注册中心： $ podman push --sign-by-sigstore=file.yml <registry>/<namespace>/<image> 您还可以使用带有类似 --sign-by-sigstore 选项的 skopeo copy 命令来为现有镜像签名，同时将它们在多个容器注册中心之间移动。警告请注意，您提交至公共服务器的包括公钥、证书和签名元数据。如需更多信息，请参阅系统中的 containers-sigstore-signing-params.yaml,podman-push (1) 和 container-registries.d 手册页。
命令/配置摘录：

docker:  <registry>:  use-sigstore-attachments: true
fulcio:  fulcioURL: "https://<your-fulcio-server>"  oidcMode: "interactive"  oidcIssuerURL: "https://<your-OIDC-provider>"  oidcClientID: "sigstore" rekorURL: "https://<your-rekor-server>"

注意：警告请注意，您提交至公共服务器的包括公钥、证书和签名元数据。

8.3. 使用私钥和 Rekor ，用 sigstore 签名签名容器镜像

要点：您可以使用带有私钥和 Rekor 的 sigstore 在 Red Hat Enterprise Linux 中签署容器镜像，以确保软件供应链中的镜像的完整性。
要点：先决条件
列表：container-tools 元数据包已安装。
列表：生成 sigstore 公钥或私钥对： $ skopeo generate-sigstore-key --output-prefix myKey.private 生成公钥和私钥 myKey.pub 和 myKey.private。
列表：将以下内容添加到 /etc/containers/registries.conf.d/default.yaml 文件中： docker: <registry>: use-sigstore-attachments: true 通过设置 use-sigstore-attachments 选项，Podman 和 Skopeo 可以将容器 sigstore 签名与镜像一起读写，并将它们保存在与签名镜像相同的存储库中。注意您可以编辑 /etc/containers/registries.d/ 目录中任何 YAML 文件中的 registry 或存储库配置部分。在 /etc/containers/registries.d/ 目录里，每…
列表：使用当前目录中的 Containerfile 构建容器镜像： $ podman build -t <registry>/<namespace>/<image>
列表：创建 /etc/containers/registries.d/file.yml 文件： privateKeyFile: "/home/user/sigstore/myKey.private" privateKeyPassphraseFile: "/mnt/user/sigstore-myKey.private-passphrase" rekorURL: "https://<your-rekor-server>" file.yml 是 sigstore 签名参数 YAML 文件，其用于存储创建 sigstore 签名所需的选项。
列表：为镜像签名并将其推送到注册中心： $ podman push --sign-by-sigstore=file.yml <registry>/<namespace>/<image> 您还可以使用带有类似 --sign-by-sigstore 选项的 skopeo copy 命令来为现有镜像签名，同时将它们在多个容器注册中心之间移动。警告请注意，您对公共服务器的提交包括有关公钥的数据和有关签名的元数据。
命令/配置摘录：

$ skopeo generate-sigstore-key --output-prefix myKey.private
docker:  <registry>:  use-sigstore-attachments: true

注意：注意您可以编辑 /etc/containers/registries.d/ 目录中任何 YAML 文件中的 registry 或存储库配置部分。在 /etc/containers/registries.d/ 目录里，每个作用域（default-docker、registry 或 namespace）只能出现在一个文件中。您还可以在 /etc/containers/registries.d/default.yaml 文件中编辑系统范围的 registry 配置。请注意，该目录中的所有 YAML 文件都会被读取，因此文件名可以任意命名。
注意：警告请注意，您对公共服务器的提交包括有关公钥的数据和有关签名的元数据。

8.4. 使用 GPG 签名为容器镜像签名

要点：使用 GPG 签名签署 Red Hat Enterprise Linux 容器镜像以建立信任并验证软件来源。应用这些加密签名可确保您的镜像不被篡改，防止基础设施部署被破坏的应用程序影响。
要点：先决条件
列表：container-tools 元软件包和 GPG 工具已安装。
列表：备用 Web 服务器已建立，您可以在其上发布文件。您可以在 /etc/containers/registries.d/default.yaml 文件中检查系统范围的注册中心配置。lookaside-staging 选项引用签名写入的文件路径，通常在主机发布签名上设置。 # cat /etc/containers/registries.d/default.yaml
列表：生成一个 GPG 密钥： # gpg --full-gen-key
列表：导出公钥： # gpg --output <path>/key.gpg --armor --export <username@example.com>
列表：使用当前目录中的 Containerfile 构建容器镜像： $ podman build -t <registry>/<namespace>/<image> 将 <registry>, <namespace> 和 <image> 替换为容器镜像标识符。
列表：为镜像签名并将其推送到注册中心： $ podman push \ --sign-by <username@example.com> \ <registry>/<namespace>/<image> 注意如果您需要在容器注册中心间移动现有镜像时为现有镜像签名，您可以使用 skopeo copy 命令。
命令/配置摘录：

# cat /etc/containers/registries.d/default.yaml
docker:  <registry>:  lookaside: https://registry-lookaside.example.com  lookaside-staging: file:///var/lib/containers/sigstore

注意：注意如果您需要在容器注册中心间移动现有镜像时为现有镜像签名，您可以使用 skopeo copy 命令。

8.5. 使用 Sequoia PGP 在 Podman 中签名容器镜像

要点：通过将后端切换到 Sequoia PGP，您可以使用现代和后量子密码学（PQC）算法，从而增强镜像签名验证能力。现有的 GnuPG 工作流仍可用于签名。
要点：先决条件
列表：container-tools meta 软件包已安装。
列表：podman-sequoia、sequoia-sq 和 sequoia-sqv 软件包已安装。
列表：使用当前目录中的 Containerfile 构建容器镜像： $ podman build -t <registry>/<namespace>/<image>
列表：生成密钥： # sq key generate --own-key --email <test@example.com> --name <namspace>
列表：导出证书： # sq cert export --cert=<fingerprint_or_key_ID> --output mycerts/sequoia-key.pub
列表：配置 policy.json 文件以指向有效的密钥。
命令/配置摘录：

$ podman build -t <registry>/<namespace>/<image>
# sq key generate --own-key --email <test@example.com> --name <namspace>

第 9 章使用 pod

要点：将相关容器分组到 pod 中，以便共享命名空间和资源。您可以使用 OpenShift 或 Kubernetes 中最小计算单元的 pod 将多个容器作为一个单元进行管理。

9.1. 创建 pod

要点：要共享网络和存储资源，您可以在 pod 中添加容器。每个 Podman pod 都包括一个 infra 容器，用于管理命名空间，并允许其他容器连接、启动和停止、保持 pod 运行。
要点：先决条件
列表：container-tools 元数据包已安装。
列表：创建空 pod: $ podman pod create --name mypod 223df6b390b4ea87a090a4b5207f7b9b003187a6960bd37631ae9bc12c433aff The pod is in the initial state Created. pod 处于 Created 的初始状态。
列表：可选：列出所有 pod： $ podman pod ps POD ID NAME STATUS CREATED # OF CONTAINERS INFRA ID 223df6b390b4 mypod Created Less than a second ago 1 3afdcd93de3e 请注意，pod 有一个容器。
列表：可选：列出与其关联的所有 pod 和容器： $ podman ps -a --pod CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES POD 3afdcd93de3e registry.access.redhat.com/ubi10/pause Less than a second ago Created 223df6b390b4-infra 223df6b390b4 您可以看到 podman ps 命令中的 pod ID 与 podman pod ps 命令中的 pod ID 匹配。默认 infra 容器是基于 registry.access.redhat.com/ub…
列表：在名为 mypod 的现有 pod 中运行名为 myubi 的容器： $ podman run -dt --name myubi --pod mypod registry.access.redhat.com/ubi10/ubi /bin/bash 5df5c48fea87860cf75822ceab8370548b04c78be9fc156570949013863ccf71
列表：可选：列出所有 pod： $ podman pod ps POD ID NAME STATUS CREATED # OF CONTAINERS INFRA ID 223df6b390b4 mypod Running Less than a second ago 2 3afdcd93de3e 您可以看到 pod 有两个容器。
命令/配置摘录：

$ podman pod create --name mypod 223df6b390b4ea87a090a4b5207f7b9b003187a6960bd37631ae9bc12c433aff The pod is in the initial state Created.
$ podman pod ps POD ID NAME STATUS CREATED # OF CONTAINERS INFRA ID 223df6b390b4 mypod Created Less than a second ago 1 3afdcd93de3e

9.2. 显示 pod 信息

要点：查看有关 pod 的详细信息，包括状态和关联的容器。这有助于监控 pod 组的健康状态和配置。
要点：如需更多信息，请参阅系统中的 podman-pod-top (1)、podman-pod-stats (1) 和 podman-pod-inspect (1) 手册页。
列表：container-tools 元数据包已安装。
列表：pod 已创建。详情请参阅创建 pod 一节。
列表：显示在 pod 中运行的活跃进程：要显示 pod 中容器的运行进程，请输入： $ podman pod top mypod USER PID PPID %CPU ELAPSED TTY TIME COMMAND 0 1 0 0.000 24.077433518s ? 0s /pause root 1 0 0.000 24.078146025s pts/0 0s /bin/bash 要显示一个或多个 pod 中容器的资源使用情况统计的实时流，请输入： $ podman pod stats -a --no-stream ID NAME CPU % MEM USAGE / LIMIT MEM % NET IO BLOCK IO PID…
列表：要显示 pod 中容器的运行进程，请输入： $ podman pod top mypod USER PID PPID %CPU ELAPSED TTY TIME COMMAND 0 1 0 0.000 24.077433518s ? 0s /pause root 1 0 0.000 24.078146025s pts/0 0s /bin/bash
列表：要显示一个或多个 pod 中容器的资源使用情况统计的实时流，请输入： $ podman pod stats -a --no-stream ID NAME CPU % MEM USAGE / LIMIT MEM % NET IO BLOCK IO PIDS a9f807ffaacd frosty_hodgkin -- 3.092MB / 16.7GB 0.02% -- / -- -- / -- 2 3b33001239ee sleepy_stallman -- -- / -- -- -- / -- -- / -- --
列表：要显示描述 pod 的信息，请输入： $ podman pod inspect --format json <POD_ID_1> <POD_ID_2> <POD_ID_3> [ { "CgroupParent": "/libpod_parent", "Containers": [ { "ID": "...", "State": "..." } ], "Created": "2025-10-16T12:00:00.000000000Z", "ID": "673f326c9f69b0d24c0847f97a544c79532817d2a713917812f865f1e8e52a8a", "InfraContain…
命令/配置摘录：

$ podman pod top mypod USER PID PPID %CPU ELAPSED TTY TIME COMMAND 0 1 0 0.000 24.077433518s ? 0s /pause root 1 0 0.000 24.078146025s pts/0 0s /bin/bash
$ podman pod stats -a --no-stream ID NAME CPU % MEM USAGE / LIMIT MEM % NET IO BLOCK IO PIDS a9f807ffaacd frosty_hodgkin -- 3.092MB / 16.7GB 0.02% -- / -- -- / -- 2 3b33001239ee sleepy_stallman -- -- / -- -- -- / -- -- / -- --

注意：注意从 Podman v5.0.0 开始，pod 输出始终是一个 JSON 数组，与 pod 的数量无关。

9.3. 停止 pod

要点：使用 podman pod stop 命令停止整个 pod 及其包含所有容器。这有助于确保 pod 中的所有相关服务一起终止。
要点：先决条件
列表：container-tools 元数据包已安装。
列表：pod 已创建。详情请参阅创建 pod 一节。
列表：停止 pod mypod: $ podman pod stop mypod
列表：可选：列出与其关联的所有 pod 和容器： $ podman ps -a --pod CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES POD ID PODNAME 5df5c48fea87 registry.redhat.io/ubi10/ubi:latest /bin/bash About a minute ago Exited (0) 7 seconds ago myubi 223df6b390b4 mypod 3afdcd93de3e registry.access.redhat.com/10/pause About a minute ago Exited (0) …
命令/配置摘录：

$ podman pod stop mypod
$ podman ps -a --pod CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES POD ID PODNAME 5df5c48fea87 registry.redhat.io/ubi10/ubi:latest /bin/bash About a minute ago Exited (0) 7 seconds ago myubi 223df6b390b4 mypod 3afdcd93de3e registry.access.redhat.com/10/pause About a minute ago Exited (0) 7 seconds ago 8a4e6527ac9d-infra 223df6b390b4 mypod

9.4. 删除 pod

要点：使用 podman pod rm 命令删除已停止的 pod。这会从系统中删除 pod 定义以及所有关联的容器。
要点：先决条件
列表：container-tools 元数据包已安装。
列表：pod 已停止。详情请参阅停止 pod 一节。
列表：删除 pod mypod，请输入： $ podman pod rm mypod 223df6b390b4ea87a090a4b5207f7b9b003187a6960bd37631ae9bc12c433aff 请注意，删除 pod 会自动移除其中的所有容器。
命令/配置摘录：

$ podman pod rm mypod 223df6b390b4ea87a090a4b5207f7b9b003187a6960bd37631ae9bc12c433aff
$ podman ps $ podman pod ps

第 10 章管理容器网络

要点：管理容器网络，以控制容器和外部系统之间的通信。使用 Podman，您可以创建、检查和管理网络来隔离流量，并帮助保持安全性。

10.1. 列出容器网络

要点：您可以查看可用的容器网络，以显示网络名称、驱动程序和其他配置详情。Podman 支持 rootless 网络，其中网络会自动设置，容器没有 IP 地址，rootful 网络，其中容器具有 IP 地址。
要点：先决条件
列表：container-tools 元数据包已安装。
列表：以 root 用户身份列出所有网络： # podman network ls NETWORK ID NAME VERSION PLUGINS 2f259bab93aa podman 0.4.0 bridge,portmap,firewall,tuning 默认情况下，Podman 提供了一个桥接网络。 Rootful 用户的网络列表与无根用户相同。如需更多信息，请参阅系统中的 podman-network-ls (1) 手册页。
列表：默认情况下，Podman 提供了一个桥接网络。
列表：Rootful 用户的网络列表与无根用户相同。如需更多信息，请参阅系统中的 podman-network-ls (1) 手册页。
命令/配置摘录：

# podman network ls NETWORK ID NAME VERSION PLUGINS 2f259bab93aa podman 0.4.0 bridge,portmap,firewall,tuning

10.2. 检查网络

要点：使用 podman network inspect 命令查看特定网络的详细配置。这显示了子网、网关和启用的插件等设置。
要点：先决条件
列表：container-tools 元数据包已安装。
列表：检查默认 podman 网络： $ podman network inspect podman [ { "cniVersion": "0.4.0", "name": "podman", "plugins": [ { "bridge": "cni-podman0", "hairpinMode": true, "ipMasq": true, "ipam": { "ranges": [ [ { "gateway": "10.88.0.1", "subnet": "10.88.0.0/16" } ] ], "routes": [ { "dst": "0.0.0.0/0" } ], "type"…
命令/配置摘录：

$ podman network inspect podman [  {  "cniVersion": "0.4.0",  "name": "podman",  "plugins": [  {  "bridge": "cni-podman0",  "hairpinMode": true,  "ipMasq": true,  "ipam": {  "ranges": [  [  {  "gateway": "10.88.0.1",  "subnet": "10.88.0.0/16"  }  ]  ],  "routes": [  {  "dst": "0.0.0.0/0"  }  ],  "type": "host-local"  },  "isGateway": true,  "type": "bridge"  },  {  "capabilities": {  "portMappings": true  },  "type": "portmap"  },  {  "type": "firewall"  },  {  "type": "tuning"  }  ]  } ]

10.3. 创建网络

要点：使用 podman network create 命令为您的容器创建自定义网络。您可以配置外部访问，或创建隔离的内部网络来保护容器通信。
要点：默认情况下，Podman 创建一个外部网络。您可以创建一个内部网络，其中容器可以与主机上的其他容器通信，但不能连接到主机外的网络。
列表：container-tools 元数据包已安装。
列表：创建名为 mynet 的外部网络： # podman network create mynet /etc/cni/net.d/mynet.conflist
列表：列出所有网络： # podman network ls NETWORK ID NAME VERSION PLUGINS 2f259bab93aa podman 0.4.0 bridge,portmap,firewall,tuning 11c844f95e28 mynet 0.4.0 bridge,portmap,firewall,tuning,dnsname 您可以看到创建的 mynet 网络和默认 podman 网络。
命令/配置摘录：

# podman network create mynet /etc/cni/net.d/mynet.conflist
# podman network ls NETWORK ID NAME VERSION PLUGINS 2f259bab93aa podman 0.4.0 bridge,portmap,firewall,tuning 11c844f95e28 mynet 0.4.0 bridge,portmap,firewall,tuning,dnsname

注意：注意从 Podman 4.0 开始，如果使用 podman network create 命令创建新的外部网络，则默认启用 DNS 插件。

10.4. 将容器连接到网络

要点：要允许容器同时在多个网络中进行通信，您可以使用 podman network connect 命令将正在运行的容器附加到额外网络。
要点：先决条件
列表：container-tools 元数据包已安装。
列表：已使用 podman network create 命令创建了网络。
列表：容器已创建。
列表：将名为 mycontainer 的容器连接到名为 mynet 的网络： # podman network connect mynet mycontainer
列表：验证 mycontainer 是否已连接到 mynet 网络： # podman inspect --format='{{.NetworkSettings.Networks}}' mycontainer map[podman:0xc00042ab40 mynet:0xc00042ac60] 您可以看到 mycontainer 已连接到 mynet 和 podman 网络。
命令/配置摘录：

# podman network connect mynet mycontainer
# podman inspect --format='{{.NetworkSettings.Networks}}' mycontainer map[podman:0xc00042ab40 mynet:0xc00042ac60]

10.5. 断开容器与网络的连接

要点：使用 podman network disconnect 命令将容器从指定网络中断开。这会使容器无法在不停止容器本身的情况下在该网络上进行通信。
要点：先决条件
列表：container-tools 元数据包已安装。
列表：已使用 podman network create 命令创建了网络。
列表：容器连接到网络。
列表：将名为 mycontainer 的容器与名为 mynet 的网络的连接： # podman network disconnect mynet mycontainer
列表：验证 mycontainer 是否从 mynet 网络断开连接： # podman inspect --format='{{.NetworkSettings.Networks}}' mycontainer map[podman:0xc000537440] 您可以看到 mycontainer 从 mynet 网络断开连接，mycontainer 仅连接到默认的 podman 网络。如需更多信息，请参阅系统中的 podman-network-disconnect (1) 手册页。
命令/配置摘录：

# podman network disconnect mynet mycontainer
# podman inspect --format='{{.NetworkSettings.Networks}}' mycontainer map[podman:0xc000537440]

10.6. 删除网络

要点：使用 podman network rm 命令删除未使用的网络。请注意，如果网络当前被任何容器使用，则无法删除它。
要点：先决条件
列表：container-tools 元数据包已安装。
列表：列出所有网络： # podman network ls NETWORK ID NAME VERSION PLUGINS 2f259bab93aa podman 0.4.0 bridge,portmap,firewall,tuning 11c844f95e28 mynet 0.4.0 bridge,portmap,firewall,tuning,dnsname
列表：删除 mynet 网络： # podman network rm mynet mynet 注意如果移除的网络关联有关联的容器，则必须使用 podman network rm -f 命令删除容器和 pod。
列表：检查 mynet 网络是否已删除： # podman network ls NETWORK ID NAME VERSION PLUGINS 2f259bab93aa podman 0.4.0 bridge,portmap,firewall,tuning 如需更多信息，请参阅系统中的 podman-network-rm (1) 手册页。
命令/配置摘录：

# podman network ls NETWORK ID NAME VERSION PLUGINS 2f259bab93aa podman 0.4.0 bridge,portmap,firewall,tuning 11c844f95e28 mynet 0.4.0 bridge,portmap,firewall,tuning,dnsname
# podman network rm mynet mynet

注意：注意如果移除的网络关联有关联的容器，则必须使用 podman network rm -f 命令删除容器和 pod。

10.7. 删除所有未使用的网络

要点：使用 podman network prune 删除所有未使用的网络。未使用的网络是一个网络，没有连接它的容器。podman network prune 命令不会删除默认的 podman 网络。
要点：先决条件
列表：container-tools 元数据包已安装。
列表：删除所有未使用的网络： # podman network prune WARNING! This will remove all networks not used by at least one container. Are you sure you want to continue? [y/N] y
列表：验证所有网络已被删除： # podman network ls NETWORK ID NAME VERSION PLUGINS 2f259bab93aa podman 0.4.0 bridge,portmap,firewall,tuning 如需更多信息，请参阅系统中的 podman-network-prune (1) 手册页。
命令/配置摘录：

# podman network prune WARNING! This will remove all networks not used by at least one container. Are you sure you want to continue? [y/N] y
# podman network ls NETWORK ID NAME VERSION PLUGINS 2f259bab93aa podman 0.4.0 bridge,portmap,firewall,tuning

第 11 章容器间的通信

要点：启用容器、主机和外部应用之间的通信。您可以使用端口映射、DNS 解析和 pod 网络等方法来管理连接。

11.1. 网络模式和层

要点：了解 Podman 中的可用网络模式，如网桥、主机和 swig4netns。选择正确的模式决定了容器如何与网络堆栈交互。
要点：Podman 使用以下网络模式和选项：
列表：bridge：在默认网桥网络上创建另一个网络
列表：container:<id> - 使用与容器相同的网络 <id> id
列表：host：使用主机网络堆栈
列表：network-id：使用由 podman network create 命令创建的用户定义的网络
列表：private: 为容器创建新网络
列表：swig4netns: 创建一个用户网络堆栈，它带有 swig4netns，即 rootless 容器的默认选项
注意：注意主机模式使容器可以完全访问本地系统服务，如 D-bus、一个用于进程间通信的系统(IPC)，因此被视为不安全。

11.2. slirp4netns 和 pasta 之间的区别

要点：了解 pasta 和 slirp4netns 网络模式之间的主要区别。
要点：与 slirp4netns 相比，pasta 网络模式的显著区别包括：
列表：pasta 支持 IPv6 端口转发。
列表：pasta 比 slirp4netns 更高效。
列表：pasta 从主机复制 IP 地址，而 slirp4netns 使用预定义的 IPv4 地址。
列表：pasta 使用主机中的接口名称，而 slirp4netns 使用 tap0 作为接口名称。
列表：pasta 使用主机中的网关地址，而 slirp4netns 定义自己的网关地址并使用 NAT。
注意：注意无根容器的默认网络模式是 pasta。

11.3. 设置网络模式

要点：在启动时使用 podman run 命令和 --network 选项指定容器的网络配置。您可以选择主机网络等模式，或附加到自定义网桥。
要点：先决条件
列表：container-tools 模块已安装。
列表：可选：如果要使用 pasta 网络模式，请安装 passt 软件包： $ dnf install passt
列表：运行基于 registry.access.redhat.com/ubi10/ubi 镜像的容器： $ podman run --network=<network_mode> -d --name=myubi registry.access.redhat.com/ubi10/ubi <network_mode> 是所需的网络模式。另外，您可以在 containers.conf 文件中使用 default_rootless_network_cmd 选项，来切换默认的网络模式。注意无根容器的默认网络模式是 pasta。
列表：验证网络模式的设置： $ podman inspect --format {{.HostConfig.NetworkMode}} myubi <netwok_mode>
命令/配置摘录：

$ dnf install passt
$ podman run --network=<network_mode> -d --name=myubi registry.access.redhat.com/ubi10/ubi

注意：注意无根容器的默认网络模式是 pasta。

11.4. 检查容器的网络设置

要点：要排除连接问题，请检查 Red Hat Enterprise Linux 容器的网络设置。通过查看 IP 地址、端口和网关等配置详情，您可以验证您的环境，并确保您的隔离服务有效通信。
要点：先决条件
列表：container-tools 元数据包已安装。
列表：显示容器的 IP 地址： # podman inspect --format='{{.NetworkSettings.IPAddress}}' <containerName>
列表：显示容器连接到的所有网络： # podman inspect --format='{{.NetworkSettings.Networks}}' <containerName>
列表：显示端口映射： # podman inspect --format='{{.NetworkSettings.Ports}}' <containerName>
命令/配置摘录：

# podman inspect --format='{{.NetworkSettings.IPAddress}}' <containerName>
# podman inspect --format='{{.NetworkSettings.Networks}}' <containerName>

11.5. 容器和应用程序间的通信

要点：您可以使用自动公开给容器网络的应用程序端口在 RHEL 中配置容器到应用程序的通信。
要点：先决条件
列表：container-tools 元数据包已安装。
列表：启动名为 web-container 的容器： # podman run -dt --name=web-container docker.io/library/httpd 默认情况下，Web 服务器侦听端口 80。这可让 myubi 容器通过容器网络访问 web-container 应用。
列表：列出所有容器： # podman ps -a CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES b8c057333513 docker.io/library/httpd:latest httpd-foreground 4 seconds ago Up 5 seconds ago web-container
列表：检查容器并显示 IP 地址： # podman inspect --format='{{.NetworkSettings.IPAddress}}' web-container 10.88.0.2
列表：运行 myubi 容器并验证 web 服务器是否正在运行： # podman run -it --name=myubi ubi10/ubi curl 10.88.0.2:80
命令/配置摘录：

# podman run -dt --name=web-container docker.io/library/httpd
# podman ps -a CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES b8c057333513 docker.io/library/httpd:latest httpd-foreground 4 seconds ago Up 5 seconds ago web-container

11.6. 容器和主机间的通信

要点：使用网桥网络上的容器 IP 地址，实现从主机到容器的通信。您可以直接从主机访问容器内运行的服务。
要点：默认情况下，podman 网络是一个桥接网络。这意味着网络设备将容器网络桥接到主机网络。
列表：container-tools 元数据包已安装。
列表：web-container 正在运行。如需更多信息，请参阅容器和应用程序之间的通信。
列表：验证网桥是否已配置： # podman network inspect podman | grep bridge "type": "bridge"
列表：显示主机网络配置： # ip addr show cni-podman0 6: podman0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default qlen 1000 link/ether 62:af:a1:0a:ca:2e brd ff:ff:ff:ff:ff:ff inet 10.88.0.1/16 brd 10.88.255.255 scope global podman0 valid_lft forever preferred_lft forever inet6 fe80::60af:a1ff:fe0a:c…
列表：检查 web-container 并显示其 IP 地址： # podman inspect --format='{{.NetworkSettings.IPAddress}}' web-container 10.88.0.2
列表：直接从主机访问 web-container: $ curl 10.88.0.2:80
命令/配置摘录：

# podman network inspect podman | grep bridge  "type": "bridge"
# ip addr show cni-podman0 6: podman0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default qlen 1000  link/ether 62:af:a1:0a:ca:2e brd ff:ff:ff:ff:ff:ff  inet 10.88.0.1/16 brd 10.88.255.255 scope global podman0  valid_lft forever preferred_lft forever  inet6 fe80::60af:a1ff:fe0a:ca2e/64 scope link  valid_lft forever preferred_lft forever

11.7. 使用端口映射在容器间通信

要点：您可以通过将网络端口映射到 RHEL 容器来安全地公开特定的容器化应用程序。这可实现隔离服务和外部客户端之间的通信。
要点：先决条件
列表：container-tools 元数据包已安装。
列表：运行未发布的容器： # podman run -dt --name=web1 ubi10/httpd-24
列表：运行自动发布的容器： # podman run -dt --name=web2 -P ubi10/httpd-24
列表：运行手动发布的容器，并发布容器端口 8080： # podman run -dt --name=web3 -p 8888:8080 ubi10/httpd-24
列表：列出所有容器： # podman ps CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES db23e8dabc74 registry.access.redhat.com/ubi10/httpd-24:latest /usr/bin/run-http... 23 seconds ago Up 23 seconds 8080/tcp, 8443/tcp web1 1824b8f0a64b registry.access.redhat.com/ubi10/httpd-24:latest /usr/bin/run-http... 18 seconds ago Up 18 secon…
列表：容器 web1 没有公布的端口，只能通过容器网络或网桥访问。
命令/配置摘录：

# podman run -dt --name=web1 ubi10/httpd-24
# podman run -dt --name=web2 -P ubi10/httpd-24

11.8. 使用 DNS 在容器间通信

要点：启用 DNS 插件时，请使用容器名称来处理容器。
要点：先决条件
列表：container-tools 元数据软件包已安装。
列表：已使用 podman network create 命令创建启用了 DNS 插件的网络。
列表：运行附加到 mynet 网络的接收器容器： # podman run -d --net mynet --name receiver ubi10 sleep 3000
列表：运行发送者容器并通过其名称访问接收器（receiver）容器： # podman run -it --rm --net mynet --name sender alpine ping receiver PING rcv01 (10.89.0.2): 56 data bytes 64 bytes from 10.89.0.2: seq=0 ttl=42 time=0.041 ms 64 bytes from 10.89.0.2: seq=1 ttl=42 time=0.125 ms 64 bytes from 10.89.0.2: seq=2 ttl=42 time=0.109 ms 使用 CTRL+C 退出。您可以看到，发…
命令/配置摘录：

# podman run -d --net mynet --name receiver ubi10 sleep 3000
# podman run -it --rm --net mynet --name sender alpine ping receiver PING rcv01 (10.89.0.2): 56 data bytes 64 bytes from 10.89.0.2: seq=0 ttl=42 time=0.041 ms 64 bytes from 10.89.0.2: seq=1 ttl=42 time=0.125 ms 64 bytes from 10.89.0.2: seq=2 ttl=42 time=0.109 ms

11.9. 在 pod 中的两个容器间通信

要点：同一 pod 中的所有容器共享 IP 地址、MAC 地址和端口映射。您可以使用 localhost:port 表示法在同一 pod 中的容器之间进行通信。
要点：先决条件
列表：container-tools 元数据包已安装。
列表：创建名为 web-pod 的 pod： $ podman pod create --name=web-pod
列表：在 pod 中运行名为 web-container 的 web 容器： $ podman container run -d --pod web-pod --name=web-container docker.io/library/httpd
列表：列出与其关联的所有 pod 和容器： $ podman ps --pod CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES POD ID PODNAME 58653cf0cf09 k8s.gcr.io/pause:3.5 4 minutes ago Up 3 minutes ago 4e61a300c194-infra 4e61a300c194 web-pod b3f4255afdb3 docker.io/library/httpd:latest httpd-foreground 3 minutes ago Up 3 minutes ago web-container 4e…
列表：根据 docker.io/library/fedora 镜像在 web-pod 中运行容器： $ podman container run -it --rm --pod web-pod docker.io/library/fedora curl localhost 您可以看到容器可以访问 web-container。
命令/配置摘录：

$ podman pod create --name=web-pod
$ podman container run -d --pod web-pod --name=web-container docker.io/library/httpd

11.10. pod 的通信

要点：通过在 pod 级别上发布端口来公开运行在 pod 内部的服务。pod 中的容器共享这些公开的端口。
要点：先决条件
列表：container-tools 元数据包已安装。
列表：创建名为 web-pod 的 pod： # podman pod create --name=web-pod-publish -p 80:80
列表：列出所有 pod: # podman pod ls POD ID NAME STATUS CREATED INFRA ID # OF CONTAINERS 26fe5de43ab3 web-pod-publish Created 5 seconds ago 7de09076d2b3 1
列表：在 web-pod 中运行名为 web-container 的 web 容器： # podman container run -d --pod web-pod-publish --name=web-container docker.io/library/httpd
列表：列出容器 # podman ps CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 7de09076d2b3 k8s.gcr.io/pause:3.5 About a minute ago Up 23 seconds ago 0.0.0.0:80->80/tcp 26fe5de43ab3-infra 088befb90e59 docker.io/library/httpd httpd-foreground 23 seconds ago Up 23 seconds ago 0.0.0.0:80->80/tcp web-container
列表：验证可以访问 web-container: $ curl localhost:80
命令/配置摘录：

# podman pod create --name=web-pod-publish -p 80:80
# podman pod ls POD ID NAME STATUS CREATED INFRA ID # OF CONTAINERS 26fe5de43ab3 web-pod-publish Created 5 seconds ago 7de09076d2b3 1

11.11. 将 pod 附加到容器网络

要点：在创建 pod 时，将 pod 连接到特定的网络。之后，添加到 pod 的所有容器会自动加入该网络。
要点：先决条件
列表：container-tools 元数据包已安装。
列表：创建名为 pod-net 的网络： # podman network create pod-net /etc/cni/net.d/pod-net.conflist
列表：创建 pod web-pod ： # podman pod create --net pod-net --name web-pod
列表：在 web-pod 中运行一个名为 web-container 的容器： # podman run -d --pod web-pod --name=web-container docker.io/library/httpd
列表：可选：显示容器与之关联的 pod： # podman ps -p CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES POD ID PODNAME b7d6871d018c registry.access.redhat.com/ubi10/pause:latest 9 minutes ago Up 6 minutes ago a8e7360326ba-infra a8e7360326ba web-pod 645835585e24 docker.io/library/httpd:latest httpd-foreground 6 minutes ago Up 6 minutes…
列表：显示连接到容器的所有网络： # podman ps --format="{{.Networks}}" pod-net
命令/配置摘录：

# podman network create pod-net /etc/cni/net.d/pod-net.conflist
# podman pod create --net pod-net --name web-pod

11.12. 为 Podman 设置 HTTP 代理变量

要点：要在代理服务器后拉取镜像，您必须为 Podman 设置 HTTP 代理变量。Podman 读取环境变量 HTTP_PROXY，以判断 HTTP 代理信息。HTTP 代理信息可以配置为环境变量，或在 /etc/profile.d 下配置。
要点：先决条件
列表：已安装 container-tool 元软件包。
列表：为 Podman 设置代理变量。例如：未经身份验证的代理： # cat /etc/profile.d/unauthenticated_http_proxy.sh export HTTP_PROXY=http://192.168.0.1:3128 export HTTPS_PROXY=http://192.168.0.1:3128 export NO_PROXY=example.com,172.5.0.0/16 经过身份验证的代理： # cat /etc/profile.d/authenticated_http_proxy.sh export HTTP_PROXY=http://USERNAME:PASSWORD@192.168.…
列表：未经身份验证的代理： # cat /etc/profile.d/unauthenticated_http_proxy.sh export HTTP_PROXY=http://192.168.0.1:3128 export HTTPS_PROXY=http://192.168.0.1:3128 export NO_PROXY=example.com,172.5.0.0/16
列表：经过身份验证的代理： # cat /etc/profile.d/authenticated_http_proxy.sh export HTTP_PROXY=http://USERNAME:PASSWORD@192.168.0.1:3128 export HTTPS_PROXY=http://USERNAME:PASSWORD@192.168.0.1:3128 export NO_PROXY=example.com,172.5.0.0/16
命令/配置摘录：

# cat /etc/profile.d/unauthenticated_http_proxy.sh export HTTP_PROXY=http://192.168.0.1:3128 export HTTPS_PROXY=http://192.168.0.1:3128 export NO_PROXY=example.com,172.5.0.0/16
# cat /etc/profile.d/authenticated_http_proxy.sh export HTTP_PROXY=http://USERNAME:PASSWORD@192.168.0.1:3128 export HTTPS_PROXY=http://USERNAME:PASSWORD@192.168.0.1:3128 export NO_PROXY=example.com,172.5.0.0/16

第 12 章设置容器网络模式

要点：您可以使用 Podman 配置容器网络模式，以定义工作负载如何与主机和外部网络通信。选择适当的网络环境可确保根据您的特定应用程序要求量身定制的最佳性能和安全隔离。

12.1. 使用静态 IP 运行容器

要点：使用 --ip 选项为容器分配特定的 IP 地址。这有助于确保需要固定 IP 的服务的一致性网络寻址。
要点：带有 --ip 选项的 podman run 命令将容器网络接口设置为特定的 IP 地址，如 10.88.0.44。要验证您是否正确设置了 IP 地址，请运行 podman inspect 命令。
列表：container-tools 元数据包已安装。
列表：将容器网络接口设为 IP 地址 10.88.0.44： # podman run -d --name=myubi --ip=10.88.0.44 registry.access.redhat.com/ubi10/ubi efde5f0a8c723f70dd5cb5dc3d5039df3b962fae65575b08662e0d5b5f9fbe85
列表：检查是否正确设置了 IP 地址： # podman inspect --format='{{.NetworkSettings.IPAddress}}' myubi 10.88.0.44
命令/配置摘录：

# podman run -d --name=myubi --ip=10.88.0.44 registry.access.redhat.com/ubi10/ubi efde5f0a8c723f70dd5cb5dc3d5039df3b962fae65575b08662e0d5b5f9fbe85
# podman inspect --format='{{.NetworkSettings.IPAddress}}' myubi 10.88.0.44

12.2. 使用 systemd 为 Netavark 运行 DHCP 插件

要点：要为容器启用动态 IP 寻址，您可以将 Netavark 的 DHCP 插件作为 systemd 服务运行。通过将此插件作为持久服务运行，确保容器化工作负载自动保持一致的网络连接。
要点：先决条件
列表：container-tools 元数据包已安装。
列表：使用 systemd 套接字启用 DHCP 代理： systemctl enable --now netavark-dhcp-proxy.socket Created symlink /etc/systemd/system/sockets.target.wants/netavark-dhcp-proxy.socket → /usr/lib/systemd/system/netavark-dhcp-proxy.socket.
列表：可选：显示套接字单元文件： # cat /usr/lib/systemd/system/netavark-dhcp-proxy.socket [Unit] Description=Netavark DHCP proxy socket [Socket] ListenStream=%t/podman/nv-proxy.sock SocketMode=0660 [Install] WantedBy=sockets.target
列表：创建一个 macvlan 网络，并使用它指定您的主机接口。通常，它是您的外部接口： # podman network create -d macvlan --interface-name <LAN_INTERFACE> mv1 mv1
列表：使用新创建的网络运行容器： # podman run --rm --network mv1 -d --name test alpine top 894ae3b6b1081aca2a5d90a9855568eaa533c08a174874be59569d4656f9bc45
列表：确认容器在本地子网上有一个 IP： # podman exec test ip addr 1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN qlen 1000 link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00 inet 127.0.0.1/8 scope host lo valid_lft forever preferred_lft forever inet6 ::1/128 scope host valid_lft forever preferred_lft forever 2…
命令/配置摘录：

systemctl enable --now netavark-dhcp-proxy.socket Created symlink /etc/systemd/system/sockets.target.wants/netavark-dhcp-proxy.socket → /usr/lib/systemd/system/netavark-dhcp-proxy.socket.
# cat /usr/lib/systemd/system/netavark-dhcp-proxy.socket [Unit] Description=Netavark DHCP proxy socket [Socket] ListenStream=%t/podman/nv-proxy.sock SocketMode=0660 [Install] WantedBy=sockets.target

注意：注意当尝试连接到此 IP 地址时，请确保连接是从其他主机建立的。使用 macvlan 网络时，不支持来自同一主机的连接。

12.3. MacVLAN 插件

要点：您可以使用 macvlan 插件将容器直接连接到物理网络接口。通过使用此插件，容器在网络上显示为物理设备。
要点：大多数容器镜像都没有 DHCP 客户端。dhcp 插件充当容器的代理 DHCP 客户端，以便容器与 DHCP 服务器交互。

第 13 章使用 Podman 将容器移植到 systemd

要点：使用 systemd 集成将容器作为系统服务进行管理。使用此功能，您可以使用标准 systemctl 命令自动启动容器、管理依赖项和控制其状态。
要点：Podman 是一个无守护进程的容器引擎，其命令行界面与 Docker-CLI 类似。它简化了从其他容器引擎进行迁移，并支持管理 pod、容器和镜像。

13.1. 使用 Quadlets 自动生成一个 systemd 单元文件

要点：使用 Quadlet 自动生成 systemd 服务文件。通过创建描述容器的简单单元文件，Qadlet 可以处理与 systemd 集成的复杂性。
要点：使用 Quadlet，您可以描述如何以与常规 systemd 单元文件非常相似的格式运行容器。容器描述只关注相关的容器信息，并隐藏了在 systemd 下运行容器的技术细节。在以下目录中的一个创建<CTRNAME>.container 单元文件：
列表：对于 root 用户：/usr/share/containers/systemd/ 或 /etc/containers/systemd/
列表：对于无根用户：$HOME/.config/containers/systemd/, $XDG_CONFIG_HOME/containers/systemd/, /etc/containers/systemd/users/$(UID) 或 /etc/containers/systemd/users/
列表：container-tools 元数据包已安装。
列表：创建 mysleep.container 单元文件： $ cat $HOME/.config/containers/systemd/mysleep.container [Unit] Description=The sleep container After=local-fs.target [Container] Image=registry.access.redhat.com/ubi10-minimal:latest Exec=sleep 1000 [Install] # Start by default on boot WantedBy=multi-user.target default.target 在 [Container]…
列表：Image - 您要运行的容器镜像
列表：Exec - 要在容器内运行的命令您可以使用 systemd 单元文件中指定的所有其他字段。
命令/配置摘录：

$ cat $HOME/.config/containers/systemd/mysleep.container [Unit] Description=The sleep container After=local-fs.target [Container] Image=registry.access.redhat.com/ubi10-minimal:latest Exec=sleep 1000 [Install] # Start by default on boot WantedBy=multi-user.target default.target
$ systemctl --user daemon-reload

注意：注意从 Podman v4.6 开始，可以使用 Quadlet。

13.2. 启用 systemd 服务

要点：使容器化服务能够在引导时自动启动。对于用户服务，必须启用 lingering，以确保这些服务在用户注销后仍然保持运行。
要点：流程
列表：启用服务：要在系统启动时启用服务，无论用户是否登录，输入： # systemctl enable <service> 您必须将 systemd 单元文件复制到 /etc/systemd/system 目录中。要在用户登录时启动服务并在用户注销时停止该服务，输入： $ systemctl --user enable <service> 您必须将 systemd 单元文件复制到 $HOME/.config/systemd/user 目录中。要允许用户在系统启动并保留日志时启动服务，请输入： # loginctl enable-linger <username> 如需更多信息，请参阅系统中的 systemctl (1) 和 log…
列表：要在系统启动时启用服务，无论用户是否登录，输入： # systemctl enable <service> 您必须将 systemd 单元文件复制到 /etc/systemd/system 目录中。
列表：要在用户登录时启动服务并在用户注销时停止该服务，输入： $ systemctl --user enable <service> 您必须将 systemd 单元文件复制到 $HOME/.config/systemd/user 目录中。
列表：要允许用户在系统启动并保留日志时启动服务，请输入： # loginctl enable-linger <username> 如需更多信息，请参阅系统中的 systemctl (1) 和 loginctl (1) 手册页。
列表：使用 systemctl 管理系统服务
命令/配置摘录：

# systemctl enable <service>
$ systemctl --user enable <service>

13.3. 使用 systemd 自动启动容器

要点：您可以使用 systemctl 命令控制 systemd 系统和服务管理器的状态。您可以以非 root 用户身份启用、启动、停止服务。若要以 root 用户身份安装服务，请省略 --user 选项。
要点：先决条件
列表：container-tools 元数据包已安装。
列表：重新载入 systemd Manager 配置： # systemctl --user daemon-reload
列表：启用服务 container.service ，并在引导时启动它： # systemctl --user enable container.service
列表：立即启动该服务： # systemctl --user start container.service
列表：检查服务的状态： $ systemctl --user status container.service ● container.service - Podman container.service Loaded: loaded (/home/user/.config/systemd/user/container.service; enabled; vendor preset: enabled) Active: active (running) since Wed 2020-09-16 11:56:57 CEST; 8s ago Docs: man:podman-generate-systemd(1) Process: 8…
列表：可选：要停止 container.service，请输入： # systemctl --user stop container.service
命令/配置摘录：

# systemctl --user daemon-reload
# systemctl --user enable container.service

13.4. 与 podman generate systemd 命令相比，使用 Quadlets 的优点

要点：您可以使用 Quadlets 工具，它描述了如何以类似于常规 systemd 单元文件的格式运行容器。
要点：与使用 podman generate systemd 命令生成单元文件相比，Qadlets 有很多优点，例如：
列表：易于维护：容器描述侧重于相关的容器细节，并隐藏在 systemd 下运行的容器的技术细节。
列表：自动更新：Quadlets 不需要在更新后手动重新生成单元文件。如果发布了一个较新版本的 Podman，您的服务会在运行 systemctl daemon-reload 命令时自动更新，例如在引导时。
列表：简化的工作流：由于简化的语法，您可以从头开始创建 Quadlet 文件，并在任何地方部署它们。
列表：支持标准的 systemd 选项：Qadlet 使用新表扩展了现有的 systemd-unit 语法，例如，配置容器的表。
列表：Container units ：用来通过运行 podman run 命令管理容器。文件扩展名：.container 部分名称：[Container] 必填字段：描述服务运行的容器镜像的 Image
列表：文件扩展名：.container
注意：注意 Quadlet 从 Podman v4.6 版本开始提供。
注意：注意 Quadlet 支持 Kubernetes YAML 功能的子集。您可以使用以下工具之一生成 YAML 文件： podman: podman generate kube 命令 OpenShift: 带有 --dry-run 选项的 oc generate 命令 kubernetes: 带有 --dry-run 选项的 kubectl create 命令

13.5. 使用 Podman 生成 systemd 单元文件

要点：使用 podman generate systemd 命令为现有容器创建 systemd 单元文件。这允许 Podman 将运行的容器作为服务进行管理，但 Quadlets 是新配置的首选。
要点：podman generate systemd 命令还可帮助您获取最新版本的单元文件。
列表：container-tools 元数据包已安装。
列表：创建容器（如 myubi）： $ podman create --name myubi registry.access.redhat.com/ubi10:latest sleep infinity 0280afe98bb75a5c5e713b28de4b7c5cb49f156f1cce4a208f13fee2f75cb453
列表：使用容器名称或 ID 生成 systemd 单元文件，并将其定向到 ~/.config/systemd/user/container-myubi.service 文件中： $ podman generate systemd --name myubi > ~/.config/systemd/user/container-myubi.service
列表：显示生成的 systemd 单元文件的内容： $ cat ~/.config/systemd/user/container-myubi.service # container-myubi.service # autogenerated by Podman 3.3.1 # Wed Sep 8 20:34:46 CEST 2021 [Unit] Description=Podman container-myubi.service Documentation=man:podman-generate-systemd(1) Wants=network-online.target After=network-online.target Req…
列表：Restart=on-failure 行设置重启策略，并指示 systemd 在无法完全启动或停止服务时重启，或者在进程非零退出时重启。
列表：ExecStart 行描述了如何启动容器。
命令/配置摘录：

$ podman create --name myubi registry.access.redhat.com/ubi10:latest sleep infinity 0280afe98bb75a5c5e713b28de4b7c5cb49f156f1cce4a208f13fee2f75cb453
$ podman generate systemd --name myubi > ~/.config/systemd/user/container-myubi.service

注意：注意从 Podman v4.6 开始，您可以使用描述如何以类似于常规 systemd 单元文件的格式运行容器的 Quadlets，并在 systemd 下隐藏运行容器的复杂性。

13.6. 使用 Podman 自动生成 systemd 单元文件

要点：默认情况下，Podman 为现有容器或 pod 生成一个单元文件。您可以使用 podman generate systemd --new 生成更多可移植的 systemd 单元文件。--new 标志指示 Podman 生成用于创建、启动和删除容器的单元文件。
要点：先决条件
列表：container-tools 元数据包已安装。
列表：拉取您要在系统中使用的镜像。例如，要拉取 httpd-24 镜像： # podman pull registry.access.redhat.com/ubi10/httpd-24
列表：可选：列出系统上所有可用的镜像： # podman images REPOSITORY TAG IMAGE ID CREATED SIZE registry.access.redhat.com/ubi10/httpd-24 latest 8594be0a0b57 2 weeks ago 462 MB
列表：创建 httpd 容器： # podman create --name httpd -p 8080:8080 registry.access.redhat.com/ubi10/httpd-24 cdb9f981cf143021b1679599d860026b13a77187f75e46cc0eac85293710a4b1
列表：可选：验证容器是否已创建： # podman ps -a CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES cdb9f981cf14 registry.access.redhat.com/ubi10/httpd-24:latest /usr/bin/run-http... 5 minutes ago Created 0.0.0.0:8080->8080/tcp httpd
列表：为 httpd 容器生成一个 systemd 单元文件： # podman generate systemd --new --files --name httpd /root/container-httpd.service
命令/配置摘录：

# podman pull registry.access.redhat.com/ubi10/httpd-24
# podman images REPOSITORY TAG IMAGE ID CREATED SIZE registry.access.redhat.com/ubi10/httpd-24 latest 8594be0a0b57 2 weeks ago 462 MB

注意：注意从 Podman v4.6 开始，您可以使用 Quadlets 来描述如何以类似于常规 systemd 单元文件的格式运行容器，并隐藏了在 systemd 下运行容器的复杂性。
注意：注意使用 --new 选项生成的单元文件不期望容器和 pod 存在。因此，它们会在启动服务时执行 podman run 命令（请参阅 ExecStart 行），而不是 podman start 命令。例如，请参阅使用 Podman 生成 systemd 单元文件一节。

13.7. 使用 systemd 自动启动 pod

要点：将整个 pod 作为 systemd 服务管理，以帮助确保 pod 中的所有容器都一起启动和停止。这简化了多容器应用的管理。
要点：请注意，systemctl 命令应该只用于 pod，不应通过 systemctl 单独启动或停止容器，因为它们由 pod 服务与内部 infra-container 一起管理。
列表：container-tools 元数据包已安装。
列表：创建一个空 pod，如 systemd-pod: $ podman pod create --name systemd-pod 11d4646ba41b1fffa51c108cbdf97cfab3213f7bd9b3e1ca52fe81b90fed5577
列表：可选：列出所有 pod： $ podman pod ps POD ID NAME STATUS CREATED # OF CONTAINERS INFRA ID 11d4646ba41b systemd-pod Created 40 seconds ago 1 8a428b257111 11d4646ba41b1fffa51c108cbdf97cfab3213f7bd9b3e1ca52fe81b90fed5577
列表：在空 pod 中创建两个容器。例如，要在 systemd-pod 中创建 container0 和 container1 ： $ podman create --pod systemd-pod --name container0 registry.access.redhat.com/ubi10 top $ podman create --pod systemd-pod --name container1 registry.access.redhat.com/ubi10 top
列表：可选：列出与其关联的所有 pod 和容器： $ podman ps -a --pod CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES POD ID PODNAME 24666f47d9b2 registry.access.redhat.com/ubi10:latest top 3 minutes ago Created container0 3130f724e229 systemd-pod 56eb1bf0cdfe k8s.gcr.io/pause:3.2 4 minutes ago Created 3130f724e229-infra 3130f724e229 syst…
列表：为新 pod 生成 systemd 单元文件： $ podman generate systemd --files --name systemd-pod /home/user1/pod-systemd-pod.service /home/user1/container-container0.service /home/user1/container-container1.service 请注意，生成了三个 systemd 单元文件，一个用于 systemd-pod pod，另两个用于容器 container0 和 container1。
命令/配置摘录：

$ podman pod create --name systemd-pod 11d4646ba41b1fffa51c108cbdf97cfab3213f7bd9b3e1ca52fe81b90fed5577
$ podman pod ps POD ID NAME STATUS CREATED # OF CONTAINERS INFRA ID 11d4646ba41b systemd-pod Created 40 seconds ago 1 8a428b257111 11d4646ba41b1fffa51c108cbdf97cfab3213f7bd9b3e1ca52fe81b90fed5577

注意：注意从 Podman v4.6 开始，您可以使用描述如何以类似于常规 systemd 单元文件的格式运行容器的 Quadlets，并在 systemd 下隐藏运行容器的复杂性。

13.8. 使用 Podman 自动更新容器

要点：使用 podman auto-update 命令，您可以根据其自动更新策略自动更新容器。当容器镜像在注册中心中被更新时，podman auto-update 命令会更新服务。
要点：要使用自动更新，必须使用 --label "io.containers.autoupdate=image" 标签创建容器，并在 podman generate systemd --new 命令生成的 systemd 单元中运行。
列表：container-tools 元数据包已安装。
列表：启动一个基于 registry.access.redhat.com/ubi10/ubi-init 镜像的 myubi 容器： # podman run --label "io.containers.autoupdate=image" \ --name myubi -dt registry.access.redhat.com/ubi10/ubi-init top bc219740a210455fa27deacc96d50a9e20516492f1417507c13ce1533dbdcd9d
列表：可选：列出正在运行或已退出的容器： # podman ps -a CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 76465a5e2933 registry.access.redhat.com/10/ubi-init:latest top 24 seconds ago Up 23 seconds ago myubi
列表：为 myubi 容器生成一个 systemd 单元文件： # podman generate systemd --new --files --name myubi /root/container-myubi.service
列表：将单元文件复制到 /usr/lib/systemd/system 中，以便以 root 用户身份安装它： # cp -Z ~/container-myubi.service /usr/lib/systemd/system
列表：重新载入 systemd 管理器配置： # systemctl daemon-reload
命令/配置摘录：

# podman run --label "io.containers.autoupdate=image" \ --name myubi -dt registry.access.redhat.com/ubi10/ubi-init top bc219740a210455fa27deacc96d50a9e20516492f1417507c13ce1533dbdcd9d
# podman ps -a CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 76465a5e2933 registry.access.redhat.com/10/ubi-init:latest top 24 seconds ago Up 23 seconds ago myubi

注意：注意从 Podman v4.6 开始，您可以使用 Quadlets 来描述如何以类似于常规 systemd 单元文件的格式运行容器，并隐藏在 systemd 下运行容器的复杂性。

13.9. 使用 systemd 自动更新容器

要点：使用 podman-auto-update 计时器和服务调度自动容器更新。这有助于确保您的系统定期检查并应用镜像更新，而无需手动干预。
要点：如使用 Podman 自动更新容器一节中所述，您可以使用 podman auto-update 命令更新容器。它整合成自定义脚本，并在需要时调用。自动更新容器的另一种方法是使用预安装的 podman-auto-update.timer 和 podman-auto-update.service systemd 服务。
列表：container-tools 元数据包已安装。
列表：显示 podman-auto-update.service 单元文件： # cat /usr/lib/systemd/system/podman-auto-update.service [Unit] Description=Podman auto-update service Documentation=man:podman-auto-update(1) Wants=network.target After=network-online.target [Service] Type=oneshot ExecStart=/usr/bin/podman auto-update [Install] WantedBy=multi-user.…
列表：显示 podman-auto-update.timer 单元文件： # cat /usr/lib/systemd/system/podman-auto-update.timer [Unit] Description=Podman auto-update timer [Timer] OnCalendar=daily Persistent=true [Install] WantedBy=timers.target 在本例中，podman auto-update 命令在每天午夜启动。
列表：在系统启动时启用 podman-auto-update.timer 服务： # systemctl enable podman-auto-update.timer
列表：启动 systemd 服务： # systemctl start podman-auto-update.timer
列表：可选：列出所有计时器： # systemctl list-timers --all NEXT LEFT LAST PASSED UNIT ACTIVATES Wed 2020-12-09 00:00:00 CET 9h left n/a n/a podman-auto-update.timer podman-auto-update.service 您可以看到 podman-auto-update.timer 激活了 podman-auto-update.service。
命令/配置摘录：

# cat /usr/lib/systemd/system/podman-auto-update.service [Unit] Description=Podman auto-update service Documentation=man:podman-auto-update(1) Wants=network.target After=network-online.target [Service] Type=oneshot ExecStart=/usr/bin/podman auto-update [Install] WantedBy=multi-user.target default.target
# cat /usr/lib/systemd/system/podman-auto-update.timer [Unit] Description=Podman auto-update timer [Timer] OnCalendar=daily Persistent=true [Install] WantedBy=timers.target

注意：注意从 Podman v4.6 开始，您可以使用 Quadlets 来描述如何以类似于常规 systemd 单元文件的格式运行容器，并隐藏了在 systemd 下运行容器的复杂性。

第 14 章使用 Podman 将容器移植到 OpenShift

要点：生成本地容器的可移植 YAML 描述，以部署到 OpenShift 或 Kubernetes。使用此功能，您可以使用 Podman 本地开发并全局部署。
要点：您可以使用 YAML 文件：
列表：使用所需的最小输入运行本地编配的容器和 pod，这对于迭代开发非常有用。
列表：在另一台计算机上运行相同的容器和 pod。

14.1. 使用 Podman 生成 Kubernetes YAML 文件

要点：您可以创建一个带有一个容器的 pod，并使用 podman generate kube 命令生成 Kubernetes YAML 文件。
要点：先决条件
列表：container-tools 元数据包已安装。
列表：pod 已创建。详情请参阅创建 pod 一节。
列表：列出与其关联的所有 pod 和容器： $ podman ps -a --pod CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES POD 5df5c48fea87 registry.access.redhat.com/ubi10/ubi:latest /bin/bash Less than a second ago Up Less than a second ago myubi 223df6b390b4 3afdcd93de3e k8s.gcr.io/pause:3.1 Less than a second ago Up Less than a second ago 223…
列表：使用 pod 名称或 ID 来生成 Kubernetes YAML 文件： $ podman generate kube mypod > mypod.yaml podman generate 命令不反映任何附加到容器的逻辑卷管理器(LVM)逻辑卷或物理卷。
列表：显示 mypod.yaml 文件： $ cat mypod.yaml # Generation of Kubernetes YAML is still under development! # # Save the output of this file and use kubectl create -f to import # it into Kubernetes. # # Created with podman-1.6.4 apiVersion: v1 kind: Pod metadata: creationTimestamp: "2020-06-09T10:31:56Z" labels: app: mypod name…
命令/配置摘录：

$ podman ps -a --pod CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES POD 5df5c48fea87 registry.access.redhat.com/ubi10/ubi:latest /bin/bash Less than a second ago Up Less than a second ago myubi 223df6b390b4 3afdcd93de3e k8s.gcr.io/pause:3.1 Less than a second ago Up Less than a second ago 223df6b390b4-infra 223df6b390b4
$ podman generate kube mypod > mypod.yaml

14.2. 在 OpenShift 环境中生成 Kubernetes YAML 文件

要点：在 OpenShift 环境中，使用 oc create 命令来生成描述应用程序的 YAML 文件。
要点：流程
列表：为您的 myapp 应用程序生成 YAML 文件： $ oc create myapp --image=me/myapp:v1 -o yaml --dry-run > myapp.yaml oc create 命令创建并运行 myapp 镜像。使用 --dry-run 选项打印对象，并重定向到 myapp.yaml 输出文件。
命令/配置摘录：

$ oc create myapp --image=me/myapp:v1 -o yaml --dry-run > myapp.yaml

注意：注意在 Kubernetes 环境中，您可以使用带有同样标志的 kubectl create 命令。

14.3. 使用 Podman 启动容器和 pod

要点：使用生成的 YAML 文件，您可以在任何环境中自动启动容器和 pod。可以使用 Podman 以外的工具生成 YAML 文件，如 Kubernetes 或 OpenShift。
要点：使用 podman play kube 命令，您可以根据 YAML 输入文件重新创建 pod 和容器。
列表：container-tools 元数据包已安装。
列表：从 mypod.yaml 文件创建 pod 和容器： $ podman play kube mypod.yaml Pod: b8c5b99ba846ccff76c3ef257e5761c2d8a5ca4d7ffa3880531aec79c0dacb22 Container: 848179395ebd33dd91d14ffbde7ae273158d9695a081468f487af4e356888ece
列表：列出所有 pod: $ podman pod ps POD ID NAME STATUS CREATED # OF CONTAINERS INFRA ID b8c5b99ba846 mypod Running 19 seconds ago 2 aa4220eaf4bb
列表：列出与其关联的所有 pod 和容器： $ podman ps -a --pod CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES POD 848179395ebd registry.access.redhat.com/ubi10/ubi:latest /bin/bash About a minute ago Up About a minute ago myubi b8c5b99ba846 aa4220eaf4bb k8s.gcr.io/pause:3.1 About a minute ago Up About a minute ago b8c5b99ba846-infra …
命令/配置摘录：

$ podman play kube mypod.yaml Pod: b8c5b99ba846ccff76c3ef257e5761c2d8a5ca4d7ffa3880531aec79c0dacb22 Container: 848179395ebd33dd91d14ffbde7ae273158d9695a081468f487af4e356888ece
$ podman pod ps POD ID NAME STATUS CREATED # OF CONTAINERS INFRA ID b8c5b99ba846 mypod Running 19 seconds ago 2 aa4220eaf4bb

14.4. 在 OpenShift 环境中启动容器和 pod

要点：您可以使用 oc create 命令在 OpenShift 环境中创建 pod 和容器。
要点：流程
列表：从 OpenShift 环境中的 YAML 文件创建 pod: $ oc create -f mypod.yaml 注意在 Kubernetes 环境中，您可以使用带有同样标志的 kubectl create 命令。
命令/配置摘录：

$ oc create -f mypod.yaml

注意：注意在 Kubernetes 环境中，您可以使用带有同样标志的 kubectl create 命令。

14.5. 使用 Podman 手动运行容器和 pod

要点：使用 Podman 手动部署一个多容器应用，如 WordPress 和 MariaDB。这涉及创建 pod 并为其添加连接的容器。
要点：假设以下目录布局：
列表：container-tools 元数据包已安装。
列表：显示 mariadb-conf/Containerfile 文件： $ cat mariadb-conf/Containerfile FROM docker.io/library/mariadb COPY my.cnf /etc/mysql/my.cnf
列表：显示 mariadb-conf/my.cnf 文件： [client-server] # Port or socket location where to connect port = 3306 socket = /run/mysqld/mysqld.sock # Import all .cnf files from the configuration directory [mariadbd] skip-host-cache skip-name-resolve bind-address = 127.0.0.1 !includedir /etc/mysql/mariadb.conf.d/ !includedir /etc/mysql…
列表：使用 mariadb-conf/Containerfile 构建 docker.io/library/mariadb 镜像： $ cd mariadb-conf $ podman build -t mariadb-conf . $ cd .. STEP 1: FROM docker.io/library/mariadb Trying to pull docker.io/library/mariadb:latest... Getting image source signatures Copying blob 7b1a6ab2e44d done ... Storing signatures STEP 2: COPY my.cnf /…
列表：可选：列出所有镜像： $ podman images LIST IMAGES REPOSITORY TAG IMAGE ID CREATED SIZE localhost/mariadb-conf latest b66fa0fa0ef2 57 seconds ago 416 MB
列表：创建名为 wordpresspod 的 pod，并配置容器和主机系统之间的端口映射： $ podman pod create --name wordpresspod -p 8080:80
命令/配置摘录：

├── mariadb-conf │ ├── Containerfile │ ├── my.cnf
$ cat mariadb-conf/Containerfile FROM docker.io/library/mariadb COPY my.cnf /etc/mysql/my.cnf

14.6. 使用 Podman 生成 YAML 文件

要点：您可以使用 podman generate kube 命令生成 Kubernetes YAML 文件。
要点：先决条件
列表：container-tools 元数据包已安装。
列表：名为 wordpresspod 的 pod 已创建。详情请参阅创建 pod 一节。
列表：列出与其关联的所有 pod 和容器： $ podman ps --pod -a CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES POD ID PODNAME 9ea56f771915 k8s.gcr.io/pause:3.5 Less than a second ago Up Less than a second ago 0.0.0.0:8080->80/tcp 4b7f054a6f01-infra 4b7f054a6f01 wordpresspod 60e8dbbabac5 localhost/mariadb-conf:latest mariadbd Less than…
列表：使用 pod 名称或 ID 来生成 Kubernetes YAML 文件： $ podman generate kube wordpresspod >> wordpresspod.yaml
列表：显示 wordpresspod.yaml 文件： $ cat wordpresspod.yaml ... apiVersion: v1 kind: Pod metadata: creationTimestamp: "2021-12-09T15:09:30Z" labels: app: wordpresspod name: wordpresspod spec: containers: - args: value: podman - name: MYSQL_PASSWORD value: "1234" - name: MYSQL_MAJOR value: "8.0" - name: MYSQL_VERSION …
命令/配置摘录：

$ podman ps --pod -a CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES POD ID PODNAME 9ea56f771915 k8s.gcr.io/pause:3.5 Less than a second ago Up Less than a second ago 0.0.0.0:8080->80/tcp 4b7f054a6f01-infra 4b7f054a6f01 wordpresspod 60e8dbbabac5 localhost/mariadb-conf:latest mariadbd Less than a second ago Up Less than a second ago 0.0.0.0:8080->80/tcp mydb 4b7f054a6f01 wordpresspod 045d3d506e50 docker.io/library/wordpress:latest apache2-foregroun... Less than a second ago Up Less than a second ago 0.0.0.0:8080->80/tcp myweb 4b7f054a6f01 wordpresspod
$ podman generate kube wordpresspod >> wordpresspod.yaml

14.7. 使用 Podman 自动运行容器和 pod

要点：在将生成的 YAML 文件传送到 Kubernetes 或 OpenShift 环境前，您可以使用 podman play kube 命令测试本地系统中的 pod 和容器的创建。
要点：podman play kube 命令还可使用类似于 docker compose 命令的 YAML 文件自动构建并运行 pod 中具有多个容器的多个 pod。如果满足以下条件，会自动构建镜像：
列表：存在一个名称与 YAML 文件中所用镜像相同的目录
列表：该目录包含一个 Containerfile
列表：container-tools 元数据包已安装。
列表：名为 wordpresspod 的 pod 已创建。详情请参阅使用 Podman 手动运行容器和 pod 一节。
列表：已生成 YAML 文件。详情请参阅使用 Podman 生成 YAML 文件一节。
列表：要从头重复整个场景，请删除本地存储的镜像： $ podman rmi localhost/mariadb-conf $ podman rmi docker.io/library/wordpress $ podman rmi docker.io/library/mysql
命令/配置摘录：

$ podman rmi localhost/mariadb-conf $ podman rmi docker.io/library/wordpress $ podman rmi docker.io/library/mysql
$ podman play kube wordpress.yaml STEP 1/2: FROM docker.io/library/mariadb STEP 2/2: COPY my.cnf /etc/mysql/my.cnf COMMIT localhost/mariadb-conf:latest --> 428832c45d0 Successfully tagged localhost/mariadb-conf:latest 428832c45d07d78bb9cb34e0296a7dc205026c2fe4d636c54912c3d6bab7f399 Trying to pull docker.io/library/wordpress:latest... Getting image source signatures Copying blob 99c3c1c4d556 done ... Storing signatures Pod: 3e391d091d190756e655219a34de55583eed3ef59470aadd214c1fc48cae92ac Containers: 6c59ebe968467d7fdb961c74a175c88cb5257fed7fb3d375c002899ea855ae1f 29717878452ff56299531f79832723d3a620a403f4a996090ea987233df0bc3d

14.8. 使用 Podman 自动停止和删除 pod

要点：podman play kube --down 命令停止并删除所有 pod 及其容器。
要点：先决条件
列表：container-tools 元数据包已安装。
列表：名为 wordpresspod 的 pod 已创建。详情请参阅使用 Podman 手动运行容器和 pod 一节。
列表：已生成 YAML 文件。详情请参阅使用 Podman 生成 YAML 文件一节。
列表：Pod 正在运行。详情请参阅使用 Podman 自动运行容器和 pod 一节。
列表：删除 wordpresspod.yaml 文件创建的所有 pod 和容器： $ podman play kube --down wordpresspod.yaml Pods stopped: 3e391d091d190756e655219a34de55583eed3ef59470aadd214c1fc48cae92ac Pods removed: 3e391d091d190756e655219a34de55583eed3ef59470aadd214c1fc48cae92ac 注意如果使用卷，它不会被删除。
列表：验证 wordpresspod.yaml 文件创建的所有 pod 和容器已被删除： $ podman ps --pod -a CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES POD ID PODNAME 如需更多信息，请参阅系统中的 podman-play-kube (1) 手册页。
命令/配置摘录：

$ podman play kube --down wordpresspod.yaml Pods stopped: 3e391d091d190756e655219a34de55583eed3ef59470aadd214c1fc48cae92ac Pods removed: 3e391d091d190756e655219a34de55583eed3ef59470aadd214c1fc48cae92ac
$ podman ps --pod -a CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES POD ID PODNAME

注意：注意如果使用卷，它不会被删除。

第 15 章使用 RHEL 系统角色管理容器

要点：podman RHEL 系统角色管理 Red Hat Enterprise Linux 系统上的容器。此角色使用 Ansible 配置 Podman，管理容器生命周期，甚至将容器化应用程序部署为 systemd 服务。

15.1. RHEL 系统角色与基于 bootc的镜像构建集成

要点：使用 bootc、Ansible 和 RHEL 系统角色构建带有预先配置的系统组件和应用程序的容器。您可以使用 Ansible 运行 playbook。此 playbook 使用一个或多个角色来配置系统组件和应用程序。
要点：例如，您可以使用 podman 角色来创建和管理物理绑定镜像。有关使用 podman 角色来构建和管理的更多信息，参请阅创建和管理物理绑定镜像

15.2. 为 Podman 和其他容器工具配置镜像 registry 管理

要点：使用 podman RHEL 系统角色，您可以在多个 RHEL 系统中自动化 Podman 管理，包括 registry 配置。您可以在 Ansible playbook 中定义 registry 配置，而不是手动编辑文件。
要点：podman RHEL 系统角色使用 podman_registries_conf 变量，它接受包含 registry 设置的字典。然后，该角色会创建一个 drop-in 文件，例如在 /etc/containers/registries.conf.d/ 中应用您的配置，遵循管理系统配置的最佳实践。
列表：您已准备好控制节点和受管节点。
列表：以可在受管主机上运行 playbook 的用户登录到控制节点。
列表：用于连接到受管节点的帐户具有这些节点的 sudo 权限。
列表：创建一个包含以下内容的 playbook 文件，如 ~/playbook.yml ： --- - name: Configure Podman registries with RHEL system roles hosts: managed-node-01.example.com vars: podman_registries_conf: unqualified-search-registries: - "registry.access.redhat.com" - "docker.io" - "my-company-registry.com" registry: - location: "my-company-r…
列表：Unqualified-search-registries：在使用简短镜像名称时（例如 podman pull <my-image> ）时，扩展Podman 搜索的 registry 列表。Podman 在默认 registry 后再搜索 my-company-registry.com 中的镜像。
列表：[registry]: 定义给定 registry 的特定属性。例如，您可以为运行在 my-local-registry:5000 的本地 registry 设置 insecure=true 来启用不安全连接。
命令/配置摘录：

--- - name: Configure Podman registries with RHEL system roles  hosts: managed-node-01.example.com  vars:  podman_registries_conf:  unqualified-search-registries:  - "registry.access.redhat.com"  - "docker.io"  - "my-company-registry.com"  registry:  - location: "my-company-registry.com"  - location: "my-local-registry:5000"  insecure: true  tasks:  - name: Include the podman system role  ansible.builtin.include_role:  name: redhat.rhel_system_roles.podman
podman_use_new_toml_formatter: true podman_containers_conf:  containers:  annotations:  - environment=production  - status=tier2

15.3. 使用 podman RHEL 系统角色创建带有绑定挂载的无根容器

要点：您可以使用 podman RHEL 系统角色，通过运行 Ansible playbook 来创建带有绑定挂载的无根容器，并管理应用程序配置。
要点：示例 Ansible Playbook 启动两个 Kubernetes pod：一个用于数据库，另一个用于 web 应用。数据库 pod 配置在 playbook 中指定，而 Web 应用 Pod 在一个外部 YAML 文件中定义。
列表：您已准备好控制节点和受管节点。
列表：以可在受管主机上运行 playbook 的用户登录到控制节点。
列表：用于连接到受管节点的帐户具有这些节点的 sudo 权限。
列表：用户和组 webapp 存在，且必须列在主机上的 /etc/subuid 和 /etc/subgid 文件中。
列表：必须已创建名为 dbuser 和名为 dbgroup 的组。
列表：创建一个包含以下内容的 playbook 文件，如 ~/playbook.yml ： - name: Configure Podman hosts: managed-node-01.example.com tasks: - name: Create a web application and a database ansible.builtin.include_role: name: redhat.rhel_system_roles.podman vars: podman_create_host_directories: true podman_firewall: - port: 8080-8081/tcp s…
命令/配置摘录：

- name: Configure Podman  hosts: managed-node-01.example.com  tasks:  - name: Create a web application and a database  ansible.builtin.include_role:  name: redhat.rhel_system_roles.podman  vars:  podman_create_host_directories: true  podman_firewall:  - port: 8080-8081/tcp  state: enabled  - port: 12340/tcp  state: enabled  podman_selinux_ports:  - ports: 8080-8081  setype: http_port_t  podman_kube_specs:  - state: started  run_as_user: dbuser  run_as_group: dbgroup  kube_file_content:  apiVersion: v1  kind: Pod  metadata:  name: db  spec:  containers:  - name: db  image: quay.io/rhel-system-roles/mysql:5.6  ports:  - containerPort: 1234  ho…
$ ansible-playbook --syntax-check --ask-vault-pass ~/playbook.yml

15.4. 使用 podman RHEL 系统角色创建一个带有 Podman 卷的有根容器

要点：您可以通过运行 Ansible Playbook，使用 podman RHEL 系统角色创建带有 Podman 卷的 rootful 容器。您可以使用此 rootful 容器管理应用程序配置。
要点：示例 Ansible Playbook 部署一个名为 ubi10-httpd 的 Kubernetes pod，它运行一个基于 registry.access.redhat.com/ubi10/httpd-24 镜像的 HTTP 服务器容器。容器的 Web 内容挂载自名为 ubi10-html-volume 的持久卷。默认情况下，podman 角色创建有根容器。
列表：您已准备好控制节点和受管节点。
列表：以可在受管主机上运行 playbook 的用户登录到控制节点。
列表：用于连接到受管节点的帐户具有这些节点的 sudo 权限。
列表：创建一个包含以下内容的 playbook 文件，如 ~/playbook.yml ： - name: Configure Podman hosts: managed-node-01.example.com tasks: - name: Start Apache server on port 8080 ansible.builtin.include_role: name: redhat.rhel_system_roles.podman vars: podman_firewall: - port: 8080/tcp state: enabled podman_kube_specs: - state: starte…
列表：ubi10-httpd 容器基于 registry.access.redhat.com/ubi10/httpd-24 容器镜像。
列表：ubi10-html-volume 将主机上的 /var/www/html 目录映射到容器。Z 标志使用私有的 unshared 标签标记内容，因此只有 ubi10-httpd 容器可以访问其内容。
命令/配置摘录：

- name: Configure Podman  hosts: managed-node-01.example.com  tasks:  - name: Start Apache server on port 8080  ansible.builtin.include_role:  name: redhat.rhel_system_roles.podman  vars:  podman_firewall:  - port: 8080/tcp  state: enabled  podman_kube_specs:  - state: started  kube_file_content:  apiVersion: v1  kind: Pod  metadata:  name: ubi10-httpd  spec:  containers:  - name: ubi10-httpd  image: registry.access.redhat.com/ubi10/httpd-24  ports:  - containerPort: 8080  hostPort: 8080  volumeMounts:  - mountPath: /var/www/html:Z  name: ubi10-html  volumes:  - name: ubi10-html  persistentVolumeClaim:  claimName: ubi10-html-volume
$ ansible-playbook --syntax-check ~/playbook.yml

15.5. 使用 podman RHEL 系统角色创建一个带有 secret 的 Quadlet 应用程序

要点：您可以通过运行 Ansible Playbook，使用 podman RHEL 系统角色创建带有 secret 的 Quadlet 应用程序。
要点：先决条件
列表：您已准备好控制节点和受管节点。
列表：以可在受管主机上运行 playbook 的用户登录到控制节点。
列表：用于连接到受管节点的帐户具有这些节点的 sudo 权限。
列表：容器中 Web 服务器的证书和对应的私钥存储在 ~/certificate.pem 和 ~/key.pem 文件中。
列表：显示证书和私钥文件的内容： $ cat ~/certificate.pem -----BEGIN CERTIFICATE----- ... -----END CERTIFICATE----- $ cat ~/key.pem -----BEGIN PRIVATE KEY----- ... -----END PRIVATE KEY----- 您在后续步骤中需要此信息。
列表：将敏感变量存储在加密的文件中：创建 vault ： $ ansible-vault create ~/vault.yml New Vault password: <vault_password> Confirm New Vault password: <vault_password> 在 ansible-vault create 命令打开编辑器后，以 <key>: <value> 格式输入敏感数据： root_password: <root_password> certificate: |- -----BEGIN CERTIFICATE----- ... -----END CERTIFICATE----- key: |- …
命令/配置摘录：

$ cat ~/certificate.pem -----BEGIN CERTIFICATE----- ... -----END CERTIFICATE----- $ cat ~/key.pem -----BEGIN PRIVATE KEY----- ... -----END PRIVATE KEY-----
$ ansible-vault create ~/vault.yml New Vault password: <vault_password> Confirm New Vault password: <vault_password>

第 16 章使用 RHEL web 控制台管理容器镜像

要点：您可以使用 RHEL web 控制台管理容器镜像。Web 控制台提供了一个图形界面，允许您通过 Podman containers 部分拉取、修剪或删除容器镜像。

16.1. 在 web 控制台中拉取容器镜像

要点：您可以将容器镜像下载到本地系统，并使用它们创建容器。
要点：先决条件
列表：您已安装了 RHEL 10 web 控制台。具体步骤请参阅安装并启用 Web 控制台。
列表：cockpit-podman 附加组件已安装。
列表：登录到 RHEL 10 web 控制台。
列表：点主菜单中的 Podman containers。
列表：在 Images 表中，单击右上角的溢出菜单，然后选择 Download new image。
列表：此时会打开搜索镜像窗口。
注意：注意您可以通过点击 Images 表中的 Create container 按钮从下载的镜像创建容器。要创建容器，请按照在 web 控制台中创建容器中的步骤 3-8。

16.2. 在 web 控制台中修剪容器镜像

要点：你可以在 RHEL Web 控制台中执行容器镜像清理操作，以移除所有未被使用、且没有任何容器依赖的镜像。
要点：先决条件
列表：至少一个容器镜像已拉取。
列表：您已安装了 RHEL 10 web 控制台。具体步骤请参阅安装并启用 Web 控制台。
列表：cockpit-podman 附加组件已安装：
列表：登录到 RHEL 10 web 控制台。
列表：点主菜单中的 Podman containers。
列表：在 Images 表中，单击右上角的溢出菜单，然后选择 Prune unused images。

16.3. 在 web 控制台中删除容器镜像

要点：您可以使用 Web 控制台删除之前拉取的容器镜像。
要点：先决条件
列表：至少一个容器镜像已拉取。
列表：您已安装了 RHEL 10 web 控制台。
列表：cockpit-podman 附加组件已安装。
列表：登录到 RHEL 10 web 控制台。
列表：单击主菜单中的 Podman containers 按钮。
列表：在 Images 表中，选择您要删除的镜像，然后点溢出菜单并选择 Delete。

第 17 章使用 RHEL web 控制台管理容器

要点：您可以使用 RHEL web 控制台管理容器和 pod。使用 Web 控制台，您可以以非 root 或 root 用户身份创建容器。
要点：作为非 root 用户，您有两个选项：
列表：作为 root 用户，您可以使用额外的特权和选项创建系统容器。
列表：作为非 root 用户，您有两个选项：要仅创建用户容器，您可以在其默认模式 - Limited access 中使用 Web 控制台。要创建用户和系统容器，请单击 Web 控制台页面顶部面板中的 Administrative access。
列表：要仅创建用户容器，您可以在其默认模式 - Limited access 中使用 Web 控制台。
列表：要创建用户和系统容器，请单击 Web 控制台页面顶部面板中的 Administrative access。

17.1. 在 web 控制台中创建一个容器检查点

要点：要保存正在运行的容器的确切当前状态，请在 Red Hat Enterprise Linux web 控制台中创建一个容器检查点。您可以通过设置这个检查点，安全地暂停操作，将工作负载迁移到另一主机，或者稍后恢复容器，而不会丢失当前进度。
要点：先决条件
列表：容器正在运行。
列表：您已安装了 RHEL 10 web 控制台。具体步骤请参阅安装并启用 Web 控制台。
列表：cockpit-podman 附加组件已安装。
列表：登录到 RHEL 10 web 控制台。
列表：点主菜单中的 Podman containers。
列表：在 Containers 表中，选择您要修改的容器，点击溢出图标菜单，并选择 Checkpoint。
注意：注意创建检查点仅适用于系统容器。

17.2. 在 web 控制台中恢复容器检查点

要点：要从之前保存的状态恢复操作，您可以在 Red Hat Enterprise Linux web 控制台中恢复容器检查点。您还可以在主机重启后快速恢复工作负载，或者在不丢失数据的情况下使迁移的容器恢复在线。
要点：先决条件
列表：已对容器执行了检查点。
列表：您已安装了 RHEL 10 web 控制台。具体步骤请参阅安装并启用 Web 控制台。
列表：cockpit-podman 附加组件已安装。
列表：登录到 RHEL 10 web 控制台。
列表：点主菜单中的 Podman containers。
列表：在 Containers 表中，选择您要修改的容器，点击溢出菜单，并选择 Restore。
注意：注意创建检查点仅适用于系统容器。

17.3. 在 web 控制台中创建 pod

要点：要将相关容器作为一个单元分组和管理，您可以在 Red Hat Enterprise Linux web 控制台界面中创建容器 pod。
要点：先决条件
列表：您已安装了 RHEL 10 web 控制台。具体步骤请参阅安装并启用 Web 控制台。
列表：cockpit-podman 附加组件已安装。
列表：登录到 RHEL 10 web 控制台。
列表：点主菜单中的 Podman containers。
列表：点 Create pod。
列表：在 Create pod 表格里提供所需的信息：仅适用于管理访问：选择容器的所有者：系统或用户。在 Name 字段中输入容器的名称。点 Add port mapping ，来添加容器和主机系统之间的端口映射。输入 IP 地址、主机端口、容器端口和协议。点 Add volume 添加卷。输入主机路径，容器路径。您可以选中 Writable 复选框来创建可写卷。在 SELinux 下拉列表中，选择以下一个选项： No Label、Share 或 Private。

17.4. 在 web 控制台中在 pod 中创建容器

要点：您可以使用 RHEL web 控制台 GUI 在 pod 中创建容器。
要点：先决条件
列表：您已安装了 RHEL 10 web 控制台。具体步骤请参阅安装并启用 Web 控制台。
列表：cockpit-podman 附加组件已安装。
列表：登录到 RHEL 10 web 控制台。
列表：点主菜单中的 Podman containers。
列表：点 Create container in pod。
列表：在 Name 字段中输入容器的名称。
注意：注意容器和 pod 的所有者是相同的。在 pod 中，您可以检查容器，更改容器的状态、提交容器或删除容器。

第 18 章为无根 Podman 配置统一配置

要点：您可以使用统一的系统范围的配置文件，集中管理策略并在 Podman 的所有无根用户间标准化操作。个人配置文件可覆盖系统默认值，而无需手动配置。

18.1. rootless Podman 的统一配置概述

要点：默认情况下，containers.conf rootless 读取 /etc/containers/containers.conf 里影响所有用户的全局配置。过去缺乏一种集中配置机制，无法在不影响 rootful podman 进程的情况下，为系统中所有用户统一配置 rootless Podman 的默认设置。
要点：对于只影响无根用户的全局配置，请使用 /etc/containers/containers.rootless.d/.conf 和 /etc/containers/containers.rootless.d/$UID/.conf。
列表：对于系统管理员：您可以为无根容器设置机构范围内的默认值，跨所有用户建立一致的配置，并通过强制实施通用资源限值、registry 设置和运行时行为来实现操作标准化。
列表：对于最终用户：您在没有手动配置的情况下继承默认值，通过个人配置文件覆盖系统默认值，并实现向后兼容性，因为您不需要更改现有用户工作流或配置。

18.2. 配置统一配置

要点：要在 RHEL 上为无根 Podman 配置统一设置，您必须主要管理系统范围的先决条件设置，同时允许用户覆盖其主目录中的特定配置。
要点：先决条件
列表：已安装 Podman。
列表：您已确认是否设置了 rootless 配置。
列表：您可以使用两个可用的方法配置统一配置：您可以为所有非 root 用户配置设置：创建 /etc/containers/containers.rootless.conf.d/ 目录，以便为所有非 root 用户设置该配置。 $ mkdir /etc/containers/containers.rootless.conf.d/ 创建 /etc/containers/containers.rootless.conf.d/dns.conf 配置文件，例如设置 dns 服务器： [containers] dns_servers = [ "1.1.1.1", "8.8.8.8", ] 您可以为指定的非 root 用户配置设置：创建 /…
列表：您可以为所有非 root 用户配置设置：创建 /etc/containers/containers.rootless.conf.d/ 目录，以便为所有非 root 用户设置该配置。 $ mkdir /etc/containers/containers.rootless.conf.d/ 创建 /etc/containers/containers.rootless.conf.d/dns.conf 配置文件，例如设置 dns 服务器： [containers] dns_servers = [ "1.1.1.1", "8.8.8.8", ]
列表：创建 /etc/containers/containers.rootless.conf.d/ 目录，以便为所有非 root 用户设置该配置。 $ mkdir /etc/containers/containers.rootless.conf.d/
列表：创建 /etc/containers/containers.rootless.conf.d/dns.conf 配置文件，例如设置 dns 服务器： [containers] dns_servers = [ "1.1.1.1", "8.8.8.8", ]
命令/配置摘录：

$ mkdir /etc/containers/containers.rootless.conf.d/
[containers] dns_servers = [  "1.1.1.1",  "8.8.8.8", ]

第 19 章在容器中运行 Skopeo、Buildah 和 Podman

要点：要在不直接安装这些工具的情况下在主机上构建、检查和管理您的镜像，请在 Red Hat Enterprise Linux 上的容器内运行 Skopeo、Buildah 和 Podman。隔离容器操作可简化部署管道并维护干净的主机环境。

19.1. 容器中 Skopeo、Buildah 和 Podman 概述

要点：您可以在 Red Hat Enterprise Linux 上的容器化环境中运行 Skopeo、Buildah 和 Podman。这提供多种优点，包括无根操作和无守护进程架构。您可以在自包含的环境中管理、构建和检查容器镜像。
要点：使用 Skopeo，您可以检查远程注册中心中的镜像，而无需下载整个镜像及其所有层。您还可以使用 Skopeo 来复制镜像、签名镜像、同步镜像以及在不同格式和层压缩间转换镜像。
列表：CI/CD 系统： Podman 和 Skopeo ：您可以在 Kubernetes 中运行 CI/CD 系统，或使用 OpenShift 构建容器镜像，并在不同的容器注册表之间分发这些镜像。要将 Skopeo 集成到 Kubernetes 工作流中，您需要在容器中运行它。 Buildah：您希望在 Kubernetes 或 OpenShift CI/CD 系统中构建持续构建镜像的 OCI/container 镜像。这等同于授予系统 root 访问权限而无需密码，这不安全。因此，红帽建议在容器中使用 Buildah。
列表：Podman 和 Skopeo ：您可以在 Kubernetes 中运行 CI/CD 系统，或使用 OpenShift 构建容器镜像，并在不同的容器注册表之间分发这些镜像。要将 Skopeo 集成到 Kubernetes 工作流中，您需要在容器中运行它。
列表：Buildah：您希望在 Kubernetes 或 OpenShift CI/CD 系统中构建持续构建镜像的 OCI/container 镜像。这等同于授予系统 root 访问权限而无需密码，这不安全。因此，红帽建议在容器中使用 Buildah。
列表：不同的版本： All ：您正在主机上运行一个旧的操作系统，但您想要运行最新版本的 Skopeo、Buildah 或 Podman。解决方法是在容器中运行容器工具。例如，这对在无法原生访问最新版本的 Red Hat Enterprise Linux 7 容器主机上运行 Red Hat Enterprise Linux 8 提供的最新版本的容器工具很有用。
列表：All ：您正在主机上运行一个旧的操作系统，但您想要运行最新版本的 Skopeo、Buildah 或 Podman。解决方法是在容器中运行容器工具。例如，这对在无法原生访问最新版本的 Red Hat Enterprise Linux 7 容器主机上运行 Red Hat Enterprise Linux 8 提供的最新版本的容器工具很有用。
列表：HPC 环境： All ：HPC 环境中的一个常见的限制是不允许非 root 用户在主机上安装软件包。当您在容器中运行 Skopeo、Buildah 或 Podman 时，您可以以非 root 用户身份执行这些特定的任务。

19.2. 在容器中运行 Skopeo

要点：您可以使用 Skopeo 检查远程容器镜像。在容器中运行 Skopeo 意味着容器根文件系统与主机 root 文件系统分离。要在主机和容器间共享或复制文件，您必须挂载文件和目录。
要点：先决条件
列表：container-tools 元数据包已安装。
列表：登录到 registry.redhat.io 注册中心: $ podman login registry.redhat.io Username: myuser@mycompany.com Password: <password> Login Succeeded!
列表：获取 registry.redhat.io/rhel10/skopeo 容器镜像： $ podman pull registry.redhat.io/rhel10/skopeo
列表：使用 Skopeo 检查远程容器镜像 registry.access.redhat.com/ubi10/ubi: $ podman run --rm registry.redhat.io/rhel10/skopeo \ skopeo inspect docker://registry.access.redhat.com/ubi10/ubi { "Name": "registry.access.redhat.com/ubi10/ubi", ... "Labels": { "architecture": "x86_64", ... "name": "ubi10", ... "summary": "Provides t…
列表：如何在容器中运行 skopeo
命令/配置摘录：

$ podman login registry.redhat.io Username: myuser@mycompany.com Password: <password> Login Succeeded!
$ podman pull registry.redhat.io/rhel10/skopeo

19.3. 使用凭证在容器中运行 Skopeo

要点：使用容器 registry 需要进行身份验证才能访问和更改数据。Skopeo 支持各种指定凭证的方法。例如，您可以使用 --cred USERNAME[:PASSWORD] 选项在命令行中指定凭证。
要点：先决条件
列表：container-tools 元数据包已安装。
列表：使用 Skopeo 根据锁定的注册中心检查远程容器镜像： $ podman run --rm registry.redhat.io/rhel10/skopeo inspect --creds $USER:$PASSWORD docker://$IMAGE
列表：如何在容器中运行 Skopeo
命令/配置摘录：

$ podman run --rm registry.redhat.io/rhel10/skopeo inspect --creds $USER:$PASSWORD docker://$IMAGE

19.4. 使用 authfile 在容器中运行 Skopeo

要点：您可以使用身份验证文件（authfile）来指定凭证。skopeo login 命令登录到特定的注册中心，并将身份验证令牌存储在 authfile 中。使用 authfile 的优点是，无需重复输入凭证。
要点：当在同一主机上运行时，所有容器工具，如 Skopeo、Buildah 和 Podman 共享相同的 authfile。在容器中运行 Skopeo 时，您必须通过在容器中卷挂载 authfile 来共享主机上的 authfile，或者您必须在容器内重新验证。
列表：container-tools 元数据包已安装。
列表：使用 Skopeo 根据锁定的注册中心检查远程容器镜像： $ podman run --rm -v $AUTHFILE:/auth.json registry.redhat.io/rhel10/skopeo inspect docker://$IMAGE -v $AUTHFILE:/auth.json 选项会将 authfile 卷挂载在容器中的 /auth.json 处。Skopeo 现在可以访问主机上的 authfile 中的身份验证令牌，并获得对注册中心的安全访问。其他 Skopeo 命令的工作方式类似，例如：使用 skopeo-copy 命令，通过 --source-creds 和 --dest-creds 选项在命令…
列表：使用 skopeo-copy 命令，通过 --source-creds 和 --dest-creds 选项在命令行中为源和目标镜像指定凭据。它还读取 /auth.json authfile。
列表：如果要为源和目标镜像指定单独的 authfile，请使用 --source-authfile 和 --dest-authfile 选项，并将这些 authfiles 从主机卷挂载到容器中。
列表：如何在容器中运行 Skopeo
命令/配置摘录：

$ podman run --rm -v $AUTHFILE:/auth.json registry.redhat.io/rhel10/skopeo inspect docker://$IMAGE

19.5. 将容器镜像复制到主机或从主机复制

要点：Skopeo、Buildah 和 Podman 共享相同的本地容器镜像存储。如果要将容器复制到主机容器存储中或从主机容器存储中复制，则必须将其挂载到 Skopeo 容器中。
要点：先决条件
列表：container-tools 元数据包已安装。
列表：将 registry.access.redhat.com/ubi10/ubi 镜像复制到本地容器存储中： $ podman run --privileged --rm -v $HOME/.local/share/containers/storage:/var/lib/containers/storage \ registry.redhat.io/rhel10/skopeo skopeo copy \ docker://registry.access.redhat.com/ubi10/ubi containers-storage:registry.access.redhat.com/ubi10/ubi privileged 选项禁用…
列表：privileged 选项禁用所有安全机制。红帽建议仅在可信环境中使用这个选项。
列表：为了避免禁用安全机制，请将镜像导出到 tarball 或其它基于路径的镜像传输,并将其挂载到 Skopeo 容器中： $ podman save --format oci-archive -o oci.tar $IMAGE $ podman run --rm -v oci.tar:/oci.tar registry.redhat.io/rhel10/skopeo copy oci-archive:/oci.tar $DESTINATION
列表：$ podman save --format oci-archive -o oci.tar $IMAGE
列表：$ podman run --rm -v oci.tar:/oci.tar registry.redhat.io/rhel10/skopeo copy oci-archive:/oci.tar $DESTINATION
命令/配置摘录：

$ podman run --privileged --rm -v $HOME/.local/share/containers/storage:/var/lib/containers/storage \ registry.redhat.io/rhel10/skopeo skopeo copy \ docker://registry.access.redhat.com/ubi10/ubi containers-storage:registry.access.redhat.com/ubi10/ubi
$ podman images REPOSITORY TAG IMAGE ID CREATED SIZE registry.access.redhat.com/ubi10/ubi latest ecbc6f53bba0 8 weeks ago 211 MB

注意：注意到主机容器存储的路径在 root 用户(/var/lib/containers/storage)和非 root 用户($HOME/.local/share/containers/storage)之间有所不同。

19.6. 在容器中运行 Buildah

要点：在容器内运行 Buildah，以在隔离的环境中运行镜像。这可在不修改主机系统的情况下启用镜像创建。
要点：先决条件
列表：container-tools 元数据包已安装。
列表：登录到 registry.redhat.io 注册中心: $ podman login registry.redhat.io Username: myuser@mycompany.com Password: <password> Login Succeeded!
列表：拉取并运行 registry.redhat.io/rhel10/buildah 镜像： # podman run --rm --device /dev/fuse -it \ registry.redhat.io/rhel10/buildah /bin/bash --rm 选项会在容器退出后删除 registry.redhat.io/rhel10/buildah 镜像。 device 选项将主机设备添加到容器中。 sys_chroot - 能够更改为不同的根目录。它不包含在容器的默认功能中。
列表：--rm 选项会在容器退出后删除 registry.redhat.io/rhel10/buildah 镜像。
列表：device 选项将主机设备添加到容器中。
列表：sys_chroot - 能够更改为不同的根目录。它不包含在容器的默认功能中。
命令/配置摘录：

$ podman login registry.redhat.io Username: myuser@mycompany.com Password: <password> Login Succeeded!
# podman run --rm --device /dev/fuse -it \  registry.redhat.io/rhel10/buildah /bin/bash

19.7. 特权和非特权 Podman 容器

要点：默认情况下，Podman 容器是非特权的，例如无法修改主机操作系统的部分。这是因为容器默认仅限制对设备的访问。
要点：下表强调了特权容器的重要属性：您可以使用 podman run --privileged <image_name> 命令运行特权容器。
列表：特权容器被授予与启动容器的用户相同的设备访问权限。
列表：特权容器禁用将容器与主机隔离的安全功能。丢弃的功能、有限的设备、只读挂载点、Apparmor 或 SELinux 隔离以及 Seccomp 过滤器都被禁用。
列表：特权容器不能比启动它们的帐户具有更多的特权。
列表：如何将 --privileged 标志用于容器引擎

19.8. 运行带扩展权限的 Podman

要点：当无根操作不可行时，您可以使用扩展权限在容器中运行 Podman。请谨慎使用此方法，因为它减少了安全隔离。
要点：先决条件
列表：container-tools 元数据包已安装。
列表：在 Podman 容器中运行 Podman 容器： $ podman run --privileged --name=privileged_podman \ registry.access.redhat.com//podman podman run ubi10 echo hello Resolved "ubi10" as an alias (/etc/containers/registries.conf.d/001-rhel-shortnames.conf) Trying to pull registry.access.redhat.com/ubi10:latest... ... Storing signatures hello
列表：根据 registry.access.redhat.com/ubi10/podman 镜像，运行名为 privileged_podman 的外部容器。
列表：--privileged 选项禁用将容器与主机隔离的安全功能。
列表：运行 podman run ubi10 echo hello 命令，以基于 ubi10 镜像创建内容器。
列表：请注意，ubi10 短镜像名称被解析为别名。因此，拉取了 registry.access.redhat.com/ubi10:latest 镜像。
命令/配置摘录：

$ podman run --privileged --name=privileged_podman \  registry.access.redhat.com//podman podman run ubi10 echo hello Resolved "ubi10" as an alias (/etc/containers/registries.conf.d/001-rhel-shortnames.conf) Trying to pull registry.access.redhat.com/ubi10:latest... ... Storing signatures hello
$ podman ps -a CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 52537876caf4 registry.access.redhat.com/ubi10/podman podman run ubi10 e... 30 seconds ago Exited (0) 13 seconds ago privileged_podman

19.9. 运行具有较少特权的 Podman

要点：您可以运行两个嵌套的 Podman 容器，而无需使用 --privileged 选项。运行不带 --privileged 选项的容器是一个更安全的选择。如果您要以尽可能安全的方式尝试不同版本的 Podman，这非常有用。
要点：先决条件
列表：container-tools 元数据包已安装。
列表：运行两个嵌套的容器： $ podman run --name=unprivileged_podman --security-opt label=disable \ --user podman --device /dev/fuse \ registry.access.redhat.com/ubi10/podman \ podman run ubi10 echo hello
列表：运行基于 registry.access.redhat.com/ubi10/podman 镜像的、名为 unprivileged_podman 的外部容器。
列表：--security-opt label=disable 选项禁用主机 Podman 上的 SELinux 隔离。SELinux 不允许容器化进程挂载在容器内运行所需的所有文件系统。
列表：--user podman 选项会自动使外部容器内的 Podman 在用户命名空间内运行。
列表：--device /dev/fuse 选项使用容器中的 fuse-overlayfs 软件包。此选项将 /dev/fuse 添加到外部容器中，因此容器中的 Podman 可以使用它。
命令/配置摘录：

$ podman run --name=unprivileged_podman --security-opt label=disable \  --user podman --device /dev/fuse \  registry.access.redhat.com/ubi10/podman \  podman run ubi10 echo hello
$ podman ps -a CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES a47b26290f43 podman run ubi10 e... 30 seconds ago Exited (0) 13 seconds ago unprivileged_podman

19.10. 在 Podman 容器内构建容器

要点：要创建隔离的开发环境或自动 CI/CD 管道中的镜像构建，您可以从现有的 Podman 容器中构建容器镜像。您还可以在不修改主机系统配置的情况下测试并开发镜像。
要点：先决条件
列表：container-tools 元数据包已安装。
列表：登陆到 registry.redhat.io 注册中心: # podman login registry.redhat.io
列表：运行基于 registry.redhat.io/rhel10/podman 镜像的容器： # podman run --privileged --name podman_container -it \ registry.redhat.io/rhel10/podman /bin/bash 运行基于 registry.redhat.io/rhel10/podman 镜像的、名为 podman_container 的外部容器。--it 选项指定您要在容器内运行交互式 bash shell。--privileged 选项禁用将容器与主机隔离的安全功能。
列表：在 podman_container 容器中创建一个 Containerfile： # vi Containerfile FROM registry.access.redhat.com/ubi10/ubi RUN dnf install -y https://dl.fedoraproject.org/pub/epel/epel-release-latest-8.noarch.rpm RUN dnf -y install moon-buggy && dnf clean all CMD ["/usr/bin/moon-buggy"] Containerfile 中的命令会导致以下构建命令：从 registry.access.redh…
列表：从 registry.access.redhat.com/ubi10/ubi 镜像构建容器。
列表：安装 epel-release-latest-8.noarch.rpm 软件包。
命令/配置摘录：

# podman login registry.redhat.io
# podman run --privileged --name podman_container -it \  registry.redhat.io/rhel10/podman /bin/bash

第 20 章监控容器

要点：您可以使用 Podman 和 RHEL web 控制台等工具来监控 RHEL 上的容器。主要方法包括检查容器日志、监控资源使用量以及检查容器进程的健康状态。

20.1. 对容器使用健康检查

要点：要确定容器中运行的进程的健康状态或就绪状态，您可以执行健康检查。如果健康检查成功，容器会标记为 "healthy"。否则，它是"unhealthy"。
要点：您可以通过运行 podman exec 命令来比较健康检查，并检查退出代码。零退出值表示容器处于健康状态。在 Containerfile 中使用 HEALTHCHECK 指令或在命令行上创建容器时，可以在构建镜像时设置健康检查。
列表：命令
列表：Retries（重试）
列表：Interval（间隔）
列表：Start-period（开始期间）
列表：Timeout（超时）
列表：容器恢复
注意：注意 Retries、Interval 和 Start-period 组件的值是持续时间，如 "30s" 或 "1h15m"。有效的时间单位是"ns"、"us"或"µs"，"ms"，"s"、"m"和"h"。
注意：注意 Podman 版本 4.2 及更高版本中提供 --health-on-failure 选项。

20.2. 使用命令行执行健康检查

要点：在命令行上创建容器时，您可以设置健康检查。因此，您可以指定命令和间隔来监控容器的应用程序状态。
要点：先决条件
列表：container-tools 元数据包已安装。
列表：定义健康检查： $ podman run -dt --name=hc-container -p 8080:8080 --health-cmd='curl http://localhost:8080 || exit 1' --health-interval=0 registry.access.redhat.com/ubi10/httpd-24 --health-cmd 选项为容器设置健康检查命令，而 --health-interval=0 则表示您手动运行健康检查。
列表：检查 hc-container 容器的健康状态：使用 podman inspect 命令： $ podman inspect --format='{{json .State.Health.Status}}' hc-container healthy 使用 podman ps 命令： $ podman ps CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES a680c6919fe localhost/hc-container:latest /usr/bin/run-http... 2 minutes ago Up 2 minutes (healthy) hc-contain…
列表：使用 podman inspect 命令： $ podman inspect --format='{{json .State.Health.Status}}' hc-container healthy
列表：使用 podman ps 命令： $ podman ps CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES a680c6919fe localhost/hc-container:latest /usr/bin/run-http... 2 minutes ago Up 2 minutes (healthy) hc-container
列表：使用 podman healthcheck run 命令： $ podman healthcheck run hc-container healthy 如需更多信息，请参阅系统中的 podman-healthcheck (1) 和 podman-run (1) 手册页
命令/配置摘录：

$ podman run -dt --name=hc-container -p 8080:8080 --health-cmd='curl http://localhost:8080 || exit 1' --health-interval=0 registry.access.redhat.com/ubi10/httpd-24
$ podman inspect --format='{{json .State.Health.Status}}' hc-container healthy

20.3. 使用 Containerfile 执行健康检查

要点：您可以使用 Containerfile 中的 HEALTHCHECK 指令来设置健康检查。
要点：先决条件
列表：container-tools 元数据包已安装。
列表：创建 Containerfile ： $ cat Containerfile FROM registry.access.redhat.com/ubi10/httpd-24 EXPOSE 8080 HEALTHCHECK CMD curl http://localhost:8080 || exit 1 注意 HEALTHCHECK 指令仅支持 docker 镜像格式。对于 oci 镜像格式，该指令会被忽略。
列表：构建容器镜像并添加镜像名称： $ podman build --format=docker -t hc-container . STEP 1/3: FROM registry.access.redhat.com/ubi10/httpd-24 STEP 2/3: EXPOSE 8080 --> 5aea97430fd STEP 3/3: HEALTHCHECK CMD curl http://localhost:8080 || exit 1 COMMIT health-check Successfully tagged localhost/health-check:latest a680c6919fe6bf1a79219a1b3d6…
列表：运行容器： $ podman run -dt --name=hc-container localhost/hc-container
列表：检查 hc-container 容器的健康状态：使用 podman inspect 命令： $ podman inspect --format='{{json .State.Health.Status}}' hc-container healthy 使用 podman ps 命令： $ podman ps CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES a680c6919fe localhost/hc-container:latest /usr/bin/run-http... 2 minutes ago Up 2 minutes (healthy) hc-contain…
列表：使用 podman inspect 命令： $ podman inspect --format='{{json .State.Health.Status}}' hc-container healthy
命令/配置摘录：

$ cat Containerfile FROM registry.access.redhat.com/ubi10/httpd-24 EXPOSE 8080 HEALTHCHECK CMD curl http://localhost:8080 || exit 1
$ podman build --format=docker -t hc-container . STEP 1/3: FROM registry.access.redhat.com/ubi10/httpd-24 STEP 2/3: EXPOSE 8080 --> 5aea97430fd STEP 3/3: HEALTHCHECK CMD curl http://localhost:8080 || exit 1 COMMIT health-check Successfully tagged localhost/health-check:latest a680c6919fe6bf1a79219a1b3d6216550d5a8f83570c36d0dadfee1bb74b924e

注意：注意 HEALTHCHECK 指令仅支持 docker 镜像格式。对于 oci 镜像格式，该指令会被忽略。

20.4. 显示 Podman 系统信息

要点：使用 podman system 命令查看 Podman 的综合系统信息和磁盘使用情况。这有助于监控存储消耗并验证环境详情。
要点：先决条件
列表：container-tools 元数据包已安装。
列表：显示 Podman 系统信息：要显示 Podman 磁盘用量，请输入： $ podman system df TYPE TOTAL ACTIVE SIZE RECLAIMABLE Images 3 2 1.085GB 233.4MB (0%) Containers 2 0 28.17kB 28.17kB (100%) Local Volumes 3 0 0B 0B (0%) 要显示空间使用情况的详细信息，请输入： $ podman system df -v Images space usage: REPOSITORY TAG IMAGE ID CREATED SIZE SHARED SIZE UNIQUE SIZE CONTAI…
列表：要显示 Podman 磁盘用量，请输入： $ podman system df TYPE TOTAL ACTIVE SIZE RECLAIMABLE Images 3 2 1.085GB 233.4MB (0%) Containers 2 0 28.17kB 28.17kB (100%) Local Volumes 3 0 0B 0B (0%)
列表：要显示空间使用情况的详细信息，请输入： $ podman system df -v Images space usage: REPOSITORY TAG IMAGE ID CREATED SIZE SHARED SIZE UNIQUE SIZE CONTAINERS registry.access.redhat.com/ubi10 latest b1e63aaae5cf 13 days 233.4MB 233.4MB 0B 0 registry.access.redhat.com/ubi10/httpd-24 latest 0d04740850e8 13 days 461.5MB 0B 461.5MB 1 registry.red…
列表：要显示主机、当前存储统计和 Podman 构建的信息，请输入： $ podman system info host: arch: amd64 buildahVersion: 1.22.3 cgroupControllers: [] cgroupManager: cgroupfs cgroupVersion: v2 conmon: package: conmon-2.0.29-1.module+el8.5.0+12381+e822eb26.x86_64 path: /usr/bin/conmon version: 'conmon version 2.0.29, commit: 7d0fa63455025991c2f…
列表：要删除所有未使用的容器、镜像和卷数据，请输入： $ podman system prune WARNING! This will remove: - all stopped containers - all stopped pods - all dangling images - all build cache Are you sure you want to continue? [y/N] y podman system prune 命令删除所有未使用的容器(包括angling 和 unreferenced)、pod 以及可选的来自本地存储的卷。使用 --all 选项删除所有未使用的镜像，包括 dangling 镜像和任…
命令/配置摘录：

$ podman system df TYPE TOTAL ACTIVE SIZE RECLAIMABLE Images 3 2 1.085GB 233.4MB (0%) Containers 2 0 28.17kB 28.17kB (100%) Local Volumes 3 0 0B 0B (0%)
$ podman system df -v Images space usage: REPOSITORY TAG IMAGE ID CREATED SIZE SHARED SIZE UNIQUE SIZE CONTAINERS registry.access.redhat.com/ubi10 latest b1e63aaae5cf 13 days 233.4MB 233.4MB 0B 0 registry.access.redhat.com/ubi10/httpd-24 latest 0d04740850e8 13 days 461.5MB 0B 461.5MB 1 registry.redhat.io/rhel8/podman latest dce10f591a2d 13 days 390.6MB 233.4MB 157.2MB 1 Containers space usage: CONTAINER ID IMAGE COMMAND LOCAL VOLUMES SIZE CREATED STATUS NAMES 311180ab99fb 0d04740850e8 /usr/bin/run-httpd 0 28.17kB 16 hours exited hc1 bedb6c287ed6 dce10f591a2d podman run ubi10 echo hello 0 0B 11 hours configured dazzling_tu Local Volumes space…

20.5. podman 事件类型

要点：了解 Podman 报告的各种事件类型，如容器创建、镜像拉取和 pod 生命周期更改。监控这些事件有助于跟踪系统活动。
要点：容器事件类型会报告以下状态：
列表：attach
列表：checkpoint
列表：cleanup
列表：commit
列表：create
列表：exec

20.6. 监控 Podman 事件

要点：使用 podman events 命令跟踪实时系统活动。这将显示带有时间戳和详情的事件流，可用于审核和故障排除。
要点：先决条件
列表：container-tools 元数据包已安装。
列表：运行 myubi 容器： $ podman run -q --rm --name=myubi registry.access.redhat.com/ubi10/ubi:latest
列表：显示 Podman 事件：要显示所有 Podman 事件，请输入： $ now=$(date --iso-8601=seconds) $ podman events --since=now --stream=false 2023-03-08 14:27:20.696167362 +0100 CET container create d4748226a2bcd271b1bc4b9f88b54e8271c13ffea9b30529968291c62d72fe09 (image=registry.access.redhat.com/ubi10/ubi:latest, name=myubi,...) 2023-03-08 14:27:2…
列表：要显示所有 Podman 事件，请输入： $ now=$(date --iso-8601=seconds) $ podman events --since=now --stream=false 2023-03-08 14:27:20.696167362 +0100 CET container create d4748226a2bcd271b1bc4b9f88b54e8271c13ffea9b30529968291c62d72fe09 (image=registry.access.redhat.com/ubi10/ubi:latest, name=myubi,...) 2023-03-08 14:27:20.652325082 +0…
列表：container create 创建新容器。
列表：image pull 如果本地存储中不存在容器镜像，拉取镜像。
命令/配置摘录：

$ podman run -q --rm --name=myubi registry.access.redhat.com/ubi10/ubi:latest
$ now=$(date --iso-8601=seconds) $ podman events --since=now --stream=false 2023-03-08 14:27:20.696167362 +0100 CET container create d4748226a2bcd271b1bc4b9f88b54e8271c13ffea9b30529968291c62d72fe09 (image=registry.access.redhat.com/ubi10/ubi:latest, name=myubi,...) 2023-03-08 14:27:20.652325082 +0100 CET image pull registry.access.redhat.com/ubi10/ubi:latest 2023-03-08 14:27:20.795695396 +0100 CET container init d4748226a2bcd271b1bc4b9f88b54e8271c13ffea9b30529968291c62d72fe09 (image=registry.access.redhat.com/ubi10/ubi:latest, name=myubi...) 2023-03-08 14:27:20.809205161 +0100 CET container start d4748226a2bcd271b1bc4b9f88b54e8271c13ffea9b30…

20.7. 使用 Podman 事件进行审计

要点：通过将 Podman 配置为在事件日志中包括检查数据来增强审计。这样可以在日志条目中直接记录事件的详细上下文，例如安全设置和配置信息。
要点：在以前的版本中，必须连接到事件才能正确解释事件。例如，container-create 事件必须与 image-pull 事件连接，才可以知道使用了哪个镜像。container-create 事件也不包含所有数据，如安全设置、卷、挂载等。
列表：container-tools 元数据包已安装。
列表：修改 ~/.config/containers/containers.conf 文件，并将 events_container_create_inspect_data=true 选项添加到 [engine] 部分： $ cat ~/.config/containers/containers.conf [engine] events_container_create_inspect_data=true 对于系统范围的配置，请修改 /etc/containers/containers.conf 或 /usr/share/container/containers.conf 文件。
列表：创建容器： $ podman create registry.access.redhat.com/ubi10/ubi:latest 19524fe3c145df32d4f0c9af83e7964e4fb79fc4c397c514192d9d7620a36cd3
列表：显示 Podman 事件：使用 podman events 命令： $ now=$(date --iso-8601=seconds) $ podman events --since $now --stream=false --format "{{.ContainerInspectData}}" | jq ".Config.CreateCommand" [ "/usr/bin/podman", "create", "registry.access.redhat.com/ubi10" ] --format "{{.ContainerInspectData}}" 选项显示检查数据。 jq ".Config.CreateComma…
列表：使用 podman events 命令： $ now=$(date --iso-8601=seconds) $ podman events --since $now --stream=false --format "{{.ContainerInspectData}}" | jq ".Config.CreateCommand" [ "/usr/bin/podman", "create", "registry.access.redhat.com/ubi10" ] --format "{{.ContainerInspectData}}" 选项显示检查数据。 jq ".Config.CreateCommand" 将 JSON 数据转…
列表：--format "{{.ContainerInspectData}}" 选项显示检查数据。
命令/配置摘录：

$ cat ~/.config/containers/containers.conf [engine] events_container_create_inspect_data=true
$ podman create registry.access.redhat.com/ubi10/ubi:latest 19524fe3c145df32d4f0c9af83e7964e4fb79fc4c397c514192d9d7620a36cd3

第 21 章使用 Toolbx 进行开发和故障排除

要点：使用 Toolbx 容器在不修改主机系统的情况下安装开发工具。Toolbx 提供了一个无缝的环境，您可以在其中访问主机资源，同时保持系统干净。
要点：在系统上安装软件会带来某些风险。它可能会改变系统的行为，并在不再需要后留下不必要的文件和目录。
列表：将 registry.access.redhat.com/ubi10/toolbox:latest 镜像拉取到您的本地系统
列表：从镜像启动容器
列表：在您可以从其访问主机系统的容器内运行 shell
注意：注意 Toolbx 容器是否以 root 或 rootless 容器运行，这取决于创建容器的用户的权限。您还必须在 root 容器中运行需要 root 权限的工具。

21.1. 启动 Toolbx 容器

要点：您可以启动一个 Toolbx 容器来进入隔离的环境，以进行开发或故障排除。通过进入容器，你可以安装并运行命令行工具，而无需对底层宿主操作系统进行任何修改。
要点：流程
列表：创建一个 Toolbx 容器：作为无根用户： $ toolbox create <mytoolbox> Created container: <mytoolbox> Enter with: toolbox enter <mytoolbox> 作为 root 用户： $ sudo toolbox create <mytoolbox> Created container: <mytoolbox> Enter with: toolbox enter <mytoolbox> 验证您是否拉取了正确的镜像： [user@toolbox ~]$ toolbox list IMAGE ID IMAGE NAME CREATED fe0ae375…
列表：作为无根用户： $ toolbox create <mytoolbox> Created container: <mytoolbox> Enter with: toolbox enter <mytoolbox>
列表：作为 root 用户： $ sudo toolbox create <mytoolbox> Created container: <mytoolbox> Enter with: toolbox enter <mytoolbox>
列表：验证您是否拉取了正确的镜像： [user@toolbox ~]$ toolbox list IMAGE ID IMAGE NAME CREATED fe0ae375f149 registry.access.redhat.com/ubi10/toolbox:latest 5 weeks ago CONTAINER ID CONTAINER NAME CREATED STATUS IMAGE NAME 5245b924c2cb <mytoolbox> 7 minutes ago created registry.access.redhat.com/ubi10/toolbox:latest
列表：进入 Toolbx 容器： [user@toolbox ~]$ toolbox enter <mytoolbox>
列表：在 <mytoolbox> 容器中输入一个命令，并显示容器和镜像的名称： ⬢ [user@toolbox ~]$ cat /run/.containerenv engine="podman-4.8.2" name="<mytoolbox>" id="5245b924c2cb..." image="registry.access.redhat.com/ubi10/toolbox:latest" imageid="fe0ae375f14919cbc0596142e3aff22a70973a36e5a165c75a86ea7ec5d8d65c"
命令/配置摘录：

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

21.2. 使用 Toolbx 进行开发

要点：您可以将 Toolbx 容器用作安装开发工具的无根用户，如编辑器、编译器和软件开发工具包(SDK)。安装完成后，您可以以 rootless 用户身份继续使用这些工具。
要点：先决条件
列表：Toolbx 容器已创建并在运行。您已进入到 Toolbx 容器。您不需要创建具有 root 权限的 Toolbx 容器。请参阅启动 Toolbx 容器。
列表：安装您选择的工具，例如 Emacs 文本编辑器、GCC 编译器和 GNU Debugger (GDB)： ⬢[user@toolbox ~]$ sudo dnf install emacs gcc gdb
列表：验证工具是否已安装： ⬢[user@toolbox ~]$ dnf repoquery --info --installed <package_name>
命令/配置摘录：

⬢[user@toolbox ~]$ sudo dnf install emacs gcc gdb
⬢[user@toolbox ~]$ dnf repoquery --info --installed <package_name>

21.3. 使用 Toolbx 对主机系统进行故障排除

要点：您可以使用具有 root 特权的 Toolbx 容器，通过使用 systemctl、journalctl 和 nmap 等工具来查找主机系统中各种问题的根本原因，而无需在主机系统上安装它们。
要点：先决条件
列表：Toolbx 容器已创建并在运行。您已进入到 Toolbx 容器。您需要创建具有 root 特权的 Toolbx 容器。请参阅启动 Toolbx 容器。
列表：安装 systemd 软件包，以便能够运行 journalctl 命令： ⬢[root@toolbox ~]# dnf install systemd
列表：显示主机上运行的所有进程的日志消息： ⬢[root@toolbox ~]# 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-thinkpad…
列表：显示内核的日志消息： ⬢[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-thinkpad…
列表：安装 nmap 网络扫描工具： ⬢[root@toolbox ~]# dnf install nmap
列表：扫描网络中的 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…
命令/配置摘录：

⬢[root@toolbox ~]# dnf install systemd
⬢[root@toolbox ~]# 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>

21.4. 停止 Toolbx 容器

要点：您可以停止活动中的 Toolbx 容器，从而释放系统资源，并结束本次开发会话。结束容器进程可确保后台任务被终止，允许您为后续工作负载维护干净且高效的环境。
要点：流程
列表：离开容器，并返回到主机： ⬢ [user@toolbox ~]$ exit
列表：停止 toolbox 容器： ⬢ [user@toolbox ~]$ podman stop <mytoolbox>
列表：可选：删除 toolbx 容器： ⬢ [user@toolbox ~]$ toolbox rm <mytoolbox> 另外，您还可以使用 podman rm 命令删除容器。
命令/配置摘录：

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

第 22 章运行特殊容器镜像

要点：使用预定义的命令运行容器，这些命令使用名为 runlabels 的内置标签。使用这些标签，您可以直接从镜像元数据触发特定操作，如 install、run 或 uninstall。

22.1. 打开到主机的权限

要点：了解特权容器的能力，该容器可以访问主机资源。特权容器（如 Toolbx）绕过标准隔离，以便与主机系统交互。
列表：Privileges ：特权容器禁用将容器与主机隔离的安全功能。您可以使用 podman run --privileged <image_name> 命令运行特权容器。例如，您可以删除主机上挂载的 root 用户所拥有的文件和目录。
列表：Process tables ：您可以使用 podman run --privileged --pid=host <image_name> 命令为容器使用主机 PID 命名空间。然后，您可以在特权容器中使用 ps -e 命令列出所有在主机上运行的进程。您可以将来自主机的进程 ID 传给在特权容器中运行的命令（例如：kill <PID>）。
列表：网络接口：默认情况下，容器只有一个外部网络接口和一个回送网络接口。您可以使用 podman run --net=host <image_name> 命令直接从容器内部访问主机网络接口。
列表：进程间的通信: 主机上的 IPC 工具可以从特权容器内访问。您可以运行 ipcs 等命令，来查看主机上活动的消息队列、共享内存段和 semaphore 设置的信息。

22.2. 带有 runlabels 的容器镜像

要点：您可以使用 runlabels 来输入存储在容器镜像中的预定义命令。安装和管理等常见标签简化了复杂容器的部署和管理。
要点：现有 runlabels 包括：
列表：install：在运行镜像前设置主机系统。通常情况下，这会在主机上创建文件和目录，容器可在稍后运行时访问。
列表：run: 标识在运行容器时要使用的 Podman 命令行选项。通常，这个选项在主机上打开特权，并挂载容器需要永久保留在主机上的主机内容。
列表：uninstall ：在运行完容器后清除主机系统。

22.3. 使用 runlabels 运行 support-tools

要点：使用其内置 runlabels 部署 support-tools 容器。此方法通过使用镜像中直接定义的命令来简化安装、执行和删除过程。
要点：制作 rhel10/support-tools 容器镜像的目的是为了运行 support-toolsd 守护进程的容器化版本。support-tools 镜像包含以下 runlabels：install、run 和 uninstall。
列表：container-tools 元数据包已安装。
列表：拉取 support-tools 镜像： # podman pull registry.redhat.io/rhel10/support-tools
列表：显示 support-tools 的 install runlabel： # podman container runlabel install --display rhel10/support-tools command: podman run --rm --privileged -v /:/host -e HOST=/host -e IMAGE=registry.redhat.io/rhel10/support-tools:latest -e NAME=support-tools registry.redhat.io/rhel10/support-tools:latest /bin/install.sh 这表明命令授予主机权限…
列表：对 support-tools 运行 install runlabel： # podman container runlabel install rhel10/support-tools command: podman run --rm --privileged -v /:/host -e HOST=/host -e IMAGE=registry.redhat.io/rhel10/support-tools:latest -e NAME=support-tools registry.redhat.io/rhel10/support-tools:latest /bin/install.sh Creating directory at…
列表：显示 support-tools 的 run runlabel： # podman container runlabel run --display rhel10/support-tools command: podman run -d --privileged --name support-tools --net=host --pid=host -v /etc/pki/support-tools:/etc/pki/support-tools -v /etc/support-tools.conf:/etc/support-tools.conf -v /etc/sysconfig/support-tools:/etc/sysconf…
列表：对 support-tools 运行 run runlabel： # podman container runlabel run rhel10/support-tools command: podman run -d --privileged --name support-tools --net=host --pid=host -v /etc/pki/support-tools:/etc/pki/support-tools -v /etc/support-tools.conf:/etc/support-tools.conf -v /etc/sysconfig/support-tools:/etc/sysconfig/support…
命令/配置摘录：

# podman pull registry.redhat.io/rhel10/support-tools
# podman container runlabel install --display rhel10/support-tools command: podman run --rm --privileged -v /:/host -e HOST=/host -e IMAGE=registry.redhat.io/rhel10/support-tools:latest -e NAME=support-tools registry.redhat.io/rhel10/support-tools:latest /bin/install.sh

注意：注意在这种情况下, uninstall.sh 脚本只删除 /etc/logrotate.d/syslog 文件。它不会清理配置文件。

第 23 章使用 container-tools API

要点：使用基于 REST 的 API 以编程方式与 Podman 交互。此 API 支持 Libpod 和 Docker 兼容端点，允许与外部工具和客户端集成。
要点：Podman 2.0 的新的基于 REST 的 API （替换旧的 varlink 远程 API）提供 rootful 和 rootless 支持。它包括 Podman 的 Libpod API 和 Docker 兼容 API，以便从 cURL、Postman、Google 的高级 REST 客户端等平台调用 Podman。
注意：注意由于 Podman 服务依赖于套接字激活，所以它无法运行，除非连接处于活动状态。您必须手动启动 podman.socket 服务才能启用此功能。建立连接时，Podman 服务将启动，运行请求的 API 操作，然后结束并返回不活跃状态。

23.1. 在 root 模式中使用 systemd 启用 Podman API

要点：您可以通过在 root 模式中启动并启用 systemd 套接字单元，在 RHEL 上启用 Podman API。此配置有助于系统范围的容器管理，并将 Podman 与现有基础架构无缝集成，同时为外部管理工具提供稳定的端点。
要点：先决条件
列表：podman-remote 软件包已安装。
列表：立即启动该服务： # systemctl enable --now podman.socket
列表：使用 docker-podman 软件包启用到 var/lib/docker.sock 的链接： # dnf install podman-docker
列表：显示 Podman 的系统信息： # podman-remote info
列表：验证链接： # ls -al /var/run/docker.sock lrwxrwxrwx. 1 root root 23 Nov 4 10:19 /var/run/docker.sock -> /run/podman/podman.sock
命令/配置摘录：

# systemctl enable --now podman.socket
# dnf install podman-docker

23.2. 在无根模式下使用 systemd 启用 Podman API

要点：您可以使用 systemd 激活 Podman API 套接字和 API 服务。
要点：先决条件
列表：podman-remote 软件包已安装。
列表：立即启用并启动该服务： $ systemctl --user enable --now podman.socket
列表：可选：要使用 Docker 启用程序来与无根 Podman 套接字进行交互： $ export DOCKER_HOST=unix:///run/user/<uid>/podman//podman.sock
列表：检查套接字的状态： $ systemctl --user status podman.socket ● podman.socket - Podman API Socket Loaded: loaded (/usr/lib/systemd/user/podman.socket; enabled; vendor preset: enabled) Active: active (listening) since Mon 2021-08-23 10:37:25 CEST; 9min ago Docs: man:podman-system-service(1) Listen: /run/user/1000/podman/podman.so…
列表：显示 Podman 的系统信息： $ podman-remote info
命令/配置摘录：

$ systemctl --user enable --now podman.socket
$ export DOCKER_HOST=unix:///run/user/<uid>/podman//podman.sock

23.3. 手动运行 Podman API

要点：您可以运行 Podman API。这对于调试 API 调用，特别是在使用 Docker 兼容性层时很有用。
要点：先决条件
列表：podman-remote 软件包已安装。
列表：为 REST API 运行服务： # podman system service -t 0 --log-level=debug 0 表示没有超时。rootful 服务的默认端点为 unix:/run/podman/podman.sock。 --log-level <level> 选项设定日志级别。标准日志记录级别为 debug、info、warn、error、fatal 和 panic。
列表：0 表示没有超时。rootful 服务的默认端点为 unix:/run/podman/podman.sock。
列表：--log-level <level> 选项设定日志级别。标准日志记录级别为 debug、info、warn、error、fatal 和 panic。
列表：在另一个命令行窗口中，显示 Podman 的系统信息。podman-remote 命令与常规的 podman 命令不同，其可通过 Podman 套接字通信： # podman-remote info
列表：要对 Podman API 进行故障排除并显示请求和响应，请使用 curl 命令。以 JSON 格式在 Linux 服务器上获取有关 Podman 安装的信息： # curl -s --unix-socket /run/podman/podman.sock http://d/v1.0.0/libpod/info | jq { "host": { "arch": "amd64", "buildahVersion": "1.15.0", "cgroupVersion": "v2", "conmon": { "package": "conmon-2.0.18-1.module+el8.3.0+7084+c16098dd.x…
命令/配置摘录：

# podman system service -t 0 --log-level=debug
# podman-remote info

完整目录

在 Red Hat Enterprise Linux 上使用 Podman、Buildah 和 Skopeo
对红帽文档提供反馈
第 1 章容器简介
- 1.1. 有关容器命令行工具的信息
- 1.2. Podman、Podman Desktop、Buildah 和 Skopeo 的特性
- 1.3. 不使用 Docker 运行容器
- 1.4. RHEL 中支持的用于容器部署的架构
- 1.5. 安装容器工具
- 1.6. 安装 Podman 桌面
- 1.7. 对 rootless 容器的特别考虑
- 1.8. 使用模块进行高级 Podman 配置
第 2 章容器镜像的类型
- 2.1. RHEL 容器镜像的一般特征
- 2.2. UBI 镜像的特点
- 2.3. 了解 UBI 标准镜像
- 2.4. 了解 UBI init 镜像
- 2.5. 了解 UBI 最小镜像
- 2.6. 了解 UBI 微镜像
第 3 章使用容器注册中心
- 3.1. 容器注册中心
- 3.2. 配置容器注册表
- 3.3. 搜索容器镜像
- 3.4. 配置短名称别名
- 3.5. 使用 policy.json 文件进行容器签名验证
第 4 章使用容器镜像
- 4.1. 从 registry 中拉取镜像
- 4.2. 使用短名称别名拉取容器镜像
- 4.3. 列出镜像
- 4.4. 检查本地镜像
- 4.5. 检查远程镜像
- 4.6. 复制容器镜像
- 4.7. 将镜像层复制到本地目录中
- 4.8. 标记镜像
- 4.9. 构建多架构镜像
- 4.10. 保存并加载镜像
- 4.11. 重新分发 UBI 镜像
- 4.12. 删除镜像
第 5 章操作容器
- 5.1. Podman run 命令概述
- 5.2. 在主机的容器中运行命令
- 5.3. 在容器内运行命令
- 5.4. 构建容器
- 5.5. 列出容器
- 5.6. 启动容器
- 5.7. 检查主机的容器
- 5.8. 将 localhost 上的目录挂载到容器
- 5.9. 挂载容器文件系统
- 5.10. 将服务作为使用静态 IP 的守护进程运行
- 5.11. 在运行中的容器中执行命令
- 5.12. 在两个容器间共享文件
- 5.13. 导出和导入容器
- 5.14. 停止容器
- 5.15. 删除容器
- 5.16. 容器的 SELinux 策略
- 5.17. 在 Podman 中配置预执行钩子
- 5.18. 在容器中调试应用程序
第 6 章可重复生成的容器构建简介
- 6.1. 可复现容器构建的好处
- 6.2. 可重现容器构建对不同环境的影响
- 6.3. 在 RHEL 容器工具中实现可复现性。
- 6.4. 使用可复现成的容器构建
第 7 章将软件添加到 UBI 容器中
- 7.1. 使用 UBI init 镜像
- 7.2. 使用 UBI 微镜像
- 7.3. 在订阅的主机上将软件添加到 UBI 容器中
- 7.4. 在标准 UBI 容器中添加软件
- 7.5. 在最小的 UBI 容器中添加软件
- 7.6. 将软件添加到未订阅的主机上的 UBI 容器中
- 7.7. 构建基于 UBI 的镜像
- 7.8. 使用 Application Stream 运行时镜像
- 7.9. 获取 UBI 容器镜像源代码
第 8 章签名容器镜像
- 8.1. 使用私钥通过 sigstore 签名签名容器镜像
- 8.2. 使用 Fulcio 和 Rekor 使用 sigstore 签名签名容器镜像
- 8.3. 使用私钥和 Rekor ，用 sigstore 签名签名容器镜像
- 8.4. 使用 GPG 签名为容器镜像签名
- 8.5. 使用 Sequoia PGP 在 Podman 中签名容器镜像
第 9 章使用 pod
- 9.1. 创建 pod
- 9.2. 显示 pod 信息
- 9.3. 停止 pod
- 9.4. 删除 pod
第 10 章管理容器网络
- 10.1. 列出容器网络
- 10.2. 检查网络
- 10.3. 创建网络
- 10.4. 将容器连接到网络
- 10.5. 断开容器与网络的连接
- 10.6. 删除网络
- 10.7. 删除所有未使用的网络
第 11 章容器间的通信
- 11.1. 网络模式和层
- 11.2. slirp4netns 和 pasta 之间的区别
- 11.3. 设置网络模式
- 11.4. 检查容器的网络设置
- 11.5. 容器和应用程序间的通信
- 11.6. 容器和主机间的通信
- 11.7. 使用端口映射在容器间通信
- 11.8. 使用 DNS 在容器间通信
- 11.9. 在 pod 中的两个容器间通信
- 11.10. pod 的通信
- 11.11. 将 pod 附加到容器网络
- 11.12. 为 Podman 设置 HTTP 代理变量
第 12 章设置容器网络模式
- 12.1. 使用静态 IP 运行容器
- 12.2. 使用 systemd 为 Netavark 运行 DHCP 插件
- 12.3. MacVLAN 插件
第 13 章使用 Podman 将容器移植到 systemd
- 13.1. 使用 Quadlets 自动生成一个 systemd 单元文件
- 13.2. 启用 systemd 服务
- 13.3. 使用 systemd 自动启动容器
- 13.4. 与 podman generate systemd 命令相比，使用 Quadlets 的优点
- 13.5. 使用 Podman 生成 systemd 单元文件
- 13.6. 使用 Podman 自动生成 systemd 单元文件
- 13.7. 使用 systemd 自动启动 pod
- 13.8. 使用 Podman 自动更新容器
- 13.9. 使用 systemd 自动更新容器
第 14 章使用 Podman 将容器移植到 OpenShift
- 14.1. 使用 Podman 生成 Kubernetes YAML 文件
- 14.2. 在 OpenShift 环境中生成 Kubernetes YAML 文件
- 14.3. 使用 Podman 启动容器和 pod
- 14.4. 在 OpenShift 环境中启动容器和 pod
- 14.5. 使用 Podman 手动运行容器和 pod
- 14.6. 使用 Podman 生成 YAML 文件
- 14.7. 使用 Podman 自动运行容器和 pod
- 14.8. 使用 Podman 自动停止和删除 pod
第 15 章使用 RHEL 系统角色管理容器
- 15.1. RHEL 系统角色与基于 bootc的镜像构建集成
- 15.2. 为 Podman 和其他容器工具配置镜像 registry 管理
- 15.3. 使用 podman RHEL 系统角色创建带有绑定挂载的无根容器
- 15.4. 使用 podman RHEL 系统角色创建一个带有 Podman 卷的有根容器
- 15.5. 使用 podman RHEL 系统角色创建一个带有 secret 的 Quadlet 应用程序
第 16 章使用 RHEL web 控制台管理容器镜像
- 16.1. 在 web 控制台中拉取容器镜像
- 16.2. 在 web 控制台中修剪容器镜像
- 16.3. 在 web 控制台中删除容器镜像
第 17 章使用 RHEL web 控制台管理容器
- 17.1. 在 web 控制台中创建一个容器检查点
- 17.2. 在 web 控制台中恢复容器检查点
- 17.3. 在 web 控制台中创建 pod
- 17.4. 在 web 控制台中在 pod 中创建容器
第 18 章为无根 Podman 配置统一配置
- 18.1. rootless Podman 的统一配置概述
- 18.2. 配置统一配置
第 19 章在容器中运行 Skopeo、Buildah 和 Podman
- 19.1. 容器中 Skopeo、Buildah 和 Podman 概述
- 19.2. 在容器中运行 Skopeo
- 19.3. 使用凭证在容器中运行 Skopeo
- 19.4. 使用 authfile 在容器中运行 Skopeo
- 19.5. 将容器镜像复制到主机或从主机复制
- 19.6. 在容器中运行 Buildah
- 19.7. 特权和非特权 Podman 容器
- 19.8. 运行带扩展权限的 Podman
- 19.9. 运行具有较少特权的 Podman
- 19.10. 在 Podman 容器内构建容器
第 20 章监控容器
- 20.1. 对容器使用健康检查
- 20.2. 使用命令行执行健康检查
- 20.3. 使用 Containerfile 执行健康检查
- 20.4. 显示 Podman 系统信息
- 20.5. podman 事件类型
- 20.6. 监控 Podman 事件
- 20.7. 使用 Podman 事件进行审计
第 21 章使用 Toolbx 进行开发和故障排除
- 21.1. 启动 Toolbx 容器
- 21.2. 使用 Toolbx 进行开发
- 21.3. 使用 Toolbx 对主机系统进行故障排除
- 21.4. 停止 Toolbx 容器
第 22 章运行特殊容器镜像
- 22.1. 打开到主机的权限
- 22.2. 带有 runlabels 的容器镜像
- 22.3. 使用 runlabels 运行 support-tools
第 23 章使用 container-tools API
- 23.1. 在 root 模式中使用 systemd 启用 Podman API
- 23.2. 在无根模式下使用 systemd 启用 Podman API
- 23.3. 手动运行 Podman API