流程

1. 确定您处于正确的项目中。如果不是，则点击 Project 列表，然后选择适当项目。
2. 点击 Workloads → Virtual Machines 以显示该项目中的虚拟机。
3. 选择虚拟机。
4. 在 Overview 选项卡中，点 virt-launcher-<vm-name> pod。
5. 点击 Terminal 选项卡。如果终端空白，则选择终端，然后按任意键启动连接。

流程

1. 在容器原生虚拟化控制台中，点击 Workloads → Virtual Machines。
2. 选择虚拟机。
3. 点击 Consoles。默认会打开 VNC 控制台。
4. 点击 VNC Console 下拉菜单并选择 Serial Console。

流程

1. 在容器原生虚拟化控制台中，点击 Workloads → Virtual Machines。
2. 选择虚拟机。
3. 点击 Consoles。默认会打开 VNC 控制台。

流程

1. 在容器原生虚拟化控制台中，点击 Workloads → Virtual Machines。
2. 选择 Windows 虚拟机。
3. 点击 Consoles 选项卡。
4. 点击 Consoles 列表并选择 Desktop Viewer。
5. 在 Network Interface 列表中，选择第 2 层 vNIC。
6. 点击 Launch Remote Desktop 下载 console.rdp 文件。

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

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

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

流程

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

   $ virtctl expose vm <fedora-vm> --port=20022 --target-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>        20022:32551/TCP   6s

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

3. 通过 SSH 登录虚拟机实例。使用节点的 ipAddress 以及您在上一步中发现的端口：

   $ ssh username@<node_IP_address> -p 32551

流程

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

   $ virtctl vnc <VMI>

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

   $ virtctl vnc <VMI> -v 4

流程

1. 以具有访问令牌的用户身份通过 oc CLI 工具登录容器原生虚拟化集群。

   $ 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. 编辑 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. 在集群上配置 PXE 网络：

   1. 为 PXE 网络 pxe-net-conf 创建 NetworkAttachmentDefinition 文件：

      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"
              },
              {
                "type": "cnv-tuning" 1
              }
            ]
          }'

      1

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

      注意

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

2. 使用您在上一步中创建的文件来创建 NetworkAttachmentDefinition 对象：

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

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

   1. 如果 PXE 服务器需要，请指定网络和 MAC 地址。如果未指定 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. 指定该网络连接到之前创建的 NetworkAttachmentDefinition。在此场景中，<pxe-net> 连接到名为 <pxe-net-conf> 的 NetworkAttachmentDefinition：

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

4. 创建虚拟机实例：

   $ oc create -f vmi-pxe-boot.yaml
     virtualmachineinstance.kubevirt.io "vmi-pxe-boot" created

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

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

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

   $ virtctl vnc vmi-pxe-boot

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

8. 登录虚拟机实例：

   $ virtctl console vmi-pxe-boot

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

   $ ip addr
   ...
   3. eth1: <BROADCAST,MULTICAST> mtu 1500 qdisc noop state DOWN group default qlen 1000
      link/ether de:00:00:00:00:de brd ff:ff:ff:ff:ff:ff

流程

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

流程

1. 确定您处于正确的命名空间中。ConfigMap 只有位于相同命名空间中才可被 DataVolume 引用。

   $ oc get ns

2. 创建 ConfigMap：

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

流程

1. 确定用于托管您要导入的虚拟磁盘镜像的 HTTP 文件服务器。您需要一个正确格式的完整 URL：

   • http://www.example.com/path/to/data

2. 如果您的数据源需要身份验证凭证，请编辑 endpoint-secret.yaml 文件，并在集群中应用更新的配置：

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

   1

   可选：您的密钥或用户名，base64 编码

   2

   可选：您的 secret 或密码，base64 编码

   $ oc apply -f endpoint-secret.yaml

3. 编辑虚拟机配置文件，为您要导入的镜像指定数据源。在本例中，导入了一个 Fedora 镜像：

   apiVersion: kubevirt.io/v1alpha3
   kind: VirtualMachine
   metadata:
     creationTimestamp: null
     labels:
       kubevirt.io/vm: vm-fedora-datavolume
     name: vm-fedora-datavolume
   spec:
     dataVolumeTemplates:
     - metadata:
         creationTimestamp: null
         name: fedora-dv
       spec:
         pvc:
           accessModes:
           - ReadWriteOnce
           resources:
             requests:
               storage: 2Gi
           storageClassName: local
         source:
           http:
             url: https://download.fedoraproject.org/pub/fedora/linux/releases/28/Cloud/x86_64/images/Fedora-Cloud-Base-28-1.1.x86_64.qcow2 1
             secretRef: "" 2
             certConfigMap: "" 3
       status: {}
     running: false
     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: 64M
         terminationGracePeriodSeconds: 0
         volumes:
         - dataVolume:
             name: fedora-dv
           name: datavolumedisk1
   status: {}

   1

   您要导入的镜像的 HTTP 源。

   2

   secretRef 参数是可选的。

   3

   与使用自签名证书或者由系统 CA 捆绑包没有签名的证书的服务器进行通信需要 certConfigMap。所引用的 ConfigMap 必须与 DataVolume 位于相同命名空间中。

4. 创建虚拟机：

   $ oc create -f vm-<name>-datavolume.yaml

   注意

   oc create 命令创建 DataVolume 和虚拟机。CDI 控制器使用正确注解创建底层 PVC，导入过程随即开始。导入完成后，DataVolume 状态变为 Succeeded，虚拟机可以启动。

   DataVolume 置备在后台进行，因此无需监控。您可以启动虚拟机，该虚拟机将在导入完成后才会运行。

可选验证步骤

1. 运行 oc get pods 并查找导入程序 Pod。该 Pod 会从指定的 URL 下载镜像，并将其存储在置备的 PV 上。

2. 监控 DataVolume 的状态，直至状态显示为 Succeeded。

   $ oc describe dv <data-label> 1

   1

   在虚拟机配置文件中指定的 DataVolume 的数据标签。

3. 要验证置备是否已完成以及 VMI 是否已启动，请尝试访问其串行控制台：

   $ 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 设置一个 StorageClass。如果省略此项，将使用默认集群。

   4

   挂载块设备的节点。

5. 创建块 PV。

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

   1

   上一步中创建的 PersistentVolume 的文件名。

流程

1. 如果您的数据源需要身份验证凭证，请编辑 endpoint-secret.yaml 文件，并在集群中应用更新的配置。

   1. 利用您首选的文本编辑器来编辑 endpoint-secret.yaml 文件：

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

      1

      可选：您的密钥或用户名，base64 编码

      2

      可选：您的 secret 或密码，base64 编码

   2. 更新 secret：

      $ oc apply -f endpoint-secret.yaml

2. 创建 DataVolume 配置，用于指定要导入的镜像的数据源和 volumeMode: Block，以便使用可用块 PV。

   apiVersion: cdi.kubevirt.io/v1alpha1
   kind: DataVolume
   metadata:
     name: <import-pv-datavolume> 1
   spec:
     storageClassName: local 2
     source:
         http:
            url: <http://download.fedoraproject.org/pub/fedora/linux/releases/28/Cloud/x86_64/images/Fedora-Cloud-Base-28-1.1.x86_64.qcow2> 3
            secretRef: <endpoint-secret> 4
     pvc:
       volumeMode: Block 5
       accessModes:
         - ReadWriteOnce
       resources:
         requests:
           storage: <2Gi>

   1

   DataVolume 的名称。

   2

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

   3

   要导入的镜像的 HTTP 源。

   4

   仅在数据源需要身份验证时才需要。

   5

   导入到块 PV 时需要。

3. 创建 DataVolume 以导入虚拟机镜像。

   $ oc create -f <import-pv-datavolume.yaml>1

   1

   上一步中创建的文件名 DataVolume。

流程

1. 创建并导航到临时目录：

   $ mkdir /tmp/<dir_name> && cd /tmp/<dir_name>

2. 在一个浏览器中，进入 VMware code 并点 SDKs。
3. 在 Compute Virtualization 下，点 Virtual Disk Development Kit(VDDK)。
4. 选择最新的 VDDK 版本，点 Download，然后在临时目录中保存 VDDK 归档。

5. 提取 VDDK 归档：

   $ tar -xzf VMware-vix-disklib-<version>.x86_64.tar.gz

6. 创建 Dockerfile：

   $ cat > Dockerfile <<EOF
   FROM busybox:latest
   COPY vmware-vix-disklib-distrib /vmware-vix-disklib-distrib
   RUN mkdir -p /opt
   ENTRYPOINT ["cp", "-r", "/vmware-vix-disklib-distrib", "/opt"]
   EOF

7. 构建镜像：

   $ podman build . -t <registry_route_or_server_path>/vddk:<tag> 1

   1

   指定您的镜像 registry:

   • 对于内部 OpenShift Container Platform registry，请使用内部 registry 路由，如 image-registry.openshift-image-registry.svc:5000/openshift/vddk:<tag>。
   • 对于外部 registry，指定服务器名称、路径和标签。例如 server.example.com:5000/vddk:<tag>。

8. 将镜像推送至 registry：

   $ podman push <registry_route_or_server_path>/vddk:<tag>

9. 确保镜像可以被 OpenShift Container PlatformO 环境访问。

10. 编辑 openshift-cnv 项目中的 v2v- vmware ConfigMap：

    $ oc edit configmap v2v-vmware -n openshift-cnv

11. 将 vddk-init-image 参数添加到 data 小节中：

    ...
    data:
      vddk-init-image: <registry_route_or_server_path>/vddk:<tag>

流程

1. 在容器原生虚拟化 web 控制台中，点击 Workloads → Virtual Machines。
2. 点击 Create Virtual Machine 并选择 Import with Wizard。

3. 在 General 屏幕中，执行以下步骤：

   1. 从 Provider 列表中选择 VMware。

   2. 选择 Connect to New Instance 或从 vCenter instance 列表中选择保存的 vCenter 实例。

      • 如果您选择 Connect to New Instance，请填写 vCenter hostname、Username 和 Password。
      • 如果您选择了一个保存的 vCenter 实例，向导将使用保存的凭证连接到 vCenter 实例。
   3. 从 VM or Template to Import 列表中选择要导入的虚拟机或模板。
   4. 选择操作系统。

   5. 从 Flavor 列表中选择现有类别或 Custom。

      如果您选择 Custom，请指定 Memory (GB) 和 CPUs。

   6. 选择 Workload Profile。
   7. 如果虚拟机名称已经在命名空间中被另一个虚拟机使用，请更新该名称。
   8. 点 Next。

4. 在 Networking 屏幕中，执行以下步骤：

   1. 点击网络接口 的 Options 菜单并选择 Edit。

   2. 输入一个有效的网络接口名称。

      名称可包含小写字母 (a-z)、数字 (0-9) 和连字符 (-)，最多 253 个字符。第一个和最后一个字符必须为字母数字。名称不得包含大写字母、空格、句点 (.) 或特殊字符。

   3. 选择网络接口型号。
   4. 选择网络定义。
   5. 选择网络接口类型。
   6. 输入 MAC 地址。
   7. 点击 Save，然后点击 Next。

5. 在 Storage 屏幕中，执行以下步骤：

   1. 点击磁盘 的 Options 菜单并选择 Edit。

   2. 输入有效名称。

      名称可包含小写字母 (a-z)、数字 (0-9) 和连字符 (-)，最多 253 个字符。第一个和最后一个字符必须为字母数字。名称不得包含大写字母、空格、句点 (.) 或特殊字符。

   3. 选择接口类型。

   4. 选择存储类。

      如果您没有选择存储类，容器原生虚拟化将使用默认存储类来创建虚拟机。

   5. 点击 Save，然后点击 Next。
6. 在 Advanced 屏幕中，如果您使用 cloud-init，请输入 Hostname 和 Authorized SSH Keys。
7. 点 Next。

8. 检查您的设置并点击 Create Virtual Machine。

   此时会显示 Successfully created virtual machine 消息以及为虚拟机创建的资源列表。关闭电源的虚拟机会出现在 Workloads → Virtual Machines 中。

9. 点击 See virtual machine details 查看导入的虚拟机的仪表板。

   如果发生错误，请执行以下步骤：

   1. 点击 Workloads → Pods。
   2. 点击 Conversion Pod，例如 kubevirt-v2v-conversion-rhel7-mini-1-27b9h。
   3. 点击 Logs 并检查错误消息。

流程

1. 登录虚拟机。
2. 进入 /etc/sysconfig/network-scripts 目录。

3. 将网络配置文件名称改为 ifcfg-eth0：

   $ mv vmnic0 ifcfg-eth0 1

   1

   额外网络配置文件按顺序编号，例如：ifcfg-eth1、ifcfg-eth2。

4. 更新网络配置文件中的 NAME 和 DEVICE 参数：

   NAME=eth0
   DEVICE=eth0

5. 重启网络：

   $ systemctl restart network

1. 获取 Conversion Pod 名称：

   $ oc get pods -n <project> | grep v2v 1
   kubevirt-v2v-conversion-f66f7d-zqkz7            1/1     Running     0          4h49m

   1

   指定导入的虚拟机的项目。

2. 获取 Conversion Pod 日志：

   $ oc logs kubevirt-v2v-conversion-f66f7d-zqkz7 -f -n <project>

流程

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

   ClusterRole 的唯一名称。

2. 在集群中创建 ClusterRole：

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

   1

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

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

   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

   RoleBinding 的唯一名称。

   2

   源 DataVolume 的命名空间。

   3

   将 DataVolume 克隆到的命名空间。

   4

   上一步中创建的 ClusterRole 的名称。

4. 在集群中创建 RoleBinding：

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

   1

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

流程

1. 检查您要克隆的虚拟机磁盘，以识别关联 PVC 的名称和命名空间。

2. 为 DataVolume 对象创建 YAML 文件，用于指定新 DataVolume 的名称、源 PVC 的名称和命名空间，以及新 DataVolume 的大小。

   例如：

   apiVersion: cdi.kubevirt.io/v1alpha1
   kind: DataVolume
   metadata:
     name: <cloner-datavolume> 1
   spec:
     source:
       pvc:
         namespace: "<source-namespace>" 2
         name: "<my-favorite-vm-disk>" 3
     pvc:
       accessModes:
         - ReadWriteOnce
       resources:
         requests:
           storage: <2Gi> 4

   1

   新 DataVolume 的名称。

   2

   源 PVC 所在的命名空间。

   3

   源 PVC 的名称。

   4

   新 DataVolume 的大小。您必须分配足够空间，否则克隆操作会失败。其大小不得低于源 PVC。

3. 通过创建 DataVolume 开始克隆 PVC：

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

   注意

   在 PVC 就绪前，DataVolume 会阻止虚拟机启动，以便您可以在 PVC 克隆期间创建引用新 DataVolume 的虚拟机。

流程

1. 检查您要克隆的虚拟机，以识别关联 PVC 的名称和命名空间。

2. 为 VirtualMachine 对象创建 YAML 文件。以下虚拟机示例克隆 my-favorite-vm-disk，该磁盘位于 source-name 命名空间中。名为 favorite-clone 的 2Gi DataVolume 从 my-favorite-vm-disk 创建而成。

   例如：

   apiVersion: kubevirt.io/v1alpha3
   kind: VirtualMachine
   metadata:
     labels:
       kubevirt.io/vm: vm-dv-clone
     name: vm-dv-clone 1
   spec:
     running: false
     template:
       metadata:
         labels:
           kubevirt.io/vm: vm-dv-clone
       spec:
         domain:
           devices:
             disks:
             - disk:
                 bus: virtio
               name: root-disk
           resources:
             requests:
               memory: 64M
         volumes:
         - dataVolume:
             name: favorite-clone
           name: root-disk
     dataVolumeTemplates:
     - metadata:
         name: favorite-clone
       spec:
         pvc:
           accessModes:
           - ReadWriteOnce
           resources:
             requests:
               storage: 2Gi
         source:
           pvc:
             namespace: "source-namespace"
             name: "my-favorite-vm-disk"

   1

   要创建的虚拟机。

3. 使用 PVC 克隆的 DataVolume 创建虚拟机：

   $ oc create -f <vm-clone-datavolumetemplate>.yaml

流程

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 设置一个 StorageClass。如果省略此项，将使用默认集群。

   4

   挂载块设备的节点。

5. 创建块 PV。

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

   1

   上一步中创建的 PersistentVolume 的文件名。

流程

1. 检查您要克隆的虚拟机磁盘，以识别关联 PVC 的名称和命名空间。

2. 为 DataVolume 对象创建 YAML 文件，用于指定新 DataVolume 的名称、源 PVC 的名称和命名空间、volumeMode: Block（以使用可用块 PV），以及新 DataVolume 的大小。

   例如：

   apiVersion: cdi.kubevirt.io/v1alpha1
   kind: DataVolume
   metadata:
     name: <cloner-datavolume> 1
   spec:
     source:
       pvc:
         namespace: "<source-namespace>" 2
         name: "<my-favorite-vm-disk>" 3
     pvc:
       accessModes:
         - ReadWriteOnce
       resources:
         requests:
           storage: <2Gi> 4
       volumeMode: Block 5

   1

   新 DataVolume 的名称。

   2

   源 PVC 所在的命名空间。

   3

   源 PVC 的名称。

   4

   新 DataVolume 的大小。您必须分配足够空间，否则克隆操作会失败。其大小不得低于源 PVC。

   5

   指定目标为一个块 PV

3. 通过创建 DataVolume 开始克隆 PVC：

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

   注意

   在 PVC 就绪前，DataVolume 会阻止虚拟机启动，以便您可以在 PVC 克隆期间创建引用新 DataVolume 的虚拟机。

流程

1. 编辑虚拟机配置文件的 interfaces 规格：

   kind: VirtualMachine
   spec:
     domain:
       devices:
         interfaces:
           - name: red
             masquerade: {} 1
             ports:
               - port: 80 2
     networks:
     - name: red
       pod: {}

   1

   使用伪装模式进行连接

   2

   允许通过 80 端口传入流量

2. 创建虚拟机：

   $ oc create -f <vm-name>.yaml

流程

1. 在容器原生虚拟化控制台的正确项目中，点击 Workloads → Virtual Machines。
2. 选择虚拟机。
3. 点击 Network Interfaces 以显示已附加到虚拟机的 NIC。
4. 点击 Create Network Interface 在列表中创建新插槽。
5. 填写新 NIC 的 Name、Model、Network、Type 和 MAC Address。
6. 点击 ✓ 按钮保存并附加 NIC 到虚拟机。

流程

1. 通过其中一个控制台或通过 SSH 访问虚拟机命令行。

2. 在虚拟机上安装 QEMU 客户机代理：

   $ yum install -y qemu-guest-agent

3. 启动 QEMU 客户机代理服务：

   $ systemctl start qemu-guest-agent

4. 确保服务持久：

   $ systemctl enable qemu-guest-agent

1. 通过输入以下命令验证客户机代理是否已安装并正在运行：

   $ systemctl status qemu-guest-agent

2. 如果客户机代理没有安装和运行，请在虚拟机上安装并运行客户机代理。

流程

1. 在容器原生虚拟化控制台中，点击 Workloads → Virtual Machines。
2. 点击虚拟机名称以打开 Virtual Machine Overview 屏幕。

流程

1. 创建 MachineConfig 文件。例如：

   $ touch machineconfig.yaml

2. 编辑该文件，确保包含希望 hostpath 置备程序在其中创建 PV 的目录。例如：

   apiVersion: machineconfiguration.openshift.io/v1
   kind: MachineConfig
   metadata:
     name: 50-set-selinux-for-hostpath-provisioner
     labels:
       machineconfiguration.openshift.io/role: worker
   spec:
     config:
       ignition:
         version: 2.2.0
       systemd:
         units:
           - contents: |
               [Unit]
               Description=Set SELinux chcon for hostpath provisioner
               Before=kubelet.service
   
               [Service]
               ExecStart=/usr/bin/chcon -Rt container_file_t <path/to/backing/directory> 1
   
               [Install]
               WantedBy=multi-user.target
             enabled: true
             name: hostpath-provisioner.service

   1

   指定希望置备程序在其中创建 PV 的后备目录。

3. 创建 MachineConfig 对象：

   $ oc create -f machineconfig.yaml -n <namespace>

流程

1. 创建 HostPathProvisioner 自定义资源文件。例如：

   $ touch hostpathprovisioner_cr.yaml

2. 编辑该文件，确保 spec.pathConfig.path 值是您希望 hostpath 置备程序在其中创建 PV 的目录。例如：

   apiVersion: hostpathprovisioner.kubevirt.io/v1alpha1
   kind: HostPathProvisioner
   metadata:
     name: hostpath-provisioner
   spec:
     imagePullPolicy: IfNotPresent
     pathConfig:
       path: "</path/to/backing/directory>" 1
       useNamingPrefix: "false" 2

   1

   指定希望置备程序在其中创建 PV 的后备目录。

   2

   如果要使用绑定到所创建的 PV 的 PersistentVolumeClaim (PVC) 名称作为目录名的前缀，请将该值更改为 true。

   注意

   如果您没有创建后备目录，则置备程序会尝试为您创建该目录。如果您没有应用 container_file_t SELinux 上下文，这会导致 Permission denied。

3. 在 openshift-cnv 命名空间中创建自定义资源：

   $ oc create -f hostpathprovisioner_cr.yaml -n openshift-cnv

流程

1. 创建用于定义存储类的 YAML 文件。例如：

   $ touch storageclass.yaml

2. 编辑该文件。例如：

   apiVersion: storage.k8s.io/v1
   kind: StorageClass
   metadata:
     name: hostpath-provisioner 1
   provisioner: kubevirt.io/hostpath-provisioner
   reclaimPolicy: Delete 2
   volumeBindingMode: WaitForFirstConsumer 3

   1

   您可以通过更改此值来选择性地重命名存储类。

   2

   两个可能的 reclaimPolicy 值为 Delete 和 Retain。如果您没有指定值，则存储类默认为 Delete。

   3

   volumeBindingMode 值决定何时发生动态置备和卷绑定。指定 WaitForFirstConsumer，将 PV 的绑定和置备延迟到创建使用 PersistentVolumeClaim (PVC) 的 Pod 后。这样可确保 PV 满足 Pod 的调度要求。

3. 创建 StorageClass 对象：

   $ oc create -f storageclass.yaml

流程

1. 创建 DataVolume 配置，用于指定 spec: source: upload{}：

   apiVersion: cdi.kubevirt.io/v1alpha1
   kind: DataVolume
   metadata:
     name: <upload-datavolume> 1
   spec:
     source:
         upload: {}
     pvc:
       accessModes:
         - ReadWriteOnce
       resources:
         requests:
           storage: <2Gi> 2

   1

   DataVolume 的名称。

   2

   DataVolume 的大小请确定这个值大于或等于您要上传的磁盘的大小。

2. 运行以下命令来创建 DataVolume：

   $ oc create -f <upload-datavolume>.yaml

流程

1. 确定以下各项：

   • 要使用的上传 DataVolume 的名称。如果此 DataVolume 不存在，则会自动创建。
   • 在上传过程中创建 DataVolume 的大小。大小必须大于或等于磁盘镜像的大小。
   • 要上传的虚拟机磁盘镜像的文件位置

2. 运行 virtctl image-upload 命令上传磁盘镜像。指定您在上一步中获得的参数。例如：

   $ virtctl image-upload dv <datavolume_name> \ 1
   --size=<datavolume_size> \ 2
   --image-path=</path/to/image> \ 3

   1

   DataVolume 的名称。

   2

   DataVolume 的大小例如： --size=500Mi, --size=1G

   3

   虚拟机磁盘镜像的文件路径。

   注意

   • 如果您不想创建新 DataVolume，请省略 --size 参数，并包含 --no-create 标志。
   • 若要在使用 HTTPS 时允许不安全的服务器连接，请使用 --insecure 参数。注意，在使用 --insecure 标志时，不会验证上传端点的真实性。

3. 可选。要验证 DataVolume 是否已创建，请运行以下命令来查看所有 DataVolume 对象：

   $ oc get dvs

流程

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 设置一个 StorageClass。如果省略此项，将使用默认集群。

   4

   挂载块设备的节点。

5. 创建块 PV。

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

   1

   上一步中创建的 PersistentVolume 的文件名。

流程

1. 创建 DataVolume 配置，用于指定 spec: source: upload{}：

   apiVersion: cdi.kubevirt.io/v1alpha1
   kind: DataVolume
   metadata:
     name: <upload-datavolume> 1
   spec:
     source:
         upload: {}
     pvc:
       accessModes:
         - ReadWriteOnce
       resources:
         requests:
           storage: <2Gi> 2

   1

   DataVolume 的名称。

   2

   DataVolume 的大小请确定这个值大于或等于您要上传的磁盘的大小。

2. 运行以下命令来创建 DataVolume：

   $ oc create -f <upload-datavolume>.yaml

流程

1. 确定以下各项：

   • 要使用的上传 DataVolume 的名称。如果此 DataVolume 不存在，则会自动创建。
   • 在上传过程中创建 DataVolume 的大小。大小必须大于或等于磁盘镜像的大小。
   • 要上传的虚拟机磁盘镜像的文件位置

2. 运行 virtctl image-upload 命令上传磁盘镜像。指定您在上一步中获得的参数。例如：

   $ virtctl image-upload dv <datavolume_name> \ 1
   --size=<datavolume_size> \ 2
   --image-path=</path/to/image> \ 3

   1

   DataVolume 的名称。

   2

   DataVolume 的大小例如： --size=500Mi, --size=1G

   3

   虚拟机磁盘镜像的文件路径。

   注意

   • 如果您不想创建新 DataVolume，请省略 --size 参数，并包含 --no-create 标志。
   • 若要在使用 HTTPS 时允许不安全的服务器连接，请使用 --insecure 参数。注意，在使用 --insecure 标志时，不会验证上传端点的真实性。

3. 可选。要验证 DataVolume 是否已创建，请运行以下命令来查看所有 DataVolume 对象：

   $ oc get dvs

流程

1. 在节点上创建新本地 PV，或使用已有的本地 PV:

   • 创建包含 nodeAffinity.nodeSelectorTerms 参数的本地 PV。以下 manifest 在 node01 上创建了一个 10Gi 的本地 PV

     kind: PersistentVolume
     apiVersion: v1
     metadata:
       name: <destination-pv> 1
       annotations:
     spec:
       accessModes:
       - ReadWriteOnce
       capacity:
         storage: 10Gi 2
       local:
         path: /mnt/local-storage/local/disk1 3
       nodeAffinity:
         required:
           nodeSelectorTerms:
           - matchExpressions:
             - key: kubernetes.io/hostname
               operator: In
               values:
               - node01 4
       persistentVolumeReclaimPolicy: Delete
       storageClassName: local
       volumeMode: Filesystem

     1

     PV 的名称。

     2

     PV 的大小。您必须分配足够空间，否则克隆操作会失败。其大小不得低于源 PVC。

     3

     节点上的挂载路径。

     4

     要创建 PV 的节点的名称。

   • 已存在于节点上的一个 PV。您可以通过查看其配置中的 nodeAffinity 字段来标识置备 PV 的节点：

     $ oc get pv <destination-pv> -o yaml

     以下输出显示 PV 位于 node01:

     ...
     spec:
       nodeAffinity:
         required:
           nodeSelectorTerms:
           - matchExpressions:
             - key: kubernetes.io/hostname 1
               operator: In
               values:
               - node01 2
     ...

     1

     Kubernetes.io/hostname 使用节点主机名来选择节点。

     2

     节点的主机名称。

2. 为 PV 添加唯一标签：

   $ oc label pv <destination-pv> node=node01

3. 创建 DataVolume 清单来引用以下内容：

   • 虚拟机的 PVC 名称和命名空间。
   • 应用上一步中的 PV 标签。

   • 目标 PV 的大小。

     apiVersion: cdi.kubevirt.io/v1alpha1
     kind: DataVolume
     metadata:
       name: <clone-datavolume> 1
     spec:
       source:
         pvc:
           name: "<source-vm-disk>" 2
           namespace: "<source-namespace>" 3
       pvc:
         accessModes:
           - ReadWriteOnce
         selector:
           matchLabels:
             node: node01 4
         resources:
           requests:
             storage: <10Gi> 5

     1

     新 DataVolume 的名称。

     2

     源 PVC 的名称。如果您不知道 PVC 名称，您可以在虚拟机配置中找到它： spec.volumes.persistentVolumeClaim.claimName。

     3

     源 PVC 所在的命名空间。

     4

     应用于上一步中 PV 的标签。

     5

     目标 PV 的大小。

4. 通过将 DataVolume 清单应用到集群来开始克隆操作：

   $ oc apply -f <clone-datavolume.yaml>

流程

1. 编辑 DataVolume 配置文件：

   apiVersion: cdi.kubevirt.io/v1alpha1
   kind: DataVolume
   metadata:
     name: blank-image-datavolume
   spec:
     source:
         blank: {}
     pvc:
       # Optional: Set the storage class or omit to accept the default
       # storageClassName: "hostpath"
       accessModes:
         - ReadWriteOnce
       resources:
         requests:
           storage: 500Mi

2. 运行以下命令，创建空白磁盘镜像：

   $ oc create -f <blank-image-datavolume>.yaml

流程

1. 从侧边菜单中点 Workloads → Config Maps。
2. 在 Project 列表中，选择 openshift-cnv。
3. 点击 kubevirt-storage-class-defaults 打开 Config Map Overview。
4. 点击 YAML 选项卡以显示可编辑的配置。

5. 使用适合您的底层存储的存储配置更新 data 值：

   ...
   data:
     accessMode: ReadWriteOnce 1
     volumeMode: Filesystem 2
     <new>.accessMode: ReadWriteMany 3
     <new>.volumeMode: Block 4

   1

   默认 accessMode 是 ReadWriteOnce。

   2

   默认 volumeMode 是 Filesystem。

   3

   如果您为存储类添加一个访问模式，请将参数的 <new> 部分替换为存储类名称。

   4

   如果您为存储类添加一个卷模式，请将参数的 <new> 部分替换为存储类名称。

6. 点 Save 以更新 ConfigMap。

流程

1. 使用 oc edit 编辑 ConfigMap:

   $ oc edit configmap kubevirt-storage-class-defaults -n openshift-cnv

2. 更新 ConfigMap 的 data 值：

   ...
   data:
     accessMode: ReadWriteOnce 1
     volumeMode: Filesystem 2
     <new>.accessMode: ReadWriteMany 3
     <new>.volumeMode: Block 4

   1

   默认 accessMode 是 ReadWriteOnce。

   2

   默认 volumeMode 是 Filesystem。

   3

   如果为存储类添加了访问模式，需要将参数的 <new> 部分替换为存储类名称。

   4

   如果您为存储类添加一个卷模式，请将参数的 <new> 部分替换为存储类名称。

3. 保存并退出编辑器以更新 ConfigMap。