虚拟化

流程

1. 运行以下命令来查看 ConsoleCLIDownload 对象：

   $ oc get ConsoleCLIDownload virtctl-clidownloads-kubevirt-hyperconverged -o yaml

2. 使用为您的发行版本列出的链接下载 virtctl 客户端。

流程

1. 从侧边菜单中点 Workloads → Virtualization。
2. 点 Virtual Machines 标签页。
3. 点 Create 并选择 Virtual Machine With YAML。

4. 在可编辑窗口写入或粘贴您的虚拟机配置。

   1. 或者，使用 YAML 屏幕中默认提供的 example 虚拟机。
5. 可选：点 Download 以下载当前状态下的 YAML 配置文件。
6. 点击 Create 以创建虚拟机。

流程

1. 在 OpenShift Virtualization 控制台中，从侧边菜单中点击 Workloads → Virtualization。
2. 点 Virtual Machines 标签页。
3. 选择一个虚拟机以打开 Virtual Machine Overview 页。
4. 点击 Console。默认会打开 VNC 控制台。
5. 选择 Disconnect before switching，以确保一次只打开一个控制台会话。否则，VNC 控制台会话会在后台保持活跃。
6. 点击 VNC Console 下拉菜单并选择 Serial Console。
7. 点 Disconnect 结束控制台会话。
8. 可选：点 Open Console in New Window 在一个单独的窗口中打开串口控制台。

流程

1. 在 OpenShift Virtualization 控制台中，从侧边菜单中点击 Workloads → Virtualization。
2. 点 Virtual Machines 标签页。
3. 选择一个虚拟机以打开 Virtual Machine Overview 页。
4. 点击 Console 选项卡。默认会打开 VNC 控制台。
5. 可选：点 Open Console in New Window 在一个单独的窗口中打开 VNC 控制台。
6. 可选：点 Send Key 将密钥组合发送到虚拟机。
7. 点控制台窗口外，然后点 Disconnect 结束会话。

流程

1. 在 OpenShift Virtualization 控制台中，从侧边菜单中点击 Workloads → Virtualization。
2. 点 Virtual Machines 标签页。
3. 选择 Windows 虚拟机以打开 Virtual Machine Overview 屏幕。
4. 点击 Console 选项卡。
5. 在 Console 列表中，选择 Desktop Viewer。
6. 在 Network Interface 列表中，选择第 2 层 vNIC。
7. 点击 Launch Remote Desktop 下载 console.rdp 文件。

8. 打开 RDP 客户端并引用 console.rdp 文件。例如，使用 Remmina：

   $ remmina --connect /path/to/console.rdp

9. 输入 Administrator 用户名和密码以连接至 Windows 虚拟机。

流程

1. 在 OpenShift Container Platform 控制台中，从侧边菜单中点 Workloads → Virtualization。
2. 点 Virtual Machines 标签页。
3. 选择一个虚拟机以打开 Virtual Machine Overview 页。
4. 从 Actions 列表中，选择 Copy SSH Command。现在，您可以将此命令粘贴到 OpenShift CLI (oc)中。

流程

1. 运行以下命令来创建 fedora-vm-ssh 服务：

   $ virtctl expose vm <fedora-vm> --port=22 --name=fedora-vm-ssh --type=NodePort 1

   1

   <fedora-vm> 是您在其上运行 fedora-vm-ssh 服务的虚拟机的名称。

2. 检查服务，找出服务获取的端口：

   $ oc get svc

   输出示例

   NAME            TYPE       CLUSTER-IP     EXTERNAL-IP   PORT(S)           AGE
   fedora-vm-ssh   NodePort   127.0.0.1      <none>        22:32551/TCP   6s

   在本例中，服务获取了 32551 端口。

3. 通过 SSH 登录 VMI。使用任何集群节点的 ipAddress，以及在上一步中找到的端口：

   $ ssh username@<node_IP_address> -p 32551

流程

1. 在虚拟机的 YAML 文件中，添加标签和一个值来公开 SSH 连接的服务。为接口启用伪装（masquerade）功能：

   VirtualMachine 定义示例

   apiVersion: kubevirt.io/v1
   kind: VirtualMachine
   metadata:
     namespace: ssh-ns 1
     name: vm-ssh
   spec:
     running: false
     template:
       metadata:
         labels:
           kubevirt.io/vm: vm-ssh
           special: vm-ssh 2
       spec:
         domain:
           devices:
             disks:
             - disk:
                 bus: virtio
               name: containerdisk
             - disk:
                 bus: virtio
               name: cloudinitdisk
             interfaces:
             - masquerade: {} 3
               name: testmasquerade 4
             rng: {}
           machine:
             type: ""
           resources:
             requests:
               memory: 1024M
         networks:
         - name: testmasquerade
           pod: {}
         volumes:
         - name: containerdisk
           containerDisk:
             image: kubevirt/fedora-cloud-container-disk-demo
         - name: cloudinitdisk
           cloudInitNoCloud:
             userData: |
               #cloud-config
               user: fedora
               password: fedora
               chpasswd: {expire: False}
   # ...

   1

   oc create namespace 命令创建的命名空间的名称。

   2

   服务用于标识为 SSH 流量连接启用的虚拟机实例的标签。标签可以是任何 key:value 对，作为标签（label）添加到此 YAML 文件，也可以作为服务 YAML 文件中的 selector 添加。

   3

   接口类型是 masquerade。

   4

   此接口的名称为 testmasquerade。

2. 创建虚拟机：

   $ oc create -f <path_for_the_VM_YAML_file>

3. 启动虚拟机：

   $ virtctl start vm-ssh

4. 在服务的 YAML 文件中，指定服务名称、端口号和目标端口。

   Service 定义示例

   apiVersion: v1
   kind: Service
   metadata:
     name: svc-ssh 1
     namespace: ssh-ns 2
   spec:
     ports:
     - targetPort: 22 3
       protocol: TCP
       port: 27017
     selector:
       special: vm-ssh 4
     type: NodePort
   # ...

   1

   SSH 服务的名称。

   2

   oc create namespace 命令创建的命名空间的名称。

   3

   SSH 连接的目标端口号。

   4

   选择器名称和值必须与虚拟机的 YAML 文件中指定的标签匹配。

5. 创建服务：

   $ oc create -f <path_for_the_service_YAML_file>

6. 验证虚拟机是否正在运行：

   $ oc get vmi

   输出示例

   NAME    AGE     PHASE       IP              NODENAME
   vm-ssh 6s       Running     10.244.196.152  node01

7. 检查服务，找出服务获取的端口：

   $ oc get svc

   输出示例

   NAME            TYPE       CLUSTER-IP     EXTERNAL-IP   PORT(S)           AGE
   svc-ssh     NodePort       10.106.236.208 <none>        27017:30093/TCP   22s

   在本例中，服务获取了端口号 30093。

8. 运行以下命令来获取节点的 IP 地址：

   $ oc get node <node_name> -o wide

   输出示例

   NAME    STATUS   ROLES   AGE    VERSION  INTERNAL-IP      EXTERNAL-IP
   node01  Ready    worker  6d22h  v1.22.1  192.168.55.101   <none>

9. 通过 SSH 登录虚拟机运行的节点的 IP 地址和端口号。使用 oc get svc 命令显示的端口号，以及 oc get node 命令显示的节点 IP 地址。以下示例显示了带有用户名、节点 IP 地址和端口号的 ssh 命令：

   $ ssh fedora@192.168.55.101 -p 30093

流程

1. 使用 virtctl 实用程序连接至图形界面：

   $ virtctl vnc <VMI>

2. 如果命令失败，请尝试使用 -v 标志来收集故障排除信息：

   $ virtctl vnc <VMI> -v 4

流程

1. 以具有访问令牌的用户身份通过 oc CLI 工具登录 OpenShift Virtualization 集群。

   $ oc login -u <user> https://<cluster.example.com>:8443

2. 使用 oc describe vmi 显示正在运行的 Windows 虚拟机的配置。

   $ oc describe vmi <windows-vmi-name>

   输出示例

   ...
   spec:
     networks:
     - name: default
       pod: {}
     - multus:
         networkName: cnv-bridge
       name: bridge-net
   ...
   status:
     interfaces:
     - interfaceName: eth0
       ipAddress: 198.51.100.0/24
       ipAddresses:
         198.51.100.0/24
       mac: a0:36:9f:0f:b1:70
       name: default
     - interfaceName: eth1
       ipAddress: 192.0.2.0/24
       ipAddresses:
         192.0.2.0/24
         2001:db8::/32
       mac: 00:17:a4:77:77:25
       name: bridge-net
   ...

3. 找出并复制第 2 层网络接口的 IP 地址。在以上示例中是 192.0.2.0，如果您首选 IPv6，则为 2001:db8::。
4. 打开 RDP 客户端，并使用上一步中复制的 IP 地址进行连接。
5. 输入 Administrator 用户名和密码以连接至 Windows 虚拟机。

流程

1. 启动虚拟机并连接至图形控制台。
2. 登录 Windows 用户会话。

3. 打开 Device Manager 并展开 Other devices 以列出所有 Unknown device。

   1. 打开 Device Properties 以识别未知设备。右击设备并选择 Properties。
   2. 单击 Details 选项卡，并在 Property 列表中选择 Hardware Ids。
   3. 将 Hardware Ids 的 Value 与受支持的 VirtIO 驱动程序相比较。
4. 右击设备并选择 Update Driver Software。
5. 点击 Browse my computer for driver software 并浏览所附加的 VirtIO 驱动程序所在 SATA CD 驱动器。驱动程序将按照其驱动程序类型、操作系统和 CPU 架构分层排列。
6. 点击 Next 以安装驱动程序。
7. 对所有必要 VirtIO 驱动程序重复这一过程。
8. 安装完驱动程序后，点击 Close 关闭窗口。
9. 重启虚拟机以完成驱动程序安装。

流程

1. 启动虚拟机并连接至图形控制台。
2. 开始 Windows 安装过程。
3. 选择 Advanced 安装。
4. 加载驱动程序前无法识别存储目的地。点击 Load driver。
5. 驱动程序将附加为 SATA CD 驱动器。点击 OK 并浏览 CD 驱动器以加载存储驱动程序。驱动程序将按照其驱动程序类型、操作系统和 CPU 架构分层排列。
6. 对所有所需驱动程序重复前面两步。
7. 完成 Windows 安装。

流程

1. 通过编辑 VirtualMachine 清单来为虚拟机设置限值。例如：

   apiVersion: kubevirt.io/v1
   kind: VirtualMachine
   metadata:
     name: with-limits
   spec:
     running: false
     template:
       spec:
         domain:
   # ...
           resources:
             requests:
               memory: 128Mi
             limits:
               memory: 256Mi  1

   1

   这个配置被支持，因为 limits.memory 值至少比 requests.memory 的值大 100Mi。

2. 保存 VirtualMachine 清单。

流程

1. 运行以下命令打开 HyperConverged CR：

   $ oc edit hco -n openshift-cnv kubevirt-hyperconverged

2. 按照以下示例所示，编辑 spec.certConfig 字段。要避免系统过载，请确保所有值都大于或等于 10 分钟。将所有值显示为符合 golang ParseDuration 格式的字符串。

   apiVersion: hco.kubevirt.io/v1beta1
   kind: HyperConverged
   metadata:
    name: kubevirt-hyperconverged
    namespace: openshift-cnv
   spec:
     certConfig:
       ca:
         duration: 48h0m0s
         renewBefore: 24h0m0s 1
       server:
         duration: 24h0m0s  2
         renewBefore: 12h0m0s  3

   1

   ca.renewBefore 的值必须小于或等于 ca.duration 的值。

   2

   server.duration 的值必须小于或等于 ca.duration 的值。

   3

   server.renewBefore 的值必须小于或等于 server.duration 的值。

3. 将 YAML 文件应用到集群。

流程

1. 编辑 Ansible Playbook YAML 文件，以便其包含 kubevirt_vm 任务：

     kubevirt_vm:
       namespace:
       name:
       cpu_cores:
       memory:
       disks:
         - name:
           volume:
             containerDisk:
               image:
           disk:
             bus:

   注意

   该片断仅包含 playbook 的 kubevirt_vm 部分。

2. 编辑这些值以反应您要创建的虚拟机，包括 namespace、cpu_cores 数、memory 以及 disks。例如：

     kubevirt_vm:
       namespace: default
       name: vm1
       cpu_cores: 1
       memory: 64Mi
       disks:
         - name: containerdisk
           volume:
             containerDisk:
               image: kubevirt/cirros-container-disk-demo:latest
           disk:
             bus: virtio

3. 如果希望虚拟机创建后立即启动，请向 YAML 文件添加 state: running。例如：

     kubevirt_vm:
       namespace: default
       name: vm1
       state: running 1
       cpu_cores: 1

   1

   将该值改为 state: absent 会删除已存在的虚拟机。

4. 运行 ansible-playbook 命令，将 playbook 文件名用作唯一参数：

   $ ansible-playbook create-vm.yaml

5. 查看输出以确定该 play 是否成功：

   输出示例

   (...)
   TASK [Create my first VM] ************************************************************************
   changed: [localhost]
   
   PLAY RECAP ********************************************************************************************************
   localhost                  : ok=2    changed=1    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0

6. 如果您未在 playbook 文件中包含 state: running，而您希望立即启动虚拟机，请编辑文件使其包含 state: running 并再次运行 playbook：

   $ ansible-playbook create-vm.yaml

流程

1. 创建定义虚拟机对象的 YAML 文件。使用示例 YAML 文件的固件小节：

   使用安全引导活跃在 EFI 模式中引导

   apiversion: kubevirt.io/v1
   kind: VirtualMachine
   metadata:
     labels:
       special: vm-secureboot
     name: vm-secureboot
   spec:
     template:
       metadata:
         labels:
           special: vm-secureboot
       spec:
         domain:
           devices:
             disks:
             - disk:
                 bus: virtio
               name: containerdisk
           features:
             acpi: {}
             smm:
               enabled: true 1
           firmware:
             bootloader:
               efi:
                 secureBoot: true 2
   #...

   1

   OpenShift Virtualization 需要为 EFI 模式的安全引导启用系统管理模式（SMM）。

   2

   在使用 EFI 模式时，OpenShift Virtualization 支持带有或不带有安全引导机制的虚拟机。如果启用了安全引导机制，则需要 EFI 模式。但是，无需使用安全引导机制即可启用 EFI 模式。

2. 运行以下命令，将清单应用到集群：

   $ oc create -f <file_name>.yaml

流程

1. 在集群上配置 PXE 网络：

   1. 为 PXE 网络 pxe-net-conf 创建网络附加定义文件：

      apiVersion: "k8s.cni.cncf.io/v1"
      kind: NetworkAttachmentDefinition
      metadata:
        name: pxe-net-conf
      spec:
        config: '{
          "cniVersion": "0.3.1",
          "name": "pxe-net-conf",
          "plugins": [
            {
              "type": "cnv-bridge",
              "bridge": "br1",
              "vlan": 1 1
            },
            {
              "type": "cnv-tuning" 2
            }
          ]
        }'

      1

      可选： VLAN 标签。

      2

      cnv-tuning 插件为自定义 MAC 地址提供支持。

      注意

      虚拟机实例将通过所请求的 VLAN 的访问端口附加到网桥 br1。

2. 使用您在上一步中创建的文件创建网络附加定义：

   $ oc create -f pxe-net-conf.yaml

3. 编辑虚拟机实例配置文件以包括接口和网络的详情。

   1. 如果 PXE 服务器需要，请指定网络和 MAC 地址。如果未指定 MAC 地址，则会自动分配一个值。

      请确保 bootOrder 设置为 1，以便该接口先启动。在本例中，该接口连接到了名为 <pxe-net> 的网络中：

      interfaces:
      - masquerade: {}
        name: default
      - bridge: {}
        name: pxe-net
        macAddress: de:00:00:00:00:de
        bootOrder: 1

      注意

      启动顺序对于接口和磁盘全局通用。

   2. 为磁盘分配一个启动设备号，以确保置备操作系统后能够正确启动。

      将磁盘 bootOrder 值设置为 2：

      devices:
        disks:
        - disk:
            bus: virtio
          name: containerdisk
          bootOrder: 2

   3. 指定网络连接到之前创建的网络附加定义。在这种情况下，<pxe-net> 连接到名为 <pxe-net-conf> 的网络附加定义：

      networks:
      - name: default
        pod: {}
      - name: pxe-net
        multus:
          networkName: pxe-net-conf

4. 创建虚拟机实例：

   $ oc create -f vmi-pxe-boot.yaml

1. 等待虚拟机实例运行：

   $ oc get vmi vmi-pxe-boot -o yaml | grep -i phase
     phase: Running

2. 使用 VNC 查看虚拟机实例：

   $ virtctl vnc vmi-pxe-boot

3. 查看启动屏幕，验证 PXE 启动是否成功。

4. 登录虚拟机实例：

   $ virtctl console vmi-pxe-boot

5. 验证虚拟机上的接口和 MAC 地址，并验证连接到网桥的接口是否具有指定的 MAC 地址。在本例中，我们使用了 eth1 进行 PXE 启动，无需 IP 地址。另一接口 eth0 从 OpenShift Container Platform 获取 IP 地址。

   $ ip addr

流程

1. 要明确告知虚拟机实例它的可用内存超过集群请求内存，请编辑虚拟机配置文件，并将 spec.domain.memory.guest 设置为超过 spec.domain.resources.requests.memory 的值。这一过程即为“内存过量使用”。

   在本例中，对集群的请求内存为 1024M，但虚拟机实例被告知它有 2048M 可用。只要相关的节点上有足够的可用内存，虚拟机实例最多可消耗 2048M 内存。

   kind: VirtualMachine
   spec:
     template:
       domain:
       resources:
           requests:
             memory: 1024M
       memory:
           guest: 2048M

   注意

   如果节点面临内存压力，则适用于 pod 的驱除规则也适用于虚拟机实例。

2. 创建虚拟机：

   $ oc create -f <file_name>.yaml

流程

1. 要禁用客户机内存开销核算，请编辑 YAML 配置文件并将 overcommitGuestOverhead 值设置为 true。默认禁用此参数。

   kind: VirtualMachine
   spec:
     template:
       domain:
       resources:
           overcommitGuestOverhead: true
           requests:
             memory: 1024M

   注意

   如果启用 overcommitGuestOverhead，则会在内存限值中添加客户机开销（如果存在）。

2. 创建虚拟机：

   $ oc create -f <file_name>.yaml

流程

1. 在虚拟机配置中，把 resources.requests.memory 和 memory.hugepages.pageSize 参数添加到 spec.domain。以下配置片段适用于请求总计 4Gi 内存的虚拟机，页面大小为 1Gi:

   kind: VirtualMachine
   ...
   spec:
     domain:
       resources:
         requests:
           memory: "4Gi" 1
       memory:
         hugepages:
           pageSize: "1Gi" 2
   ...

   1

   为虚拟机请求的总内存量。这个值必须可以被按页大小整除。

   2

   每个巨页的大小。x86_64 架构的有效值为 1Gi 和 2Mi。页面大小必须小于请求的内存。

2. 应用虚拟机配置：

   $ oc apply -f <virtual_machine>.yaml

流程

1. 从侧边菜单中选择 Workloads → Virtual Machines。
2. 选择一个虚拟机以打开 Virtual Machine 选项卡。
3. 点 Details 标签页。
4. 点 Dedicated Resources 项右面的铅笔标签打开 Dedicated Resources 窗口。
5. 选择 Schedule this workload with dedicated resources (guaranteed policy)。
6. 点 Save。

流程

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

   apiVersion: kubevirt.io/v1
   kind: VirtualMachine
   metadata:
     labels:
       kubevirt.io/vm: vm2-rhel84-watchdog
     name: <vm-name>
   spec:
     running: false
     template:
       metadata:
        labels:
           kubevirt.io/vm: vm2-rhel84-watchdog
       spec:
         domain:
           devices:
             watchdog:
               name: <watchdog>
               i6300esb:
                 action: "poweroff" 1
   ...

   1

   指定 watchdog 操作（poweroff、reset 或 shutdown）。

   上面的示例使用 poweroff 操作配置 RHEL8 虚拟机上的 i6300esb watchdog 设备，并将设备公开为 /dev/watchdog。

   现在，watchdog 二进制文件可以使用这个设备。

2. 运行以下命令，将 YAML 文件应用到集群：

   $ oc apply -f <file_name>.yaml

1. 运行以下命令来验证虚拟机是否已连接到 watchdog 设备：

   $ lspci | grep watchdog -i

2. 运行以下命令之一以确认 watchdog 处于活跃状态：

   • 触发内核 panic：

     # echo c > /proc/sysrq-trigger

   • 终止 watchdog 服务：

     # pkill -9 watchdog

流程

1. 作为 root 用户，安装 watchdog 软件包和依赖项：

   # yum install watchdog

2. 在 /etc/watchdog.conf 文件中取消注释以下行，并保存更改：

   #watchdog-device = /dev/watchdog

3. 在引导时启用 watchdog 服务：

   # systemctl enable --now watchdog.service

流程

1. 确定您处于正确的命名空间中。配置映射只能被数据卷引用（如果位于同一命名空间中）。

   $ oc get ns

2. 创建配置映射：

   $ oc create configmap <configmap-name> --from-file=</path/to/file/ca.pem>

流程

1. 如果您的数据源需要身份验证，请创建一个 Secret 清单，指定数据源凭证，并将其保存为 endpoint-secret.yaml ：

   apiVersion: v1
   kind: Secret
   metadata:
     name: endpoint-secret 1
     labels:
       app: containerized-data-importer
   type: Opaque
   data:
     accessKeyId: "" 2
     secretKey:   "" 3

   1

   指定 Secret 的名称。

   2

   指定以 Base64 编码的密钥 ID 或用户名。

   3

   指定以 Base64 编码的 secret 密钥或密码。

2. 应用 Secret 清单：

   $ oc apply -f endpoint-secret.yaml

3. 编辑 VirtualMachine 清单，为要导入的虚拟机镜像指定数据源，并将其保存为 vm-fedora-datavolume.yaml ：

   apiVersion: kubevirt.io/v1
   kind: VirtualMachine
   metadata:
     creationTimestamp: null
     labels:
       kubevirt.io/vm: vm-fedora-datavolume
     name: vm-fedora-datavolume 1
   spec:
     dataVolumeTemplates:
     - metadata:
         creationTimestamp: null
         name: fedora-dv 2
       spec:
         storage:
           resources:
             requests:
               storage: 10Gi
           storageClassName: local
         source:
           http: 3
             url: "https://mirror.arizona.edu/fedora/linux/releases/35/Cloud/x86_64/images/Fedora-Cloud-Base-35-1.2.x86_64.qcow2" 4
             secretRef: endpoint-secret 5
             certConfigMap: "" 6
       status: {}
     running: true
     template:
       metadata:
         creationTimestamp: null
         labels:
           kubevirt.io/vm: vm-fedora-datavolume
       spec:
         domain:
           devices:
             disks:
             - disk:
                 bus: virtio
               name: datavolumedisk1
           machine:
             type: ""
           resources:
             requests:
               memory: 1.5Gi
         terminationGracePeriodSeconds: 180
         volumes:
         - dataVolume:
             name: fedora-dv
           name: datavolumedisk1
   status: {}

   1

   指定虚拟机的名称。

   2

   指定数据卷的名称。

   3

   为 HTTP 或 HTTPS 端点指定 http。为从 registry 导入的容器磁盘镜像指定 registry。

   4

   要导入的虚拟机镜像的源。本例引用了 HTTPS 端点上的虚拟机镜像。容器镜像仓库端点示例为 url: "docker://kubevirt/fedora-cloud-container-disk-demo:latest"。

   5

   如果您为数据源创建 Secret，则需要此项。

   6

   可选：指定一个 CA 证书配置映射。

4. 创建虚拟机：

   $ oc create -f vm-fedora-datavolume.yaml

   注意

   oc create 命令创建数据卷和虚拟机。CDI 控制器创建一个带有正确注解和导入过程的底层 PVC。导入完成后，数据卷状态变为 Succeeded。您可以启动虚拟机。

   数据卷置备在后台进行，因此无需监控进程。

验证

1. importer pod 从指定的 URL 下载虚拟机镜像或容器磁盘，并将其存储在置备的 PV 上。运行以下命令，查看 importer pod 的状态：

   $ oc get pods

2. 运行以下命令监控数据卷，直到其状态为 Succeeded ：

   $ oc describe dv fedora-dv 1

   1

   指定您在 VirtualMachine 清单中定义的数据卷名称。

3. 通过访问其串行控制台来验证置备是否已完成，并且虚拟机是否已启动：

   $ virtctl console vm-fedora-datavolume

流程

1. 以 root 身份登录节点，在其上创建本地 PV。本流程以 node01 为例。

2. 创建一个文件并用空字符填充，以便可将其用作块设备。以下示例创建 loop10 文件，大小为 2Gb（20,100 Mb 块）：

   $ dd if=/dev/zero of=<loop10> bs=100M count=20

3. 将 loop10 文件挂载为 loop 设备。

   $ losetup </dev/loop10>d3 <loop10> 1 2

   1

   挂载 loop 设备的文件路径。

   2

   上一步中创建的文件，挂载为 loop 设备。

4. 创建引用所挂载 loop 设备的 PersistentVolume 清单。

   kind: PersistentVolume
   apiVersion: v1
   metadata:
     name: <local-block-pv10>
     annotations:
   spec:
     local:
       path: </dev/loop10> 1
     capacity:
       storage: <2Gi>
     volumeMode: Block 2
     storageClassName: local 3
     accessModes:
       - ReadWriteOnce
     persistentVolumeReclaimPolicy: Delete
     nodeAffinity:
       required:
         nodeSelectorTerms:
         - matchExpressions:
           - key: kubernetes.io/hostname
             operator: In
             values:
             - <node01> 4

   1

   节点上的 loop 设备路径。

   2

   将其指定为块 PV。

   3

   可选：为 PV 设置存储类。如果省略此项，将使用默认集群。

   4

   挂载块设备的节点。

5. 创建块 PV。

   # oc create -f <local-block-pv10.yaml>1

   1

   上一步中创建的持久性卷的文件名。

流程

1. 如果您的数据源需要身份验证，请创建一个 Secret 清单，指定数据源凭证，并将其保存为 endpoint-secret.yaml ：

   apiVersion: v1
   kind: Secret
   metadata:
     name: endpoint-secret 1
     labels:
       app: containerized-data-importer
   type: Opaque
   data:
     accessKeyId: "" 2
     secretKey:   "" 3

   1

   指定 Secret 的名称。

   2

   指定以 Base64 编码的密钥 ID 或用户名。

   3

   指定以 Base64 编码的 secret 密钥或密码。

2. 应用 Secret 清单：

   $ oc apply -f endpoint-secret.yaml

3. 创建 DataVolume 清单，为虚拟机镜像指定数据源，并为 storage.volumeMode 指定 Block。

   apiVersion: cdi.kubevirt.io/v1beta1
   kind: DataVolume
   metadata:
     name: import-pv-datavolume 1
   spec:
     storageClassName: local 2
       source:
         http:
           url: "https://mirror.arizona.edu/fedora/linux/releases/35/Cloud/x86_64/images/Fedora-Cloud-Base-35-1.2.x86_64.qcow2" 3
           secretRef: endpoint-secret 4
     storage:
       volumeMode: Block 5
       resources:
         requests:
           storage: 10Gi

   1

   指定数据卷的名称。

   2

   可选：设置存储类，或忽略此项，接受集群默认值。

   3

   指定要导入的镜像的 HTTP 或 HTTPS URL。

   4

   如果您为数据源创建 Secret，则需要此项。

   5

   对于已知的存储置备程序，会自动检测到卷模式和访问模式。否则，指定 Block。

4. 创建数据卷来导入虚拟机镜像：

   $ oc create -f import-pv-datavolume.yaml

流程

1. 创建 ClusterRole 清单：

   apiVersion: rbac.authorization.k8s.io/v1
   kind: ClusterRole
   metadata:
     name: <datavolume-cloner> 1
   rules:
   - apiGroups: ["cdi.kubevirt.io"]
     resources: ["datavolumes/source"]
     verbs: ["*"]

   1

   集群角色的唯一名称。

2. 在集群中创建集群角色：

   $ oc create -f <datavolume-cloner.yaml> 1

   1

   上一步中创建的 ClusterRole 清单的文件名。

3. 创建应用于源和目标命名空间的 RoleBinding 清单，并引用上一步中创建的集群角色。

   apiVersion: rbac.authorization.k8s.io/v1
   kind: RoleBinding
   metadata:
     name: <allow-clone-to-user> 1
     namespace: <Source namespace> 2
   subjects:
   - kind: ServiceAccount
     name: default
     namespace: <Destination namespace> 3
   roleRef:
     kind: ClusterRole
     name: datavolume-cloner 4
     apiGroup: rbac.authorization.k8s.io

   1

   角色绑定的唯一名称。

   2

   源数据卷的命名空间。

   3

   数据卷克隆到的命名空间。

   4

   上一步中创建的集群角色的名称。

4. 在集群中创建角色绑定：

   $ oc create -f <datavolume-cloner.yaml> 1

   1

   上一步中创建的 RoleBinding 清单的文件名。