流程

1. 安装 RHEL。

2. 注册 RHEL：输入您的用户名和密码。用户名和密码与您红帽客户门户网站的登录凭证相同：

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

3. 订阅 RHEL。

   • 要自动订阅 RHEL：

     # subscription-manager attach --auto

   • 要按池 ID 订阅 RHEL：

     # subscription-manager attach --pool <PoolID>

4. 安装 container-tools 模块：

   # yum module install -y container-tools

5. 可选：安装 podman-docker 软件包：

   # yum install podman-docker

   podman-docker 软件包使用匹配的 Podman 命令替换 Docker 命令行界面和 docker-api。

流程

1. 安装 RHEL。

2. 安装 podman 软件包：

   # yum install podman -y

3. 创建新的用户帐户：

   # useradd -c "Joe Jones" joe
   # passwd joe

   • 用户会自动配置为能够使用 rootless Podman。
   • useradd 命令会在 /etc/subuid 和 /etc/subgid 文件中自动设置可访问用户和组 ID 的范围。
   • 如果您手动更改 /etc/subuid 或 /etc/subgid，则必须运行 podman system migrate 命令，以允许应用新的更改。

4. 连接到用户：

   $ ssh joe@server.example.com

   注意

   不要使用 su 或 su - 命令，因为这些命令不会设置正确的环境变量。

5. 拉取 registry.access.redhat.com/ubi8/ubi 容器镜像：

   $ podman pull registry.access.redhat.com/ubi8/ubi

6. 运行名为 myubi 的容器,并显示 OS 版本：

   $ podman run --rm --name=myubi registry.access.redhat.com/ubi8/ubi \
     cat /etc/os-release
   NAME="Red Hat Enterprise Linux"
   VERSION="8 (Plow)"

流程

1. 向注册中心进行身份验证：

   # podman login quay.io

2. 搜索镜像：

   • 要搜索特定注册中心中的特定镜像，请输入：

     # podman search quay.io/postgresql-10
     INDEX       NAME                                           DESCRIPTION           STARS   OFFICIAL   AUTOMATED
     redhat.io   registry.redhat.io/rhel8/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 postgresql-10

     要显示完整的描述，请将 --no-trunc 选项传给命令。

流程

1. 登录到 registry.redhat.io registry:

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

2. 拉取 registry.redhat.io/ubi8/ubi 容器镜像：

   $ podman pull registry.redhat.io/ubi8/ubi

流程

1. 创建 /var/lib/images/nginx 目录：

   $ mkdir -p /var/lib/images/nginx

2. 将 docker://docker.io/nginx:latest 镜像 的 层复制到新创建的目录中：

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

流程

1. 列出所有镜像：

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

2. 使用以下选项之一将 myubi 名称分配给 registry.redhat.io/ubi8/ubi 镜像：

   • 镜像名称：

     $ podman tag registry.redhat.io/ubi8/ubi myubi

   • 镜像 ID：

     $ podman tag 3269c37eae33 myubi

     两个命令会给出同样的结果。

3. 列出所有镜像：

   $ podman images
   REPOSITORY                           TAG     IMAGE ID      CREATED       SIZE
   registry.redhat.io/ubi8/ubi          latest  3269c37eae33  2 months ago  208 MB
   localhost/myubi                      latest  3269c37eae33  2 months ago  208 MB

   请注意，两个镜像的默认标签都是 latest。您可以看到所有镜像名称都被分配给单个镜像 ID 3269c37eae33。

4. 使用以下方法将 8 标签添加到 registry.redhat.io/ubi8/ubi 镜像：

   • 镜像名称：

     $ podman tag registry.redhat.io/ubi8/ubi myubi:8

   • 镜像 ID：

     $ podman tag 3269c37eae33 myubi:8

     两个命令会给出同样的结果。

5. 列出所有镜像：

   $ podman images
   REPOSITORY                           TAG     IMAGE ID      CREATED       SIZE
   registry.redhat.io/ubi8/ubi          latest  3269c37eae33  2 months ago  208 MB
   localhost/myubi                      latest  3269c37eae33  2 months ago  208 MB
   localhost/myubi                      8     3269c37eae33  2 months ago  208 MB

   请注意，两个镜像的默认标签都是 latest。您可以看到所有镜像名称都被分配给单个镜像 ID 3269c37eae33。

流程

1. 将 registry.redhat.io/rhel8/rsyslog 镜像保存为 tar 包：

   • 在默认的 docker-dir 格式下：

     $ podman save -o myrsyslog.tar registry.redhat.io/rhel8/rsyslog:latest

   • 在 oci-archive 格式下，使用 --format 选项：

     $ podman save -o myrsyslog-oci.tar --format=oci-archive registry.redhat.io/rhel8/rsyslog

     myrsyslog.tar 和 myrsyslog-oci.tar 存档存储在您的当前目录中。接下来的步骤使用 myrsyslog.tar tar 包来执行。

2. 检查 myrsyslog.tar 的文件类型：

   $ file myrsyslog.tar
   myrsyslog.tar: POSIX tar archive

3. 要从 myrsyslog.tar 加载 registry.redhat.io/rhel8/rsyslog:latest 镜像：

   $ podman load -i myrsyslog.tar
   ...
   Loaded image(s): registry.redhat.io/rhel8/rsyslog:latest

流程

1. 可选：对 ubi 镜像添加一个额外的名称：

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

2. 将 registry.example.com:5000/ubi8/ubi 镜像从本地存储推送到注册中心:

   # podman push registry.example.com:5000/ubi8/ubi

   重要

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

流程

1. 列出本地系统上的所有镜像：

   $ podman images
   REPOSITORY                           TAG     IMAGE ID      CREATED      SIZE
   registry.redhat.io/rhel8/rsyslog     latest  4b32d14201de  7 weeks ago  228 MB
   registry.redhat.io/ubi8/ubi          latest  3269c37eae33  7 weeks ago  208 MB
   localhost/myubi                      X.Y     3269c37eae33  7 weeks ago  208 MB

2. 列出所有容器：

   $ podman ps -a
   CONTAINER ID  IMAGE                                    COMMAND          CREATED        STATUS            PORTS   NAMES
   7ccd6001166e  registry.redhat.io/rhel8/rsyslog:latest  /bin/rsyslog.sh  6 seconds ago  Up 5 seconds ago          mysyslog

   要删除 registry.redhat.io/rhel8/rsyslog 镜像，您必须使用 podman stop 命令停止运行此镜像的所有容器。您可以通过其 ID 或名称来停止容器。

3. 停止 mysyslog 容器：

   $ podman stop mysyslog
   7ccd6001166e9720c47fbeb077e0afd0bb635e74a1b0ede3fd34d09eaf5a52e9

4. 删除 registry.redhat.io/rhel8/rsyslog 镜像：

   $ podman rmi registry.redhat.io/rhel8/rsyslog

   • 要删除多个镜像：

     $ podman rmi registry.redhat.io/rhel8/rsyslog registry.redhat.io/ubi8/ubi

   • 要从您的系统中删除所有镜像：

     $ podman rmi -a

   • 要删除与其有多个名称（标记）关联的镜像，请添加 -f 选项来删除它们：

     $ podman rmi -f 1de7d7b3f531
     1de7d7b3f531...

流程

1. 使用 cat /etc/os-release 命令，显示基于 registry.access.redhat.com/ubi8/ubi 容器镜像的容器的操作系统的类型：

   $ podman run --rm registry.access.redhat.com/ubi8/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 8"
   ...

2. 可选：列出所有容器。

   $ podman ps
   CONTAINER ID  IMAGE   COMMAND  CREATED  STATUS  PORTS   NAMES

   由于 --rm 选项，您应该看不到任何容器。容器已被删除。

流程

1. 运行基于 registry.redhat.io/ubi8/ubi 镜像的名为 myubi 的容器：

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

   • -i 选项创建一个交互式会话。如果不使用 -t 选项，shell 将保持打开状态，但您无法对 shell 输入任何东西。
   • -t 选项打开一个终端会话。如果不使用 -i 选项，shell 会打开，然后退出。

2. 安装 procps-ng 软件包，其包含一组系统工具（如 ps、top 和 uptime ，等等）：

   [root@6ccffd0f6421 /]# yum install procps-ng

3. 使用 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

4. 输入 exit 退出容器并返回到主机：

   # exit

5. 可选：列出所有容器：

   $ podman ps
   CONTAINER ID  IMAGE                               COMMAND    CREATED         STATUS                     PORTS   NAMES
   1984555a2c27  registry.redhat.io/ubi8/ubi:latest  /bin/bash  21 minutes ago  Exited (0) 21 minutes ago          myubi

   您可以看到容器处于 Exited 状态。

流程

1. 运行基于 registry.redhat.io/rhel8/rsyslog 镜像的容器：

   $ podman run -d registry.redhat.io/rhel8/rsyslog

2. 列出所有容器：

   • 要列出所有正在运行的容器：

     $ podman ps
     CONTAINER ID IMAGE              COMMAND         CREATED       STATUS            PORTS NAMES
     74b1da000a11 rhel8/rsyslog /bin/rsyslog.sh 2 minutes ago Up About a minute       musing_brown

   • 要列出所有运行或停止的容器：

     $ podman ps -a
     CONTAINER ID IMAGE         COMMAND    CREATED    STATUS                PORTS NAMES     IS INFRA
     d65aecc325a4 ubi8/ubi      /bin/bash  3 secs ago Exited (0) 5 secs ago peaceful_hopper false
     74b1da000a11 rhel8/rsyslog rsyslog.sh 2 mins ago Up About a minute     musing_brown    false

流程

1. 启动 myubi 容器：

   • 在非互动模式中：

     $ podman start myubi

     另外，您可以使用 podman start 1984555a2c27。

   • 在交互模式中，使用 -a (--attach)和 -i (--interactive)选项来使用容器 bash shell：

     $ podman start -a -i myubi

     或者，您可以使用 podman start -a -i 1984555a2c27。

2. 输入 exit 退出容器并返回到主机：

   [root@6ccffd0f6421 /]# exit

流程

1. 运行名为 log_test 的容器，并在容器内挂载主机 /dev/log 设备：

   # podman run --name="log_test" -v /dev/log:/dev/log --rm \
     registry.redhat.io/ubi8/ubi logger "Testing logging to the host"

2. 使用 journalctl 工具来显示日志：

   # journalctl -b | grep Testing
   Dec 09 16:55:00 localhost.localdomain root[14634]: Testing logging to the host

   --rm 选项会在容器退出时删除容器。

流程

1. 运行名为 mysyslog 的容器：

   # podman run -d --name=mysyslog registry.redhat.io/rhel8/rsyslog

2. 可选：列出所有容器：

   # podman ps -a
   CONTAINER ID  IMAGE                                    COMMAND          CREATED         STATUS                     PORTS   NAMES
   c56ef6a256f8  registry.redhat.io/rhel8/rsyslog:latest  /bin/rsyslog.sh  20 minutes ago  Up 20 minutes ago                  mysyslog

3. 挂载 mysyslog 容器：

   # podman mount mysyslog
   /var/lib/containers/storage/overlay/990b5c6ddcdeed4bde7b245885ce4544c553d108310e2b797d7be46750894719/merged

4. 使用 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

5. 显示 OS 版本：

   # cat /var/lib/containers/storage/overlay/990b5c6ddcdeed4bde7b245885ce4544c553d108310e2b797d7be46750894719/merged/etc/os-release
   NAME="Red Hat Enterprise Linux"
   VERSION="8 (Ootpa)"
   ID="rhel"
   ID_LIKE="fedora"
   ...

流程

1. 将容器网络接口设为 IP 地址 10.88.0.44：

   # podman run -d --ip=10.88.0.44 registry.access.redhat.com/rhel8/rsyslog
   efde5f0a8c723f70dd5cb5dc3d5039df3b962fae65575b08662e0d5b5f9fbe85

2. 检查是否正确设置了 IP 地址：

   # podman inspect efde5f0a8c723 | grep 10.88.0.44
   "IPAddress": "10.88.0.44",

流程

1. 在 myrsyslog 容器中执行 rpm -qa 命令来列出所有已安装的软件包：

   $ podman exec -it myrsyslog rpm -qa
   tzdata-2020d-1.el8.noarch
   python3-pip-wheel-9.0.3-18.el8.noarch
   redhat-release-8.3-1.0.el8.x86_64
   filesystem-3.8-3.el8.x86_64
   ...

2. 在 myrsyslog 容器中执行 /bin/bash 命令：

   $ podman exec -it myrsyslog /bin/bash

3. 安装 procps-ng 软件包，其包含一组系统工具（如 ps、top 和 uptime ，等等）：

   # yum install procps-ng

4. 检查容器：

   • 要列出系统上的每个进程：

     # ps -ef
     UID          PID    PPID  C STIME TTY          TIME CMD
     root           1       0  0 10:23 ?        00:00:01 /usr/sbin/rsyslogd -n
     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
     fuse-overlayfs   27G  7.1G   20G  27% /
     tmpfs            64M     0   64M   0% /dev
     tmpfs           269M  936K  268M   1% /etc/hosts
     shm              63M     0   63M   0% /dev/shm
     ...

   • 要显示系统信息：

     # uname -r
     4.18.0-240.10.1.el8_3.x86_64

   • 要以 MB 为单位显示空闲和使用的内存量：

     # free --mega
     total        used        free      shared  buff/cache   available
     Mem:       2818         615        1183          12         1020        1957
     Swap:      3124           0        3124

流程

1. 创建卷：

   $ podman volume create hostvolume

2. 显示卷的信息：

   $ 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 hostvolume --format {{.Mountpoint}}) 。

   请注意，如果您运行 sudo podman volume create hostvolume，则挂载点会更改为 /var/lib/containers/storage/volumes/hostvolume/_data。

3. 使用存储在 mntPoint 变量中的路径来在目录中创建一个文本文件：

   $ echo "Hello from host" >> $mntPoint/host.txt

4. 列出 mntPoint 变量所定义的目录中的所有文件：

   $ ls $mntPoint/
   host.txt

5. 运行名为 myubi1 的容器，并将主机上 hostvolume 卷名定义的目录映射到容器上的 /containervolume1 目录：

   $ podman run -it --name myubi1 -v hostvolume:/containervolume1 registry.access.redhat.com/ubi8/ubi /bin/bash

   请注意，如果您使用 mntPoint 变量定义的卷路径(-v $mntPoint:/containervolume1)，则在运行 podman volume prune 命令时数据可能会丢失，因为这会删除未使用的卷。始终使用 -v hostvolume_name:/containervolume_name。

6. 列出容器上共享卷中的文件：

   # ls /containervolume1
   host.txt

   您可以查看在主机上创建的 host.txt 文件。

7. 在 /containervolume1 目录中创建一个文本文件：

   # echo "Hello from container 1" >> /containervolume1/container1.txt

8. 使用 CTRL+p 和 CTRL+q 从容器分离。

9. 列出主机上共享卷中的文件，您应该看到两个文件：

   $ ls $mntPoint
   container1.rxt  host.txt

   此时，您要在容器和主机间共享文件。要在两个容器之间共享文件，请运行另一个名为 myubi2 的容器。

10. 运行名为 myubi2 的容器，并将主机上 hostvolume 卷名定义的目录映射到容器上的 /containervolume2 目录：

    $ podman run -it --name myubi2 -v hostvolume:/containervolume2 registry.access.redhat.com/ubi8/ubi /bin/bash

11. 列出容器上共享卷中的文件：

    # ls /containervolume2
    container1.txt host.txt

    您可以看到您在主机上创建的 host.txt 文件，以及您在 myubi1 容器中创建的 container1.txt 文件。

12. 在 /containervolume2 目录中创建一个文本文件：

    # echo "Hello from container 2" >> /containervolume2/container2.txt

13. 使用 CTRL+p 和 CTRL+q 从容器分离。

14. 列出主机上共享卷中的文件，您应该看到三个文件：

    $ ls $mntPoint
    container1.rxt  container2.txt host.txt

流程

1. 运行基于 registry.access.redhat.com/ubi8/ubi 镜像的 myubi 容器 ：

   $ podman run -dt --name=myubi registry.access.redhat.com/8/ubi

2. 可选：列出所有容器：

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

3. 附加到 myubi 容器：

   $ podman attach myubi

4. 创建名为 testfile 的文件：

   [root@a6a6d4896142 /]# echo "hello" > testfile

5. 使用 CTRL+p 和 CTRL+q 从容器分离。

6. 将 myubi 的文件系统导出为本地机器上的 myubi-container.tar ：

   $ podman export -o myubi.tar a6a6d4896142

7. 可选：列出当前目录的内容：

   $ ls -l
   -rw-r--r--. 1 user user 210885120 Apr  6 10:50 myubi-container.tar
   ...

8. 可选：创建一个 myubi-container 目录，提取 myubi-container.tar 存档中的所有文件。以树形格式列出 myubi-directory 的内容：

   $ mkdir myubi-container
   $ tar -xf myubi-container.tar -C myubi-container
   $ tree -L 1 myubi-container
   ├── bin -> usr/bin
   ├── boot
   ├── dev
   ├── etc
   ├── home
   ├── lib -> usr/lib
   ├── lib64 -> usr/lib64
   ├── lost+found
   ├── media
   ├── mnt
   ├── opt
   ├── proc
   ├── root
   ├── run
   ├── sbin -> usr/sbin
   ├── srv
   ├── sys
   ├── testfile
   ├── tmp
   ├── usr
   └── var
   
   20 directories, 1 file

   您可以看到 myubi-container.tar 包含容器文件系统。

9. 导入 myubi.tar ，并将其保存为文件系统镜像：

   $ podman import myubi.tar myubi-imported
   Getting image source signatures
   Copying blob 277cab30fe96 done
   Copying config c296689a17 done
   Writing manifest to image destination
   Storing signatures
   c296689a17da2f33bf9d16071911636d7ce4d63f329741db679c3f41537e7cbf

10. 列出所有镜像：

    $ podman images
    REPOSITORY                              TAG     IMAGE ID      CREATED         SIZE
    docker.io/library/myubi-imported       latest  c296689a17da  51 seconds ago  211 MB

11. 显示 testfile 文件的内容：

    $ podman run -it --name=myubi-imported docker.io/library/myubi-imported cat testfile
    hello

流程

1. 列出所有运行或停止的容器：

   $ podman ps -a
   CONTAINER ID IMAGE         COMMAND    CREATED    STATUS                PORTS NAMES     IS INFRA
   d65aecc325a4 ubi8/ubi      /bin/bash  3 secs ago Exited (0) 5 secs ago peaceful_hopper false
   74b1da000a11 rhel8/rsyslog rsyslog.sh 2 mins ago Up About a minute     musing_brown    false

2. 删除容器：

   • 要删除 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

流程

1. 拉取 registry.access.redhat.com/ubi8/ubi 容器镜像：

   # podman pull registry.access.redhat.com/ubi8/ubi

2. 将 registry.access.redhat.com/ubi8/ubi 镜像导出到 rhel.tar 归档中：

   # podman export $(podman create registry.access.redhat.com/ubi8/ubi) > rhel.tar

3. 创建 bundle/rootfs 目录：

   # mkdir -p bundle/rootfs

4. 将 rhel.tar 归档解压到 bundle/rootfs 目录中：

   # tar -C bundle/rootfs -xf rhel.tar

5. 为捆绑包创建一个名为 config.json 的新规范文件：

   # <runtime> spec -b bundle

   • -b 选项指定捆绑包目录。默认值为当前目录。

6. 可选：更改设置：

   # vi bundle/config.json

7. 为捆绑包创建一个名为 myubi 的容器实例：

   # <runtime> create -b bundle/ myubi

8. 启动 myubi 容器：

   # <runtime> start myubi

流程

1. 拉取 registry.access.redhat.com/ubi8/ubi 容器镜像：

   $ podman pull registry.access.redhat.com/ubi8/ubi

2. 使用 --runtime 选项更改容器运行时：

   $ podman run --name=myubi -dt --runtime=<runtime> ubi8
   e4654eb4df12ac031f1d0f2657dc4ae6ff8eb0085bf114623b66cc664072e69b

3. 可选。列出所有镜像：

   $ podman ps -a
   CONTAINER ID  IMAGE                                   COMMAND  CREATED        STATUS            PORTS   NAMES
   e4654eb4df12  registry.access.redhat.com/ubi8:latest  bash     4 seconds ago  Up 4 seconds ago          myubi

流程

1. 更改 /etc/containers/containers.conf 文件中的运行时：

   # vim /etc/containers/containers.conf
   [engine]
   runtime = "<runtime>"

2. 运行名为 myubi 的容器：

   # podman run --name=myubi -dt ubi8 bash
   Resolved "ubi8" as an alias (/etc/containers/registries.conf.d/001-rhel-shortnames.conf)
   Trying to pull registry.access.redhat.com/ubi8:latest…
   ...
   Storing signatures

流程

1. 在新目录中创建一个包含以下内容的 Containerfile ：

   FROM registry.access.redhat.com/ubi8/ubi-init
   RUN yum -y install httpd; yum 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" ]

   Containerfile 安装 httpd 软件包，启用 httpd 服务，以便在引导时启动，创建一个测试文件(index.html)，将 Web 服务器暴露给主机（端口 80），并在容器启动时启动 systemd init 服务(/sbin/init)。

2. 构建容器：

   # podman build --format=docker -t mysysd .

3. 可选：如果要使用 systemd 运行容器，且在您的系统上启用了 SELinux，您必须设置 container_manage_cgroup 布尔值变量：

   # setsebool -P container_manage_cgroup 1

4. 运行名为 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_start=80

5. 检查容器是否正在运行：

   # podman ps
   a282b0c2ad3d  localhost/mysysd:latest  /sbin/init  15 seconds ago  Up 14 seconds ago  0.0.0.0:80->80/tcp  mysysd_run

6. 测试 Web 服务器：

   # curl localhost/index.html
   Successful Web Server Test

流程

1. 拉取并构建 registry.access.redhat.com/ubi8/ubi-micro 镜像：

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

2. 挂载可正常工作的容器根文件系统：

   # micromount=$(buildah mount $microcontainer)

3. 将 httpd 服务安装到 micromount 目录中：

   # yum install \
       --installroot $micromount \
       --releasever 8 \
       --setopt install_weak_deps=false \
       --nodocs -y \
       httpd
   # yum clean all \
       --installroot $micromount

4. 在工作容器中卸载根文件系统：

   # buildah umount $microcontainer

5. 从工作容器创建 ubi-micro-httpd 镜像：

   # buildah commit $microcontainer ubi-micro-httpd

验证步骤

1. 显示有关 ubi-micro-httpd 镜像的详情：

   # podman images ubi-micro-httpd
   localhost/ubi-micro-httpd latest 7c557e7fbe9f  22 minutes ago  151 MB

流程

1. 拉取并运行 registry.access.redhat.com/ubi8/ubi 镜像：

   $ podman run -it --name myubi registry.access.redhat.com/ubi8/ubi

2. 将软件包添加到 myubi 容器。

   • 要添加 UBI 存储库中的软件包，请禁用除 UBI 存储库外的所有 yum 存储库。例如，要添加 bzip2 软件包：

     # yum install --disablerepo=* --enablerepo=ubi-8-appstream-rpms --enablerepo=ubi-8-baseos-rpms bzip2

   • 要添加不在 UBI 存储库中的软件包，请不要禁用任何存储库。例如，要添加 zsh 软件包：

     # yum install zsh

   • 要添加位于不同主机存储库中的软件包，请明确启用您需要的存储库。例如，要安装 codeready-builder-for-rhel-8-x86_64-rpms 存储库中的 python38-devel 软件包：

     # yum install --enablerepo=codeready-builder-for-rhel-8-x86_64-rpms python38-devel

验证步骤

1. 列出容器内所有启用的存储库：

   # yum repolist

2. 确保列出了所需的存储库。

3. 列出所有安装的软件包：

   # rpm -qa

4. 确保列出了所需的软件包。

流程

1. 拉取并运行 registry.access.redhat.com/ubi8/ubi-minimal 镜像：

   $ podman run -it --name myubimin registry.access.redhat.com/ubi8/ubi-minimal

2. 将软件包添加到 myubimin 容器：

   • 要添加 UBI 存储库中的软件包，请不要禁用任何存储库。例如，要添加 bzip2 软件包：

     # microdnf install bzip2

   • 要添加位于不同主机存储库中的软件包，请明确启用您需要的存储库。例如，要安装 codeready-builder-for-rhel-8-x86_64-rpms 存储库中的 python38-devel 软件包：

     # microdnf install --enablerepo=codeready-builder-for-rhel-8-x86_64-rpms python38-devel

验证步骤

1. 列出容器内所有启用的存储库：

   # microdnf repolist

2. 确保列出了所需的存储库。

3. 列出所有安装的软件包：

   # rpm -qa

4. 确保列出了所需的软件包。

验证步骤

1. 列出所有启用的存储库：

   • 要列出基于 UBI 标准或 UBI init 镜像的容器中所有启用的存储库：

     #  yum repolist

   • 要列出基于 UBI 最小容器的容器中所有启用的存储库：

     # microdnf repolist

2. 确保列出了所需的存储库。

3. 列出所有安装的软件包：

   # rpm -qa

4. 确保列出了所需的软件包。

流程

1. 创建 Containerfile ：

   FROM registry.access.redhat.com/ubi8/ubi
   USER root
   LABEL maintainer="John Doe"
   # Update image
   RUN yum update --disablerepo=* --enablerepo=ubi-8-appstream-rpms --enablerepo=ubi-8-baseos-rpms -y && rm -rf /var/cache/yum
   RUN yum install --disablerepo=* --enablerepo=ubi-8-appstream-rpms --enablerepo=ubi-8-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"]

2. 构建容器镜像：

   # buildah bud -t johndoe/webserver .
   STEP 1: FROM registry.access.redhat.com/ubi8/ubi:latest
   STEP 2: USER root
   STEP 3: LABEL maintainer="John Doe"
   STEP 4: RUN yum update --disablerepo=* --enablerepo=ubi-8-appstream-rpms --enablerepo=ubi-8-baseos-rpms -y
   ...
   Writing manifest to image destination
   Storing signatures
   --> f9874f27050
   f9874f270500c255b950e751e53d37c6f8f6dba13425d42f30c2a8ef26b769f2

验证步骤

1. 运行 web 服务器：

   # podman run -d --name=myweb -p 80:80 johndoe/webserver
   bbe98c71d18720d966e4567949888dc4fb86eec7d304e785d5177168a5965f64

2. 测试 Web 服务器：

   # curl http://localhost/index.html
   The Web Server is Running

流程

1. 使用 skopeo copy 命令将源容器镜像复制到本地目录中：

   $ skopeo copy \
   docker://registry.access.redhat.com/ubi8:8.1-397-source \
   dir:$HOME/TEST
   ...
   Copying blob 477bc8106765 done
   Copying blob c438818481d3 done
   ...
   Writing manifest to image destination
   Storing signatures

2. 使用 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:1ae73d938ab9f11718d0f6a4148eb07d38ac1c0a70b1d03e751de8bf3c2c87fa",
           "sha256:9fe966885cb8712c47efe5ecc2eaa0797a0d5ffb8b119c4bd4b400cc9e255421",
           "sha256:61b2527a4b836a4efbb82dfd449c0556c0f769570a6c02e112f88f8bbcd90166",
           ...
           "sha256:cc56c782b513e2bdd2cc2af77b69e13df4ab624ddb856c4d086206b46b9b9e5f",
           "sha256:dcf9396fdada4e6c1ce667b306b7f08a83c9e6b39d0955c481b8ea5b2a465b32",
           "sha256:feb6d2ae252402ea6a6fca8a158a7d32c7e4572db0e6e5a5eab15d4e0777951e"
       ],
       "Env": null
   }

3. 解包所有内容：

   $ cd $HOME/TEST
   $ for f in $(ls); do tar xvf $f; done

4. 检查结果：

   $ find blobs/ rpm_dir/
   blobs/
   blobs/sha256
   blobs/sha256/10914f1fff060ce31388f5ab963871870535aaaa551629f5ad182384d60fdf82
   rpm_dir/
   rpm_dir/gzip-1.9-4.el8.src.rpm

   如果结果正确，则镜像可以使用。

流程

1. 生成一个 GPG 密钥：

   # gpg --full-gen-key

2. 导出公钥：

   # gpg --output <path>/key.gpg --armor --export <username@domain.com>

3. 使用 Containerfile 在当前目录中构建容器镜像：

   $ podman build -t <registry>/<namespace>/<image>

   将 <registry>, <namespace> 和 <image> 替换为容器镜像标识符。如需了解更多详细信息，请参阅容器 registry。

4. 为镜像签名并将其推送到注册中心：

    $  podman push \
       --sign-by <username@domain.com> \
       <registry>/<namespace>/<image>

   注意

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

5. 可选：显示新镜像签名：

   # (cd /var/lib/containers/sigstore/; find . -type f)
   ./<image>@sha256=<digest>/signature-1

6. 将本地签名复制到备用 web 服务器：

   # rsync -a /var/lib/containers/sigstore <user@registry-lookaside.example.com>:/registry-lookaside/webroot/sigstore

流程

1. 更新 <registry> 的信任范围：

   $ podman image trust set -f <path>/key.gpg <registry>/<namespace>

2. 可选：通过显示 /etc/containers/policy.json 文件来验证信任策略配置：

   $ cat /etc/containers/policy.json
   {
     ...
     "transports": {
       "docker": {
         "<registry>/<namespace>": [
           {
             "type": "signedBy",
             "keyType": "GPGKeys",
             "keyPath": "<path>/key.gpg"
           }
         ]
       }
     }
   }

   注意

   通常，/etc/containers.policy.json 文件在使用相同密钥的机构层面进行配置。例如，用于公共注册中心的 <registry>/<namespace>，或单个公司专用中心的 registry 。

3. 拉取镜像：

   # podman pull <registry>/<namespace>/<image>
   ...
   Storing signatures
   e7d92cdc71feacf90708cb59182d0df1b911f8ae022d29e8e95d75ca6a99776a

   podman pull 命令会强制签名存在，而无需额外的选项。

流程

1. 生成 sigstore 公钥/私钥对：

   $ skopeo generate-sigstore-key --output-prefix myKey

   • 生成公钥和私钥 myKey.pub 和 myKey.private。

     注意

     skopeo generate-sigstore-key 命令可从 RHEL 8.8 中提供。否则，您必须使用上游 Cosign 项目来生成公钥/私钥对：

     • 安装 cosign 工具：

       $ git clone -b v2.0.0 https://github.com/sigstore/cosign
       $ cd cosign
       $ make ./cosign

     • 生成公钥/私钥对：

       $ ./cosign generate-key-pair
       ...
       Private key written to cosign.key
       Public key written to cosign.pub

2. 在 /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 文件中的注册中心配置部分。所有 YAML 文件都可读，文件名可以是任意的。单个范围(default-docker、注册中心或命名空间)只能存在于 /etc/containers/registries.d 目录中的一个文件中。

3. 使用 Containerfile 在当前目录中构建容器镜像：

   $ podman build -t <registry>/<namespace>/<image>

4. 为镜像签名并将其推送到注册中心：

   $ 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 私钥将 sigstore 签名添加到 <registry>/<namespace>/<image> 镜像。镜像和 sigstore 签名被上传到远程注册中心。

流程

1. 在 /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 文件中的注册中心配置部分。所有 YAML 文件都可读，文件名可以是任意的。单个范围(default-docker、注册中心或命名空间)只能存在于 /etc/containers/registries.d 目录中的一个文件中。

2. 编辑 /etc/containers/policy.json 文件以强制 sigstore 签名存在：

   ...
   "transports": {
               "docker": {
                   "<registry>/<namespace>": [
                       {
                           "type": "sigstoreSigned",
                           "keyPath": "/some/path/to/cosign.pub"
                       }
                   ]
               }
           }
   ...

   通过修改 /etc/containers/policy.json 配置文件，您可以更改信任策略配置。Podman、Buildah 和 Skopeo 强制容器镜像签名的存在。

3. 拉取镜像：

   $ podman pull <registry>/<namespace>/<image>

流程

1. 在 /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 或 repository 配置部分。单个范围 (default-docker、注册中心或命名空间) 只能存在于 /etc/containers/registries.d 目录中的一个文件中。您还可以在 /etc/containers/registries.d/default.yaml 文件中编辑系统范围的 registry 配置。请注意，所有 YAML 文件都是可读的，文件名是任意的。

2. 创建 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 签名所需的选项。

3. 为镜像签名并将其推送到注册中心：

   $ podman push --sign-by-sigstore=file.yml <registry>/<namespace>/<image>

   • 您还可以使用带有类似 --sign-by-sigstore 选项的 skopeo copy 命令来为现有镜像签名，同时将它们在多个容器注册中心之间移动。

流程

1. 在 /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 或 repository 配置部分。单个范围 (default-docker、注册中心或命名空间) 只能存在于 /etc/containers/registries.d 目录中的一个文件中。您还可以在 /etc/containers/registries.d/default.yaml 文件中编辑系统范围的 registry 配置。请注意，所有 YAML 文件都是可读的，文件名是任意的。

2. 在 /etc/containers/policy.json 文件中添加 fulcio 部分和 rekorPublicKeyPath 或 rekorPublicKeyData 字段：

   {
       ...
       "transports": {
   	"docker": {
           "<registry>/<namespace>": [
               {
               "type": "sigstoreSigned",
               "fulcio": {
                   "caPath": "/path/to/local/CA/file",
                   "oidcIssuer": "https://expected.OIDC.issuer/",
                   "subjectEmail", "expected-signing-user@example.com",
               },
               "rekorPublicKeyPath": "/path/to/local/public/key/file",
               }
           ]
       ...
   	}
     }
     ...
   }

   • fulcio 部分提供签名是基于 Fulcio 发布的证书。
   • 您必须指定 caPath 和 caData 字段中的一个，其中包含 Fulcio 实例的 CA 证书。
   • oidcIssuer 和 subjectEmail 都是必需的，准确指定预期的身份提供商，以及获取 Fulcio 证书的用户身份。
   • 您必须指定 rekorPublicKeyPath 和 rekorPublicKeyData 字段之一。

3. 拉取镜像：

   $ podman pull <registry>/<namespace>/<image>

流程

1. 生成 sigstore 公钥/私钥对：

   $ skopeo generate-sigstore-key --output-prefix myKey

   • 生成公钥和私钥 myKey.pub 和 myKey.private。

2. 在 /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 或 repository 配置部分。单个范围 (default-docker、注册中心或命名空间) 只能存在于 /etc/containers/registries.d 目录中的一个文件中。您还可以在 /etc/containers/registries.d/default.yaml 文件中编辑系统范围的 registry 配置。请注意，所有 YAML 文件都是可读的，文件名是任意的。

3. 使用 Containerfile 在当前目录中构建容器镜像：

   $ podman build -t <registry>/<namespace>/<image>

4. 创建 file.yml 文件：

   privateKeyFile: "/home/user/sigstore/myKey.private"
   privateKeyPassphraseFile: "/mnt/user/sigstore-myKey-passphrase"
   rekorURL: "https://<your-rekor-server>"

   • file.yml 是 sigstore 签名参数 YAML 文件，其用于存储创建 sigstore 签名所需的选项。

5. 为镜像签名并将其推送到注册中心：

   $ podman push --sign-by-sigstore=file.yml <registry>/<namespace>/<image>

   • 您还可以使用带有类似 --sign-by-sigstore 选项的 skopeo copy 命令来为现有镜像签名，同时将它们在多个容器注册中心之间移动。

流程

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

2. 删除 mynet 网络：

   # podman network rm mynet
   mynet

流程

1. 创建空 pod:

   $ podman pod create --name mypod
   223df6b390b4ea87a090a4b5207f7b9b003187a6960bd37631ae9bc12c433aff
   The pod is in the initial state Created.

   pod 处于 Created 的初始状态。

2. 可选：列出所有 pod：

   $ podman pod ps
   POD ID         NAME    STATUS    CREATED                  # OF CONTAINERS   INFRA ID
   223df6b390b4   mypod   Created   Less than a second ago   1                 3afdcd93de3e

   请注意，pod 有一个容器。

3. 可选：列出与其关联的所有 pod 和容器：

   $ podman ps -a --pod
   CONTAINER ID  IMAGE                 COMMAND  CREATED                 STATUS   PORTS  NAMES               POD
   3afdcd93de3e  registry.access.redhat.com/ubi8/pause            Less than a second ago  Created         223df6b390b4-infra  223df6b390b4

   您可以看到 podman ps 命令中的 pod ID 与 podman pod ps 命令中的 pod ID 匹配。默认 infra 容器是基于 registry.access.redhat.com/ubi8/pause 镜像。

4. 在名为 mypod 的现有 pod 中运行名为 myubi 的容器：

   $ podman run -dt --name myubi --pod mypod registry.access.redhat.com/ubi8/ubi /bin/bash
   5df5c48fea87860cf75822ceab8370548b04c78be9fc156570949013863ccf71

5. 可选：列出所有 pod：

   $ podman pod ps
   POD ID         NAME    STATUS    CREATED                  # OF CONTAINERS   INFRA ID
   223df6b390b4   mypod   Running   Less than a second ago   2                 3afdcd93de3e

   您可以看到 pod 有两个容器。

6. 可选：列出与其关联的所有 pod 和容器：

   $ podman ps -a --pod
   CONTAINER ID  IMAGE                                       COMMAND    CREATED                 STATUS                     PORTS  NAMES               POD
   5df5c48fea87  registry.access.redhat.com/ubi8/ubi:latest  /bin/bash  Less than a second ago  Up Less than a second ago         myubi               223df6b390b4
   3afdcd93de3e  registry.access.redhat.com/ubi8/pause                                   Less than a second ago  Up Less than a second ago         223df6b390b4-infra  223df6b390b4

流程

1. 停止 pod mypod:

   $ podman pod stop mypod

2. 可选：列出与其关联的所有 pod 和容器：

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

   您可以看到 pod mypod 和容器 myubi 都处于"Exited"状态。

流程

1. 删除 pod mypod，请输入：

   $ podman pod rm mypod
   223df6b390b4ea87a090a4b5207f7b9b003187a6960bd37631ae9bc12c433aff

   请注意，删除 pod 会自动移除其中的所有容器。

2. 可选：检查是否所有容器和 pod 都已删除：

   $ podman ps
   $ podman pod ps

流程

1. 显示容器的 IP 地址：

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

2. 显示容器连接到的所有网络：

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

3. 显示端口映射：

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

流程

1. 启动名为 web-container 的容器：

   # podman run -dt --name=web-container docker.io/library/httpd

2. 列出所有容器：

   # 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

3. 检查容器并显示 IP 地址：

   # podman inspect --format='{{.NetworkSettings.IPAddress}}' web-container
   
   10.88.0.2

4. 运行 myubi 容器并验证 web 服务器是否正在运行：

   # podman run -it --name=myubi ubi8/ubi curl 10.88.0.2:80
   
   <html><body><h1>It works!</h1></body></html>

流程

1. 验证网桥是否已配置：

   # podman network inspect podman | grep bridge
   
       "bridge": "cni-podman0",
       "type": "bridge"

2. 显示主机网络配置：

   # ip addr show cni-podman0
   
   6: cni-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 cni-podman0
          valid_lft forever preferred_lft forever
       inet6 fe80::60af:a1ff:fe0a:ca2e/64 scope link
          valid_lft forever preferred_lft forever

   您可以看到 web-container 的 IP 地址为 cni-podman0 网络，网络则桥接到主机。

3. 检查 web-container 并显示其 IP 地址：

   # podman inspect --format='{{.NetworkSettings.IPAddress}}' web-container
   
   10.88.0.2

4. 直接从主机访问 web-container:

   $ curl 10.88.0.2:80
   
   <html><body><h1>It works!</h1></body></html>

流程

1. 运行未发布的容器：

   # podman run -dt --name=web1 ubi8/httpd-24

2. 运行自动发布的容器：

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

3. 运行手动发布的容器并发布容器端口 80：

   # podman run -dt --name=web3 -p 9090:80 ubi8/httpd-24

4. 列出所有容器：

   # podman ps
   
   CONTAINER ID  IMAGE                                            COMMAND               CREATED         STATUS             PORTS                                             NAMES
   f12fa79b8b39  registry.access.redhat.com/ubi8/httpd-24:latest  /usr/bin/run-http...  23 seconds ago  Up 24 seconds ago                                                    web1
   9024d9e815e2  registry.access.redhat.com/ubi8/httpd-24:latest  /usr/bin/run-http...  13 seconds ago  Up 13 seconds ago  0.0.0.0:43595->8080/tcp, 0.0.0.0:42423->8443/tcp  web2
   03bc2a019f1b  registry.access.redhat.com/ubi8/httpd-24:latest  /usr/bin/run-http...  2 seconds ago   Up 2 seconds ago   0.0.0.0:9090->80/tcp                              web3

   您可以看到：

   • 容器 web1 没有公布的端口，只能通过容器网络或网桥访问。

   • 容器 web2 已自动映射端口 43595 和 42423，以分别发布应用端口 8080 和 8443。

     注意

     自动端口映射是可能的，因为 registry.access.redhat.com/8/httpd-24 镜像在 Containerfile 中有 EXPOSE 8080 和 EXPOSE 8443 命令。

   • 容器 web3 有一个手动发布的端口。主机端口 9090 映射到容器端口 80。

5. 显示 web1 和 web3 容器的 IP 地址：

   # podman inspect --format='{{.NetworkSettings.IPAddress}}' web1
   # podman inspect --format='{{.NetworkSettings.IPAddress}}' web3

6. 使用 <IP>:<port> 表示法访问 web1 容器：

   # curl 10.88.0.14:8080
   ...
   <title>Test Page for the HTTP Server on Red Hat Enterprise Linux</title>
   ...

7. 使用 localhost:<port> 表示法访问 web2 容器：

   # curl localhost:43595
   ...
   <title>Test Page for the HTTP Server on Red Hat Enterprise Linux</title>
   ...

8. 使用 <IP>:<port> 表示法访问 web3 容器：

   # curl 10.88.0.14:9090
   ...
   <title>Test Page for the HTTP Server on Red Hat Enterprise Linux</title>
   ...

流程

1. 运行附加到 mynet 网络的 接收器 容器：

   # podman run -d --net mynet --name receiver ubi8 sleep 3000

2. 运行 发送者 容器并通过其名称访问 接收器（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 退出。

流程

1. 创建名为 web-pod 的 pod：

   $ podman pod create --name=web-pod

2. 在 pod 中运行名为 web-container 的 web 容器：

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

3. 列出与其关联的所有 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  4e61a300c194  web-pod

4. 根据 docker.io/library/fedora 镜像在 web-pod 中运行容器：

   $ podman container run -it --rm --pod web-pod docker.io/library/fedora curl localhost
   
   <html><body><h1>It works!</h1></body></html>

   您可以看到容器可以访问 web-container。

流程

1. 创建名为 web-pod 的 pod：

   # podman pod create --name=web-pod-publish -p 80:80

2. 列出所有 pod:

   # podman pod ls
   
   POD ID        NAME         STATUS   CREATED        INFRA ID      # OF CONTAINERS
   26fe5de43ab3  publish-pod  Created  5 seconds ago  7de09076d2b3  1

3. 在 web-pod 中运行名为 web-container 的 web 容器：

   # podman container run -d --pod web-pod-publish --name=web-container docker.io/library/httpd

4. 列出容器

   # 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

5. 验证可以访问 web-container:

   $ curl localhost:80
   
   <html><body><h1>It works!</h1></body></html>

流程

1. 创建名为 pod-net 的网络：

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

2. 创建 pod web-pod ：

   # podman pod create --net pod-net --name web-pod

3. 在 web-pod 中运行一个名为 web-container 的容器：

   # podman run -d --pod webt-pod --name=web-container docker.io/library/httpd

4. 可选：显示容器与之关联的 pod：

   # podman ps -p
   
   CONTAINER ID  IMAGE                           COMMAND           CREATED        STATUS            PORTS       NAMES               POD ID        PODNAME
   b7d6871d018c   registry.access.redhat.com/ubi8/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 ago              web-container    a8e7360326ba  web-pod

流程

1. 手动运行 dhcp 插件：

   # /usr/libexec/cni/dhcp daemon &
   [1] 4966

2. 检查 dhcp 插件是否正在运行：

   # ps -a | grep dhcp
   4966 pts/1    00:00:00 dhcp

3. 运行 alpine 容器：

   # podman run -it --rm --network=example alpine ip addr show enp1s0
   Resolved "alpine" as an alias (/etc/containers/registries.conf.d/000-shortnames.conf)
   Trying to pull docker.io/library/alpine:latest...
   ...
   Storing signatures
   
   2: eth0@eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP
       link/ether f6:dd:1b:a7:9b:92 brd ff:ff:ff:ff:ff:ff
       inet 192.168.1.22/24 brd 192.168.1.255 scope global eth0
       ...

   在本例中：

   • --network=example 选项指定要连接的名为 example 的网络。
   • alpine 容器内的 ip addr show enp1s0 命令检查网络接口 enp1s0 的 IP 地址。
   • 主机网络是 192.168.1.0/24
   • eth0 接口为 alpine 容器租期 IP 地址 192.168.1.122。

流程

1. 创建套接字单元文件：

   # cat /usr/lib/systemd/system/io.podman.dhcp.socket
   [Unit]
   Description=DHCP Client for CNI
   
   [Socket]
   ListenStream=%t/cni/dhcp.sock
   SocketMode=0600
   
   [Install]
   WantedBy=sockets.target

2. 创建服务单元文件：

   # cat /usr/lib/systemd/system/io.podman.dhcp.service
   [Unit]
   Description=DHCP Client CNI Service
   Requires=io.podman.dhcp.socket
   After=io.podman.dhcp.socket
   
   [Service]
   Type=simple
   ExecStart=/usr/libexec/cni/dhcp daemon
   TimeoutStopSec=30
   KillMode=process
   
   
   [Install]
   WantedBy=multi-user.target
   Also=io.podman.dhcp.socket

3. 立即启动该服务：

   # systemctl --now enable io.podman.dhcp.socket

流程

1. 如果 /etc/containers/containers.conf 文件不存在，请将 /usr/share/containers/containers.conf 文件复制到 /etc/containers/ 目录中：

   # cp /usr/share/containers/containers.conf /etc/containers/

2. 编辑 /etc/containers/containers.conf 文件，并在 [network] 部分中添加以下内容：

   network_backend="netavark"

3. 如果您有任何容器或 pod，请将存储重置回初始状态：

   # podman system reset

4. 重启系统：

   # reboot

流程

1. 如果 /etc/containers/containers.conf 文件不存在，请将 /usr/share/containers/containers.conf 文件复制到 /etc/containers/ 目录中：

   # cp /usr/share/containers/containers.conf /etc/containers/

2. 编辑 /etc/containers/containers.conf 文件，并在 [network] 部分中添加以下内容：

   network_backend="cni"

3. 如果您有任何容器或 pod，请将存储重置回初始状态：

   # podman system reset

4. 重启系统：

   # reboot

流程

1. 列出与其关联的所有 pod 和容器：

   $ podman ps -a --pod
   CONTAINER ID  IMAGE                                       COMMAND    CREATED                 STATUS                     PORTS  NAMES               POD
   5df5c48fea87  registry.access.redhat.com/ubi8/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

2. 使用 pod 名称或 ID 来生成 Kubernetes YAML 文件：

   $ podman generate kube mypod > mypod.yaml

   请注意，podman generate 命令不反映任何可能附加到容器的逻辑卷管理器(LVM)逻辑卷或物理卷。

3. 显示 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: mypod
   spec:
     containers:
     - command:
           - /bin/bash
           env:
           - name: PATH
                 value: /usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
           - name: TERM
                 value: xterm
           - name: HOSTNAME
           - name: container
                 value: oci
           image: registry.access.redhat.com/ubi8/ubi:latest
           name: myubi
           resources: {}
           securityContext:
                 allowPrivilegeEscalation: true
                 capabilities: {}
                 privileged: false
                 readOnlyRootFilesystem: false
           tty: true
           workingDir: /
   status: {}

流程

1. 从 mypod.yaml 文件创建 pod 和容器：

   $ podman play kube mypod.yaml
   Pod:
   b8c5b99ba846ccff76c3ef257e5761c2d8a5ca4d7ffa3880531aec79c0dacb22
   Container:
   848179395ebd33dd91d14ffbde7ae273158d9695a081468f487af4e356888ece

2. 列出所有 pod:

   $ podman pod ps
   POD ID         NAME    STATUS    CREATED          # OF CONTAINERS   INFRA ID
   b8c5b99ba846   mypod   Running   19 seconds ago   2                 aa4220eaf4bb

3. 列出与其关联的所有 pod 和容器：

   $ podman ps -a --pod
   CONTAINER ID  IMAGE                                       COMMAND    CREATED             STATUS                 PORTS  NAMES               POD
   848179395ebd  registry.access.redhat.com/ubi8/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  b8c5b99ba846

   podman ps 命令中的 pod ID 与 podman pod ps 命令中的 pod ID 相匹配。

流程

1. 显示 mariadb-conf/Containerfile 文件：

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

2. 显示 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/conf.d/

3. 使用 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 /etc/mysql/my.cnf
   STEP 3: COMMIT mariadb-conf
   --> ffae584aa6e
   Successfully tagged localhost/mariadb-conf:latest
   ffae584aa6e733ee1cdf89c053337502e1089d1620ff05680b6818a96eec3c17

4. 可选：列出所有镜像：

   $ podman images
   LIST IMAGES
   REPOSITORY                                                       TAG         IMAGE ID      CREATED             SIZE
   localhost/mariadb-conf                                           latest      b66fa0fa0ef2  57 seconds ago      416 MB

5. 创建名为 wordpresspod 的 pod，并配置容器和主机系统之间的端口映射：

   $ podman pod create --name wordpresspod -p 8080:80

6. 在 wordpresspod pod 中创建 mydb 容器：

   $ podman run --detach --pod wordpresspod \
       -e MYSQL_ROOT_PASSWORD=1234 \
       -e MYSQL_DATABASE=mywpdb \
       -e MYSQL_USER=mywpuser \
       -e MYSQL_PASSWORD=1234 \
       --name mydb localhost/mariadb-conf

7. 在 wordpresspod pod 中创建 myweb 容器：

   $ podman run --detach --pod wordpresspod \
       -e WORDPRESS_DB_HOST=127.0.0.1 \
       -e WORDPRESS_DB_NAME=mywpdb \
       -e WORDPRESS_DB_USER=mywpuser \
       -e WORDPRESS_DB_PASSWORD=1234 \
       --name myweb docker.io/wordpress

8. 可选。列出与其关联的所有 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 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

流程

1. 列出与其关联的所有 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 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

2. 使用 pod 名称或 ID 来生成 Kubernetes YAML 文件：

   $ podman generate kube wordpresspod >> wordpresspod.yaml

1. 存在一个名称与 YAML 文件中所用镜像相同的目录
2. 该目录包含一个 Containerfile

流程

1. 使用 wordpress.yaml 文件创建 wordpress pod：

   $ 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

   podman play kube 命令：

   • 根据 docker.io/library/mariadb 镜像，自动构建 localhost/mariadb-conf:latest 镜像。
   • 拉取 docker.io/library/wordpress:latest 镜像。
   • 创建名为 wordpresspod 的 pod，它有两个容器，名为 wordpresspod-mydb 和 wordpresspod-myweb。

2. 列出所有容器和 pod：

   $ podman ps --pod -a
   CONTAINER ID  IMAGE                               COMMAND               CREATED        STATUS                    PORTS                 NAMES               POD ID        PODNAME
   a1dbf7b5606c  k8s.gcr.io/pause:3.5                                      3 minutes ago  Up 2 minutes ago          0.0.0.0:8080->80/tcp  3e391d091d19-infra  3e391d091d19  wordpresspod
   6c59ebe96846  localhost/mariadb-conf:latest       mariadbd              2 minutes ago  Exited (1) 2 minutes ago  0.0.0.0:8080->80/tcp  wordpresspod-mydb   3e391d091d19  wordpresspod
   29717878452f  docker.io/library/wordpress:latest  apache2-foregroun...  2 minutes ago  Up 2 minutes ago          0.0.0.0:8080->80/tcp  wordpresspod-myweb  3e391d091d19  wordpresspod

流程

1. 创建 mysleep.container 单元文件：

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

   在 [Container] 部分中，您必须指定：

   • Image - 您要运行的容器镜像

   • Exec - 要在容器内运行的命令

     这可让您使用 systemd 单元文件中指定的所有其他字段。

2. 根据 mysleep.container 文件创建 mysleep.service ：

   $ systemctl --user daemon-reload

3. 可选：检查 mysleep.service 的状态：

   $ systemctl --user status mysleep.service
   ○ mysleep.service - The sleep container
   	 Loaded: loaded (/home/username/.config/containers/systemd/mysleep.container; generated)
   	 Active: inactive (dead)

4. 启动 mysleep.service ：

   $ systemctl --user start mysleep.service

验证

1. 检查 mysleep.service 的状态：

   $ systemctl --user status mysleep.service
   ● mysleep.service - The sleep container
   	 Loaded: loaded (/home/username/.config/containers/systemd/mysleep.container; generated)
   	 Active: active (running) since Thu 2023-02-09 18:07:23 EST; 2s ago
      Main PID: 265651 (conmon)
         Tasks: 3 (limit: 76815)
   	 Memory: 1.6M
      	 CPU: 94ms
   	 CGroup: ...

2. 列出所有容器：

   $ podman ps -a
   CONTAINER ID  IMAGE                            COMMAND               CREATED            STATUS                          PORTS   NAMES
   421c8293fc1b  registry.access.redhat.com/ubi8-minimal:latest               sleep 1000  30 seconds ago   Up 10 seconds ago systemd-mysleep

   请注意，创建的容器的名称由以下元素组成：

   • systemd- 前缀

   • systemd 单元的名称，即 systemd-mysleep

     这种命名有助于将常见容器与在 systemd 单元中运行的容器区分开来。它还有助于确定容器运行在哪个单元中。如果要更改容器的名称，请使用 [Container] 部分中的 ContainerName 字段。

流程

1. 重新载入 systemd 管理器配置：

   # systemctl --user daemon-reload

2. 启用服务 container.service ，并在引导时启动它：

   # systemctl --user enable container.service

3. 立即启动该服务：

   # systemctl --user start container.service

4. 检查服务的状态：

   $ 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: 80602 ExecStart=/usr/bin/podman run --conmon-pidfile //run/user/1000/container.service-pid --cidfile //run/user/1000/container.service-cid -d ubi8-minimal:>
     Process: 80601 ExecStartPre=/usr/bin/rm -f //run/user/1000/container.service-pid //run/user/1000/container.service-cid (code=exited, status=0/SUCCESS)
    Main PID: 80617 (conmon)
      CGroup: /user.slice/user-1000.slice/user@1000.service/container.service
              ├─ 2870 /usr/bin/podman
              ├─80612 /usr/bin/slirp4netns --disable-host-loopback --mtu 65520 --enable-sandbox --enable-seccomp -c -e 3 -r 4 --netns-type=path /run/user/1000/netns/cni->
              ├─80614 /usr/bin/fuse-overlayfs -o lowerdir=/home/user/.local/share/containers/storage/overlay/l/YJSPGXM2OCDZPLMLXJOW3NRF6Q:/home/user/.local/share/contain>
              ├─80617 /usr/bin/conmon --api-version 1 -c cbc75d6031508dfd3d78a74a03e4ace1732b51223e72a2ce4aa3bfe10a78e4fa -u cbc75d6031508dfd3d78a74a03e4ace1732b51223e72>
              └─cbc75d6031508dfd3d78a74a03e4ace1732b51223e72a2ce4aa3bfe10a78e4fa
                └─80626 /usr/bin/coreutils --coreutils-prog-shebang=sleep /usr/bin/sleep 1d

   您可以使用 systemctl is-enabled container.service 命令检查服务是否已启用。

流程

1. 创建容器（如 myubi）：

   $ podman create --name myubi registry.access.redhat.com/ubi8:latest sleep infinity
   0280afe98bb75a5c5e713b28de4b7c5cb49f156f1cce4a208f13fee2f75cb453

2. 使用容器名称或 ID 生成 systemd 单元文件，并将其定向到 ~/.config/systemd/user/container-myubi.service 文件中：

   $ podman generate systemd --name myubi > ~/.config/systemd/user/container-myubi.service

流程

1. 拉取您要在系统中使用的镜像。例如，要拉取 httpd-24 镜像：

   # podman pull registry.access.redhat.com/ubi8/httpd-24

2. 可选：列出系统上所有可用的镜像：

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

3. 创建 httpd 容器：

   # podman create --name httpd -p 8080:8080 registry.access.redhat.com/ubi8/httpd-24
   cdb9f981cf143021b1679599d860026b13a77187f75e46cc0eac85293710a4b1

4. 可选：验证容器是否已创建：

   # podman ps -a
   CONTAINER ID  IMAGE                                            COMMAND               CREATED        STATUS      PORTS                   NAMES
   cdb9f981cf14  registry.access.redhat.com/ubi8/httpd-24:latest  /usr/bin/run-http...  5 minutes ago  Created     0.0.0.0:8080->8080/tcp  httpd

5. 为 httpd 容器生成一个 systemd 单元文件：

   # podman generate systemd --new --files --name httpd
   /root/container-httpd.service

6. 显示生成的 container-httpd.service systemd 单元文件的内容：

   # cat /root/container-httpd.service
   # container-httpd.service
   # autogenerated by Podman 3.3.1
   # Wed Sep  8 20:41:44 CEST 2021
   
   [Unit]
   Description=Podman container-httpd.service
   Documentation=man:podman-generate-systemd(1)
   Wants=network-online.target
   After=network-online.target
   RequiresMountsFor=%t/containers
   
   [Service]
   Environment=PODMAN_SYSTEMD_UNIT=%n
   Restart=on-failure
   TimeoutStopSec=70
   ExecStartPre=/bin/rm -f %t/%n.ctr-id
   ExecStart=/usr/bin/podman run --cidfile=%t/%n.ctr-id --sdnotify=conmon --cgroups=no-conmon --rm -d --replace --name httpd -p 8080:8080 registry.access.redhat.com/ubi8/httpd-24
   ExecStop=/usr/bin/podman stop --ignore --cidfile=%t/%n.ctr-id
   ExecStopPost=/usr/bin/podman rm -f --ignore --cidfile=%t/%n.ctr-id
   Type=notify
   NotifyAccess=all
   
   [Install]
   WantedBy=multi-user.target default.target

流程

1. 创建一个空 pod，如 systemd-pod:

   $ podman pod create --name systemd-pod
   11d4646ba41b1fffa51c108cbdf97cfab3213f7bd9b3e1ca52fe81b90fed5577

2. 可选：列出所有 pod：

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

3. 在空 pod 中创建两个容器。例如，要在 systemd-pod 中创建 container0 和 container1 ：

   $ podman create --pod systemd-pod --name container0 registry.access.redhat.com/ubi8 top
   $ podman create --pod systemd-pod --name container1 registry.access.redhat.com/ubi8 top

4. 可选：列出与其关联的所有 pod 和容器：

   $ podman ps -a --pod
   CONTAINER ID  IMAGE                                   COMMAND  CREATED        STATUS         PORTS   NAMES               POD ID        PODNAME
   24666f47d9b2  registry.access.redhat.com/ubi8:latest  top      3 minutes ago  Created                container0          3130f724e229  systemd-pod
   56eb1bf0cdfe  k8s.gcr.io/pause:3.2                             4 minutes ago  Created                3130f724e229-infra  3130f724e229  systemd-pod
   62118d170e43  registry.access.redhat.com/ubi8:latest  top      3 seconds ago  Created                container1          3130f724e229  systemd-pod

5. 为新 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。

6. 显示 pod-systemd-pod.service 单元文件：

   $ cat pod-systemd-pod.service
   # pod-systemd-pod.service
   # autogenerated by Podman 3.3.1
   # Wed Sep  8 20:49:17 CEST 2021
   
   [Unit]
   Description=Podman pod-systemd-pod.service
   Documentation=man:podman-generate-systemd(1)
   Wants=network-online.target
   After=network-online.target
   RequiresMountsFor=
   Requires=container-container0.service container-container1.service
   Before=container-container0.service container-container1.service
   
   [Service]
   Environment=PODMAN_SYSTEMD_UNIT=%n
   Restart=on-failure
   TimeoutStopSec=70
   ExecStart=/usr/bin/podman start bcb128965b8e-infra
   ExecStop=/usr/bin/podman stop -t 10 bcb128965b8e-infra
   ExecStopPost=/usr/bin/podman stop -t 10 bcb128965b8e-infra
   PIDFile=/run/user/1000/containers/overlay-containers/1dfdcf20e35043939ea3f80f002c65c00d560e47223685dbc3230e26fe001b29/userdata/conmon.pid
   Type=forking
   
   [Install]
   WantedBy=multi-user.target default.target

   • [Unit] 部分中的 Requires 行定义 container-container0.service 和 container-container1.service 单元文件的依赖项。两个单元文件都会被激活。
   • [Service] 部分中的 ExecStart 和 ExecStop 行分别启动和停止 infra-container。

7. 显示 container-container0.service 单元文件：

   $ cat container-container0.service
   # container-container0.service
   # autogenerated by Podman 3.3.1
   # Wed Sep  8 20:49:17 CEST 2021
   
   [Unit]
   Description=Podman container-container0.service
   Documentation=man:podman-generate-systemd(1)
   Wants=network-online.target
   After=network-online.target
   RequiresMountsFor=/run/user/1000/containers
   BindsTo=pod-systemd-pod.service
   After=pod-systemd-pod.service
   
   [Service]
   Environment=PODMAN_SYSTEMD_UNIT=%n
   Restart=on-failure
   TimeoutStopSec=70
   ExecStart=/usr/bin/podman start container0
   ExecStop=/usr/bin/podman stop -t 10 container0
   ExecStopPost=/usr/bin/podman stop -t 10 container0
   PIDFile=/run/user/1000/containers/overlay-containers/4bccd7c8616ae5909b05317df4066fa90a64a067375af5996fdef9152f6d51f5/userdata/conmon.pid
   Type=forking
   
   [Install]
   WantedBy=multi-user.target default.target

   • [Unit] 部分中的 BindsTo 行定义 pod-systemd-pod.service 单元文件的依赖项
   • [Service] 部分中的 ExecStart 和 ExecStop 行分别启动和停止 container0。

8. 显示 container-container1.service 单元文件：

   $ cat container-container1.service

9. 将所有生成的文件复制到 $HOME/.config/systemd/user 中，以便以非 root 用户身份安装：

   $ cp pod-systemd-pod.service container-container0.service container-container1.service $HOME/.config/systemd/user

10. 启用该服务并在用户登录时启动：

    $ systemctl enable --user pod-systemd-pod.service
    Created symlink /home/user1/.config/systemd/user/multi-user.target.wants/pod-systemd-pod.service → /home/user1/.config/systemd/user/pod-systemd-pod.service.
    Created symlink /home/user1/.config/systemd/user/default.target.wants/pod-systemd-pod.service → /home/user1/.config/systemd/user/pod-systemd-pod.service.

    请注意，服务会在用户注销时停止。

流程

1. 启动基于 registry.access.redhat.com/ubi8/ubi-init 镜像的 myubi 容器：

   # podman run --label "io.containers.autoupdate=image" \
   --name myubi -dt registry.access.redhat.com/ubi8/ubi-init top
   bc219740a210455fa27deacc96d50a9e20516492f1417507c13ce1533dbdcd9d

2. 可选：列出正在运行或已退出的容器：

   # podman ps -a
   CONTAINER ID  IMAGE                                            COMMAND  CREATED         STATUS             PORTS   NAMES
   76465a5e2933  registry.access.redhat.com/8/ubi-init:latest  top      24 seconds ago  Up 23 seconds ago          myubi

3. 为 myubi 容器生成一个 systemd 单元文件：

   # podman generate systemd --new --files --name myubi /root/container-myubi.service

4. 将单元文件复制到 /usr/lib/systemd/system 中，以便以 root 用户身份安装它：

   # cp -Z ~/container-myubi.service /usr/lib/systemd/system

5. 重新载入 systemd 管理器配置：

   # systemctl daemon-reload

6. 启动并检查容器的状态：

   # systemctl start container-myubi.service
   # systemctl status container-myubi.service

7. 自动更新容器：

   # podman auto-update

流程

1. 显示 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

2. 显示 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 命令在每天午夜启动。

3. 在系统启动时启用 podman-auto-update.timer 服务：

   # systemctl enable podman-auto-update.timer

4. 启动 systemd 服务：

   # systemctl start podman-auto-update.timer

5. 可选：列出所有计时器：

   # 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。

流程

1. 创建包含以下内容的 playbook.yml 文件：

   - hosts: all
     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/db/db:stable
                   ports:
                     - containerPort: 1234
                       hostPort: 12340
                   volumeMounts:
                     - mountPath: /var/lib/db:Z
                       name: db
               volumes:
                 - name: db
                   hostPath:
                     path: /var/lib/db
         - state: started
           run_as_user: webapp
           run_as_group: webapp
           kube_file_src: /path/to/webapp.yml
     roles:
       - linux-system-roles.podman

   此流程创建一个有两个容器的 pod。podman_kube_specs 角色变量描述了 pod。

   • run_as_user 和 run_as_group 字段指定容器是无根的。

   • 包含 Kubernetes YAML 文件的 kube_file_content 字段定义了名为 db 的第一个容器。您可以使用 podman generate systemd 命令生成 Kubernetes YAML 文件。

     • db 容器是基于 quay.io/db/db:stable 容器镜像。
     • db 绑定挂载将主机上的 /var/lib/db 目录映射到容器中的 /var/lib/db 目录。Z 标志使用私有的 unshared 标签标记内容，因此只有 db 容器才能访问内容。
   • kube_file_src 字段定义第二个容器。控制器节点上 /path/to/webapp.yml 文件的内容将复制到受管节点上的 kube_file 字段中。
   • 设置 podman_create_host_directories: true 以在主机上创建目录。这指示角色检查 hostPath 卷的 kube 规格，并在主机上创建这些目录。如果您需要对所有权和权限有更多的控制，请使用 podman_host_directories。

2. 可选：验证 playbook 语法。

   # ansible-playbook --syntax-check playbook.yml -i inventory_file

3. 在清单文件上运行 playbook:

   # ansible-playbook -i inventory_file playbook.yml

流程

1. 创建包含以下内容的 playbook.yml 文件：

   - hosts: all
     vars:
       podman_firewall:
         - port: 8080/tcp
           state: enabled
       podman_kube_specs:
         - state: started
           kube_file_content:
             apiVersion: v1
             kind: Pod
             metadata:
               name: ubi8-httpd
             spec:
               containers:
                 - name: ubi8-httpd
                   image: registry.access.redhat.com/ubi8/httpd-24
                   ports:
                     - containerPort: 8080
                       hostPort: 8080
                   volumeMounts:
                     - mountPath: /var/www/html:Z
                       name: ubi8-html
               volumes:
                 - name: ubi8-html
                   persistentVolumeClaim:
                     claimName: ubi8-html-volume
     roles:
       - linux-system-roles.podman

   此流程创建一个具有一个容器的 pod。podman_kube_specs 角色变量描述了 pod。

   • 默认情况下，Podman 角色创建有根容器。

   • 包含 Kubernetes YAML 文件的 kube_file_content 字段定义了名为 ubi8-httpd 的容器。

     • ubi8-httpd 容器是基于 registry.access.redhat.com/ubi8/httpd-24 容器镜像。

       • ubi8-html-volume 将主机上的 /var/www/html 目录映射到容器。Z 标志使用私有 unshared 标签标记内容，因此只有 ubi8-httpd 容器可以访问内容。
       • pod 使用挂载路径 /var/www/html 挂载名为 ubi8-html-volume 的现有持久性卷。

2. 可选：验证 playbook 语法。

   # ansible-playbook --syntax-check playbook.yml -i inventory_file

3. 在清单文件上运行 playbook:

   # ansible-playbook -i inventory_file playbook.yml

流程

1. 创建包含以下内容的 playbook.yml 文件：

   podman_create_host_directories: true
   podman_activate_systemd_unit: false
   podman_quadlet_specs:
     - name: quadlet-demo
       type: network
       file_content: |
         [Network]
         Subnet=192.168.30.0/24
         Gateway=192.168.30.1
         Label=app=wordpress
     - file_src: quadlet-demo-mysql.volume
     - template_src: quadlet-demo-mysql.container.j2
     - file_src: envoy-proxy-configmap.yml
     - file_src: quadlet-demo.yml
     - file_src: quadlet-demo.kube
       activate_systemd_unit: true
   podman_firewall:
     - port: 8000/tcp
       state: enabled
     - port: 9000/tcp
       state: enabled
   podman_secrets:
     - name: mysql-root-password-container
       state: present
       skip_existing: true
       data: "{{ root_password_from_vault }}"
     - name: mysql-root-password-kube
       state: present
       skip_existing: true
       data: |
         apiVersion: v1
         data:
           password: "{{ root_password_from_vault | b64encode }}"
         kind: Secret
         metadata:
           name: mysql-root-password-kube
     - name: envoy-certificates
       state: present
       skip_existing: true
       data: |
         apiVersion: v1
         data:
           certificate.key: {{ key_from_vault | b64encode }}
           certificate.pem: {{ cert_from_vault | b64encode }}
         kind: Secret
         metadata:
           name: envoy-certificates

   流程创建一个与 MySQL 数据库配对的 WordPress 内容管理系统。podman_quadlet_specs 角色 变量为 Quadlet 定义一组配置，它指向以某种方式一起工作的一组容器或服务。它包括以下规范：

   • Wordpress 网络由 quadlet-demo 网络单元定义。
   • MySQL 容器的卷配置由 file_src: quadlet-demo-mysql.volume 字段定义。
   • template_src: quadlet-demo-mysql.container.j2 字段用于为 MySQL 容器生成一个配置。
   • 两个 YAML 文件如下：file_src: envoy-proxy-configmap.yml 和 file_src: quadlet-demo.yml.请注意，.yml 不是一个有效的 Quadlet 单元类型，因此这些文件将只被复制，且不会作为 Quadlet 规范来处理。
   • Wordpress 和 envoy 代理容器和配置由 file_src: quadlet-demo.kube 字段定义。kube 单元将之前 [Kube] 部分中的 YAML 文件称为 Yaml=quadlet-demo.yml 和 ConfigMap=envoy-proxy-configmap.yml。

2. 可选：验证 playbook 语法。

   # ansible-playbook --syntax-check playbook.yml -i inventory_file

3. 在清单文件上运行 playbook:

   # ansible-playbook -i inventory_file playbook.yml

流程

1. 点主菜单中的 Podman containers。
2. 点 Create container。
3. 在 Name 字段中输入容器的名称。

4. 在 Details 选项卡中提供所需信息。

   • Available only with the administrative access ：选择容器的所有者：系统或用户。

   • 在 Image 下拉列表中，选择或搜索所选注册中心中的容器镜像。

     • 可选：点 Pull latest image 复选框，以拉取最新的容器镜像。

   • Command 字段指定命令。如果需要，您可以更改默认命令。

     • 可选：点 With terminal 复选框，以使用终端运行容器。
   • Memory limit 字段指定容器的内存限制。要更改默认内存限制，请选中复选框并指定限制。
   • Available only for system containers ：在 CPU shares 字段 中，指定相对 CPU 时间的相对量。默认值为 1024。选中复选框以修改默认值。

   • Available only for system containers ：在 Restart policy 下拉菜单中，选择以下选项之一：

     • No（默认值）：无操作。
     • On Failure：失败时重启容器。
     • Always ：退出或系统引导后重启容器。

5. 在 Integration 选项卡中提供所需信息。

   • 点 Add port mapping 添加容器和主机系统之间的端口映射。

     • 输入 IP 地址、主机端口、容器端口和协议。

   • 点 Add volume 添加卷。

     • 输入主机路径，容器路径。您可以选择 Writable 复选框来创建一个可写卷。在 SELinux 下拉列表中，选择以下选项之一： No Label、Share 或 Private。

   • 单击 Add variable 以添加环境变量。

     • 输入键和值。

6. 在 Health check 选项卡中提供所需信息。

   • 在 Command 字段中，输入 healthcheck 命令。

   • 指定健康检查选项：

     • 间隔（默认为 30 秒）
     • 超时（默认为 30 秒）
     • 起始周期
     • healthcheck 命令的重试（默认为 3）

     • 在不健康时：选择以下选项之一：

       • No action（默认）：不执行任何操作。
       • Restart: 重启容器。
       • Stop ：停止容器。
       • Force stop ：强制停止容器，它不会等待容器退出。
7. 点 Create and run 创建并运行容器。

流程

1. 点主菜单中的 Podman containers。

2. 点 > 箭头图标查看容器的详情。

   • 在 Details 选项卡中，您可以看到容器 ID、镜像、命令、已创建（创建容器时的时间戳）及其状态。

     • Available only for system containers ：您还可以查看 IP 地址、MAC 地址和网关地址。
   • 在 Integration 选项卡中，您可以看到环境变量、端口映射和卷。
   • 在 Log 选项卡中，您可以看到容器日志。
   • 在 Console 选项卡中，您可以使用命令行与容器进行交互。

流程

1. 点主菜单中的 Podman containers。

2. 在 Containers 表中，选择您要修改的容器，点击溢出菜单并选择您要执行的操作：

   • Start
   • Stop
   • Force stop
   • Restart
   • Force restart
   • Pause
   • Rename

流程

1. 点主菜单中的 Podman containers。
2. 在 Containers 表中，选择您要修改的容器，点击溢出菜单并选择 Commit。

3. 在 Commit container 表单中，添加以下详情：

   • 在 New image name 字段中，输入镜像名称。
   • 可选：在 Tag 字段中输入标签。
   • 可选：在 Author 字段中输入您的名称。
   • 可选：在 Command 字段中，根据需要更改命令。

   • 可选：检查您需要的选项：

     • 在创建镜像时暂停容器：在提交镜像时，容器及其进程将暂停。
     • 使用传统的 Docker 格式：如果您不使用 Docker 镜像格式，则使用 OCI 格式。
4. 点 Commit。

流程

1. 点主菜单中的 Podman containers。
2. 在 Containers 表中，选择您要修改的容器，点击溢出图标菜单并选择 Checkpoint。

3. 可选：在 Checkpoint 容器 表单中，检查您需要的选项：

   • 保留所有临时检查点文件：在检查点过程中保留 CRIU 创建的所有临时日志和统计数据文件。如果检查点失败，这些文件不会被删除，以便做进一步调试。
   • 将检查点写入磁盘后让其继续运行：让容器在检查点之后继续运行，而不是停止它。
   • 支持保留建立的 TCP 连接
4. 点 Checkpoint。

流程

1. 点主菜单中的 Podman containers。
2. 在 Containers 表中，选择您要修改的容器，点击溢出菜单并选择 Restore。

3. 可选：在 Restore container 表单中，检查您需要的选项：

   • 保留所有临时检查点文件：保留检查点期间 CRIU 创建的所有临时日志和统计数据文件。如果检查点失败，这些文件不会被删除，以便做进一步调试。
   • 使用建立的 TCP 连接恢复
   • 如果静态设置了 IP 地址，忽略它：如果容器是使用 IP 地址启动的，则恢复的容器也会尝试使用该 IP 地址，如果该 IP 地址已在使用，则恢复会失败。如果您在创建容器时在 Integration 选项卡中添加了端口映射，则此选项适用。
   • 如果静态设定了 MAC 地址，忽略它：如果容器是使用 MAC 地址启动的，则恢复的容器也会尝试使用该 MAC 地址，如果该 MAC 地址已在使用，则恢复会失败。
4. 点 Restore。

流程

1. 点主菜单中的 Podman containers。
2. 在 Containers 表中，选择您要删除的容器，点击溢出菜单并选择 Delete。
3. 此时会出现弹出窗口。点 Delete 确认您的选择。

流程

1. 点主菜单中的 Podman containers。
2. 点 Create pod。

3. 在 Create pod 表单中提供所需信息：

   • Available only with the administrative access ：选择容器的所有者：系统或用户。
   • 在 Name 字段中输入容器的名称。

   • 点 Add port mapping 添加容器和主机系统之间的端口映射。

     • 输入 IP 地址、主机端口、容器端口和协议。

   • 点 Add volume 添加卷。

     • 输入主机路径，容器路径。您可以选择 Writable 复选框来创建一个可写卷。在 SELinux 下拉列表中，选择以下选项之一： No Label、Share 或 Private。
4. 点 Create。

流程

1. 点主菜单中的 Podman containers。
2. 点 Create container in pod。
3. 按照 在 web 控制台中创建容器 中的步骤 3.-8.。

流程

1. 点主菜单中的 Podman containers。

2. 在 Containers 表中，选择要修改的 pod，点击溢出菜单并选择您要执行的操作：

   • Start
   • Stop
   • Force stop
   • Restart
   • Force restart
   • Pause

流程

1. 点主菜单中的 Podman containers。
2. 在 Containers 表中，选择您要删除的 pod，点击溢出菜单并选择 Delete。
3. 此时会出现弹出窗口。点 Delete 确认您的选择。

流程

1. 登录到 registry.redhat.io registry:

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

2. 获取 registry.redhat.io/rhel8/skopeo 容器镜像：

   $ podman pull registry.redhat.io/rhel8/skopeo

3. 使用 Skopeo 检查远程容器镜像 registry.access.redhat.com/ubi8/ubi:

   $ podman run --rm registry.redhat.io/rhel8/skopeo \
     skopeo inspect docker://registry.access.redhat.com/ubi8/ubi
   {
       "Name": "registry.access.redhat.com/ubi8/ubi",
       ...
       "Labels": {
           "architecture": "x86_64",
           ...
           "name": "ubi8",
           ...
           "summary": "Provides the latest release of Red Hat Universal Base Image 8.",
           "url": "https://access.redhat.com/containers/#/registry.access.redhat.com/ubi8/images/8.2-347",
           ...
       },
       "Architecture": "amd64",
       "Os": "linux",
       "Layers": [
       ...
       ],
       "Env": [
           "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
           "container=oci"
       ]
   }

   --rm 选项会在容器退出后删除 registry.redhat.io/rhel8/skopeo 镜像。

流程

1. 将 registry.access.redhat.com/ubi8/ubi 镜像复制到本地容器存储中：

   $ podman run --privileged --rm -v $HOME/.local/share/containers/storage:/var/lib/containers/storage \
   registry.redhat.io/rhel8/skopeo skopeo copy \
   docker://registry.access.redhat.com/ubi8/ubi containers-storage:registry.access.redhat.com/ubi8/ubi

   • privileged 选项禁用所有安全机制。红帽建议仅在可信环境中使用这个选项。

   • 为了避免禁用安全机制，请将镜像导出到 tarball 或其它基于路径的镜像传输,并将其挂载到 Skopeo 容器中：

     • $ podman save --format oci-archive -o oci.tar $IMAGE
     • $podman run --rm -v oci.tar:/oci.tar registry.redhat.io/rhel8/skopeo copy oci-archive:/oci.tar $DESTINATION

2. 可选：列出本地存储中的镜像：

   $ podman images
   REPOSITORY                               TAG     IMAGE ID      CREATED       SIZE
   registry.access.redhat.com/ubi8/ubi      latest  ecbc6f53bba0  8 weeks ago   211 MB

流程

1. 登录到 registry.redhat.io registry:

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

2. 拉取并运行 registry.redhat.io/rhel8/buildah 镜像：

   # podman run --rm --device /dev/fuse -it \
     registry.redhat.io/rhel8/buildah /bin/bash

   • --rm 选项会在容器退出后删除 registry.redhat.io/rhel8/buildah 镜像。
   • device 选项将主机设备添加到容器中。
   • sys_chroot - 能够更改为不同的根目录。它不包含在容器的默认功能中。

3. 使用 registry.access.redhat.com/ubi8 镜像创建一个新的容器：

   # buildah from registry.access.redhat.com/ubi8
   ...
   ubi8-working-container

4. 在 ubi8-working-container 容器中运行 ls / 命令：

   # buildah run --isolation=chroot ubi8-working-container ls /
   bin  boot  dev  etc  home  lib  lib64  lost+found  media  mnt  opt  proc  root  run  sbin  srv

5. 可选：列出本地存储中的所有镜像：

   # buildah images
   REPOSITORY                        TAG      IMAGE ID       CREATED       SIZE
   registry.access.redhat.com/ubi8   latest   ecbc6f53bba0   5 weeks ago   211 MB

6. 可选：列出工作容器及其基础镜像：

   # buildah containers
   CONTAINER ID  BUILDER  IMAGE ID     IMAGE NAME                       CONTAINER NAME
   0aaba7192762     *     ecbc6f53bba0 registry.access.redhat.com/ub... ubi8-working-container

7. 可选：将 registry.access.redhat.com/ubi8 镜像推送到 registry.example.com 上的本地注册中心：

   # buildah push ecbc6f53bba0 registry.example.com:5000/ubi8/ubi