专栏首页CNCF在KubeVirt使用Intel vGPU

在KubeVirt使用Intel vGPU

CNCF Cloud Native Survey 2021:第1部分现在开始了!

问卷链接(https://www.surveymonkey.com/r/GRMM6Y2)


作者:Mark DeNeve

介绍

图形用户界面(GUI)在过去几年中已经出现,大多数现代桌面环境都希望某种形式的 GPU 加速,以便给你一个无缝的用户体验。如果你试过在 KubeVirt 上运行像 Windows 10 这样的东西,你可能会注意到桌面体验有点慢。这是由于 Windows 10 对 GPU 加速的依赖。此外,许多应用程序也正在利用 GPU 加速,它甚至可以用于基于 web 的应用程序,如“FishGL”:

如果没有 GPU 硬件加速,将极大地影响虚拟机的用户体验。

从嵌入英特尔图形处理器的第五代 Intel Core 处理器开始,可以在多个虚拟机之间共享图形处理器。在 Linux 中,GPU 的这种共享通常是通过使用中介 GPU 设备(也称为 vGPU)来实现的。KubeVirt 从 2019 年 v0.22.0 版本开始就支持 GPU 的使用,包括 GPU 直通(passthrough)和 vGPU。这种支持是以一个特定的供应商为中心的,并且只适用于昂贵的企业级卡,并且需要额外的许可。KubeVirt 0.40[1]支持检测和分配基于 Intel 的 vGPU。从 4.19 版本开始,Linux 内核就支持创建这些虚拟化 Intel GPU。这对你来说意味着什么?你不再需要额外的驱动程序或许可证来测试 GPU 加速的虚拟机。

你可以创建的 Intel vGPU 的总数取决于你的特定硬件以及对更改显卡孔径大小和 BIOS 中共享显卡内存的支持。有关此的更多细节,请参阅英特尔 GVTg wiki 中的创建 vGPU(仅 KVMGT)[2]。最小配置的设备通常可以制造至少两个 vGPU 设备。

你可以在运行 KubeVirt v0.40.0 或更高版本的任何 Kubernetes 集群上复制这项工作,但是加载内核模块和启用虚拟设备所需的步骤将根据 Kubernetes 集群所运行的底层操作系统而有所不同。为了演示如何启用该特性,我们将使用一个使用 Fedora 32 和 minikube 构建的一体化 Kubernetes 集群。

请注意:这篇博文是一个更高级的主题,并且假设你对 Linux 和 Kubernetes 有一定的了解。

先决条件

在我们开始之前,你需要一些东西来使用 Intel GPU:

  • 一台工作站或服务器,具有第五代或更高的 Intel Core 处理器,或 E3_v4 或更高的 Xeon 处理器,并拥有足够的内存来虚拟化一个或多个虚拟机
  • 预装的 Fedora 32 工作站,“/”文件系统中至少有 50Gb 的空闲空间
  • 以下软件:
    • minikube - 参见minikube start[3]
    • virtctl — 参见KubeVirt releases[4]
    • kubectl — 参见在 Linux 上安装和设置 kubectl[5]
    • Windows 10 安装镜像文件 - 请参见下载 Windows 10 磁盘镜像文件[6]

Fedora 工作站的准备功夫

为了在 Fedora 32 上使用 minikube,我们将在整个演示中安装多个应用程序。此外,我们将配置工作站以使用 cgroups v1,我们将更新防火墙,以允许与 Kubernetes 集群以及任何托管应用程序进行适当的通信。最后,我们将根据 minikube 裸金属安装说明禁用 SELinux:

请注意:这篇文章假设我们从 Fedora 32 的新安装开始。如果使用已配置的现有 Fedora 32 工作站,可能会有一些软件冲突。

sudo dnf update -y
sudo dnf install -y pciutils podman podman-docker conntrack tigervnc rdesktop
sudo grubby --update-kernel=ALL --args="systemd.unified_cgroup_hierarchy=0"
# Setup firewall rules to allow inbound and outbound connections from your minikube cluster
sudo firewall-cmd --add-port=30000-65535/tcp --permanent
sudo firewall-cmd --add-port=30000-65535/udp --permanent
sudo firewall-cmd --add-port=10250-10252/tcp --permanent
sudo firewall-cmd --add-port=10248/tcp --permanent
sudo firewall-cmd --add-port=2379-2380/tcp --permanent
sudo firewall-cmd --add-port=6443/tcp --permanent
sudo firewall-cmd --add-port=8443/tcp --permanent
sudo firewall-cmd --add-port=9153/tcp --permanent
sudo firewall-cmd --add-service=dns --permanent
sudo firewall-cmd --add-interface=cni-podman0 --permanent
sudo firewall-cmd --add-masquerade --permanent
sudo vi /etc/selinux/config
# change the "SELINUX=enforcing" to "SELINUX=permissive"
sudo setenforce 0
sudo systemctl enable sshd --now

我们现在将安装 CRIO 运行时:

sudo dnf module enable -y cri-o:1.18
sudo dnf install -y cri-o cri-tools
sudo systemctl enable --now crio

准备 Intel vGPU 驱动

为了使用 Intel vGPU 驱动程序,我们需要对我们的一体化主机做一些更改。下面的命令假设你使用的是基于 Fedora 的主机。如果你使用的是不同的基本操作系统,请确保更新针对该特定发行版的命令。

以下命令将执行以下操作:

  • 加载 kvmgt 模块以启用 KVM 内的支持
  • 启动 i915 模块中的 gvt
  • 更新 Linux 内核以启用 Intel IOMMU
sudo sh -c "echo kvmgt > /etc/modules-load.d/gpu-kvmgt.conf"
sudo grubby --update-kernel=ALL --args="intel_iommu=on i915.enable_gvt=1"
sudo shutdown -r now

重启后检查,以确保已经加载了适当的内核模块:

$ sudo lsmod | grep kvmgt
kvmgt                  32768  0
mdev                   20480  2 kvmgt,vfio_mdev
vfio                   32768  3 kvmgt,vfio_mdev,vfio_iommu_type1
kvm                   798720  2 kvmgt,kvm_intel
i915                 2494464  4 kvmgt
drm                   557056  4 drm_kms_helper,kvmgt,i915

现在我们将创建我们的 vGPU 设备。这些虚拟设备是通过将 GUID 回送到由 Intel 驱动程序创建的系统设备来创建的。每次系统引导时都需要执行此操作。最简单的方法是使用在每次启动时都运行的 systemd 服务。在创建这个 systemd 服务之前,我们需要验证你的 Intel 显卡的 PCI ID。为此,我们将使用 lspci 命令:

$ sudo lspci
00:00.0 Host bridge: Intel Corporation Device 9b53 (rev 03)
00:02.0 VGA compatible controller: Intel Corporation Device 9bc8 (rev 03)
00:08.0 System peripheral: Intel Corporation Xeon E3-1200 v5/v6 / E3-1500 v5 / 6th/7th/8th Gen Core Processor Gaussian Mixture Model

请注意,在上面的输出中,英特尔图形处理器是在“00:02.0”上。现在创建/etc/systemd/system/gvtg-enable.service,但请确保更新适合你的机器的 PCI ID:

cat > ~/gvtg-enable.service << EOF
[Unit]
Description=Create Intel GVT-g vGPU

[Service]
Type=oneshot
ExecStart=/bin/sh -c "echo '56a4c4e2-c81f-4cba-82bf-af46c30ea32d' > /sys/devices/pci0000:00/0000:00:02.0/mdev_supported_types/i915-GVTg_V5_8/create"
ExecStart=/bin/sh -c "echo '973069b7-2025-406b-b3c9-301016af3150' > /sys/devices/pci0000:00/0000:00:02.0/mdev_supported_types/i915-GVTg_V5_8/create"
ExecStop=/bin/sh -c "echo '1' > /sys/devices/pci0000:00/0000:00:02.0/56a4c4e2-c81f-4cba-82bf-af46c30ea32d/remove"
ExecStop=/bin/sh -c "echo '1' > /sys/devices/pci0000:00/0000:00:02.0/973069b7-2025-406b-b3c9-301016af3150/remove"
RemainAfterExit=yes

[Install]
WantedBy=multi-user.target
EOF
sudo mv ~/gvtg-enable.service /etc/systemd/system/gvtg-enable.service
sudo systemctl enable gvtg-enable --now

请注意:上面的 systemd 服务将创建两个 vGPU 设备,你可以使用额外的唯一 guid 重复命令,最多 8 个 vGPU,如果你的硬件支持它。

我们可以通过查看/sys/devices/pci0000:00/0000:00:02.0/目录来验证 vGPU 设备是否已经创建。

$ ls -lsa /sys/devices/pci0000:00/0000:00:02.0/56a4c4e2-c81f-4cba-82bf-af46c30ea32d
total 0
lrwxrwxrwx. 1 root root    0 Apr 20 13:56 driver -> ../../../../bus/mdev/drivers/vfio_mdev
drwxr-xr-x. 2 root root    0 Apr 20 14:41 intel_vgpu
lrwxrwxrwx. 1 root root    0 Apr 20 14:41 iommu_group -> ../../../../kernel/iommu_groups/8
lrwxrwxrwx. 1 root root    0 Apr 20 14:41 mdev_type -> ../mdev_supported_types/i915-GVTg_V5_8
drwxr-xr-x. 2 root root    0 Apr 20 14:41 power
--w-------. 1 root root 4096 Apr 20 14:41 remove
lrwxrwxrwx. 1 root root    0 Apr 20 13:56 subsystem -> ../../../../bus/mdev
-rw-r--r--. 1 root root 4096 Apr 20 13:56 uevent

注意“mdev_type”指向“i915-GVTg_V5_8”,这将在稍后我们配置 KubeVirt 以检测 vGPU 时发挥作用。

用 minikube 安装 Kubernetes

现在我们将把 Kubernetes 安装到我们的 Fedora 工作站。Minikube[7]将帮助我们快速建立 Kubernetes 集群环境。我们将从 minikube 和 kubectl 的最新版本开始。

curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64
sudo install minikube-linux-amd64 /usr/local/bin/minikube
VERSION=$(minikube kubectl version | head -1 | awk -F', ' {'print $3'} | awk -F':' {'print $2'} | sed s/\"//g)
sudo install ${HOME}/.minikube/cache/linux/${VERSION}/kubectl /usr/local/bin

我们将使用 minikube 驱动程序“none”,它将直接安装 Kubernetes 到这台机器上。这将允许你维护通过重新引导构建的虚拟机的一个副本。在这篇文章的后面,我们将在“/data”中为虚拟机存储创建持久卷。如前所述,确保在“/data”中至少有 50Gb 的空闲空间来完成此设置。安装 minikube 需要几分钟时间。

$ sudo mkdir -p /data/winhd1-pv
$ sudo minikube start --driver=none --container-runtime=crio
?  minikube v1.19.0 on Fedora 32
✨  Using the none driver based on user configuration
?  Starting control plane node minikube in cluster minikube
?  Running on localhost (CPUs=12, Memory=31703MB, Disk=71645MB) ...
ℹ️  OS release is Fedora 32 (Workstation Edition)
?  Preparing Kubernetes v1.20.2 on Docker 20.10.6 ...
    ▪ Generating certificates and keys ...
    ▪ Booting up control plane ...
    ▪ Configuring RBAC rules ...
?  Configuring local host environment ...
?  Verifying Kubernetes components...
    ▪ Using image gcr.io/k8s-minikube/storage-provisioner:v5
?  Enabled addons: storage-provisioner, default-storageclass
?  Done! kubectl is now configured to use "minikube" cluster and "default" namespace by default

为了使我们与 Kubernetes 的交互更容易一些,我们需要复制一些文件并更新我们的.kube/config:

mkdir -p ~/.minikube/profiles/minikube
sudo cp -r /root/.kube /home/$USER
sudo cp /root/.minikube/ca.crt /home/$USER/.minikube/ca.crt
sudo cp /root/.minikube/profiles/minikube/client.crt /home/$USER/.minikube/profiles/minikube
sudo cp /root/.minikube/profiles/minikube/client.key /home/$USER/.minikube/profiles/minikube
sudo chown -R $USER:$USER /home/$USER/.kube
sudo chown -R $USER:$USER /home/$USER/.minikube
sed -i  "s/root/home\/$USER/" ~/.kube/config

一旦完成了 minikube 的安装,请验证一切是否正常工作。

$ kubectl get nodes
NAME       STATUS   ROLES                  AGE    VERSION
kubevirt   Ready    control-plane,master   4m5s   v1.20.2

只要你没有得到任何错误,你的基础 Kubernetes 集群就准备好了。

安装 KubeVirt

我们的一体化 Kubernetes 集群现在可以安装 KubeVirt 了。使用 minikube 插件管理器,我们将安装 KubeVirt 到我们的集群:

$ sudo minikube addons enable kubevirt
$ kubectl -n kubevirt wait kubevirt kubevirt --for condition=Available --timeout=300s

此时,我们需要更新集群中的 KubeVirt 实例。我们需要配置 KubeVirt,通过给它一个要查找的 mdevNameSelector 和一个要分配给它的 resourceName 来检测 Intel vGPU。mdevNameSelector 来自于“mdev_type”,我们之前在创建两个虚拟 GPU 时确定了它。当 KubeVirt 设备管理器发现此 mdev 类型的实例时,它将记录此信息,并用标识的 resourceName 标记该节点。稍后在启动虚拟机时,我们将使用这个 resourceName。

cat > kubevirt-patch.yaml << EOF
spec:
  configuration:
    developerConfiguration:
      featureGates:
      - GPU
    permittedHostDevices:
      mediatedDevices:
      - mdevNameSelector: "i915-GVTg_V5_8"
        resourceName: "intel.com/U630"
EOF
kubectl patch kubevirt kubevirt -n kubevirt --patch "$(cat kubevirt-patch.yaml)" --type=merge

现在我们需要等待 KubeVirt 重新加载它的配置。

验证 vGPU 检测

现在 KubeVirt 已经安装并运行,让我们确保 vGPU 被正确识别。使用 kubectl describe node 命令描述 minikube 节点,并查找“Capacity”部分。如果 KubeVirt 正确地检测到 vGPU,你将看到一个容量值大于 0 的“intel.com/U630”条目。

$ kubectl describe node
Name:               kubevirt
Roles:              control-plane,master
Labels:             beta.kubernetes.io/arch=amd64
                    beta.kubernetes.io/os=linux
...
Capacity:
  cpu:                            12
  devices.kubevirt.io/kvm:        110
  devices.kubevirt.io/tun:        110
  devices.kubevirt.io/vhost-net:  110
  ephemeral-storage:              71645Mi
  hugepages-1Gi:                  0
  hugepages-2Mi:                  0
  intel.com/U630:                 2
  memory:                         11822640Ki
  pods:                           110

在这里,intel.com/U630——其中两个是可用的。现在我们只需要一个虚拟机来消耗它们。

安装容器数据导入器

为了安装 Windows 10,我们需要将 Windows 10 安装 ISO 上传到集群中。这可以通过使用容器数据导入器(Containerized Data Importer)来促进。以下步骤摘自“容器数据导入器(CDI)实验[8]”网页:

export VERSION=$(curl -s https://github.com/kubevirt/containerized-data-importer/releases/latest | grep -o "v[0-9]\.[0-9]*\.[0-9]*")
kubectl create -f https://github.com/kubevirt/containerized-data-importer/releases/download/$VERSION/cdi-operator.yaml
kubectl create -f https://github.com/kubevirt/containerized-data-importer/releases/download/$VERSION/cdi-cr.yaml
kubectl -n cdi wait cdi cdi --for condition=Available --timeout=300s

现在我们的 CDI 已经可用,我们将使用 nodePort 暴露它以供使用。这将允许我们在接下来的步骤中连接到 cdi-proxy。

cat > cdi-nodeport.yaml << EOF
apiVersion: v1
kind: Service
metadata:
  name: cdi-proxy-nodeport
  namespace: cdi
spec:
  type: NodePort
  selector:
    cdi.kubevirt.io: cdi-uploadproxy
  ports:
    - port: 8443
      nodePort: 30443
EOF
kubectl create -f cdi-nodeport.yaml

最后一步,让我们获得 virtctl 的最新版本,我们将在安装 Windows 时使用它。

VERSION=$(kubectl get kubevirt.kubevirt.io/kubevirt -n kubevirt -o=jsonpath="{.status.observedKubeVirtVersion}")
curl -L -o virtctl https://github.com/kubevirt/kubevirt/releases/download/${VERSION}/virtctl-${VERSION}-linux-amd64
sudo install virtctl /usr/local/bin

安装 Windows

现在,我们可以安装一个 Windows VM 来测试这个特性。下面的步骤是基于KubeVirt:从 ISO 安装 Microsoft Windows[9],但是我们将使用 Windows 10 而不是 Windows Server 2012。下面的命令假设你有一个名为 win10-virtio.iso 的 Windows 10 ISO 文件。如果你需要 Windows 10 光盘,请参见下载 Windows 10 磁盘镜像[10],并在获得安装光盘后返回这里。

$ virtctl image-upload \
   --image-path=win10-virtio.iso \
   --pvc-name=iso-win10 \
   --access-mode=ReadWriteOnce \
   --pvc-size=6G \
   --uploadproxy-url=https://127.0.0.1:30443 \
   --insecure \
   --wait-secs=240

我们需要一个地方来存储我们的 Windows 10 虚拟磁盘,使用以下方法来创建一个 40Gb 的空间来存储我们的文件。为了在 minikube 中做到这一点,我们将手动创建一个 PersistentVolume(PV)和一个 PersistentVolumeClaim(PVC)。这些步骤假设在“/”中有 45+ GiB 的空闲空间。我们将创建一个“/data”目录以及一个用于存储 PV 的子目录。如果“/”中没有至少 45gib 的空闲空间,则需要释放空间,或将存储挂载到“/data”上才能继续。

cat > win10-pvc.yaml << EOF
---
apiVersion: v1
kind: PersistentVolume
metadata:
  name: pvwinhd1
spec:
  accessModes:
    - ReadWriteOnce
  capacity:
    storage: 43Gi
  claimRef:
    namespace: default
    name: winhd1
  hostPath:
    path: /data/winhd1-pv
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: winhd1
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 40Gi
EOF
kubectl create -f win10-pvc.yaml

现在我们可以创建 Windows 10 虚拟机了。使用以下方法创建一个包含 vGPU 的虚拟机定义文件:

cat > win10vm1.yaml << EOF
apiVersion: kubevirt.io/v1alpha3
kind: VirtualMachine
metadata:
  name: win10vm1
spec:
  running: false
  template:
    metadata:
      creationTimestamp: null
      labels:
        kubevirt.io/domain: win10vm1
    spec:
      domain:
        clock:
          timer:
            hpet:
              present: false
            hyperv: {}
            pit:
              tickPolicy: delay
            rtc:
              tickPolicy: catchup
          utc: {}
        cpu:
          cores: 1
          sockets: 2
          threads: 1
        devices:
          gpus:
          - deviceName: intel.com/U630
            name: gpu1
          disks:
          - cdrom:
              bus: sata
            name: windows-guest-tools
          - bootOrder: 1
            cdrom:
              bus: sata
            name: cdrom
          - bootOrder: 2
            disk:
              bus: sata
            name: disk-1
          inputs:
          - bus: usb
            name: tablet
            type: tablet
          interfaces:
          - masquerade: {}
            model: e1000e
            name: nic-0
        features:
          acpi: {}
          apic: {}
          hyperv:
            relaxed: {}
            spinlocks:
              spinlocks: 8191
            vapic: {}
        machine:
          type: pc-q35-rhel8.2.0
        resources:
          requests:
            memory: 8Gi
      hostname: win10vm1
      networks:
      - name: nic-0
        pod: {}
      terminationGracePeriodSeconds: 3600
      volumes:
        - name: cdrom
          persistentVolumeClaim:
            claimName: iso-win10
        - name: disk-1
          persistentVolumeClaim:
            claimName: winhd1
        - containerDisk:
            image: quay.io/kubevirt/virtio-container-disk
          name: windows-guest-tools
EOF
kubectl create -f win10vm1.yaml

请注意:该虚拟机没有优化使用 virtio 设备来简化操作系统的安装。通过使用 SATA 设备和模拟的 e1000 网卡,我们不需要担心加载额外的驱动程序。

我们已经添加到这个虚拟机定义中的关键信息是 yaml 的这段代码:

        devices:
          gpus:
          - deviceName: intel.com/U630
            name: gpu1

在这里,我们正在标识我们想要绑定到这个 VM 的 GPU 设备。deviceName 与我们给 KubeVirt 的用来识别 Intel GPU 资源的名称有关。它也是运行 kubectl describe node 时出现在节点“Capacity”部分的相同标识符。

我们现在可以启动虚拟机了:

virtctl start win10vm1
kubectl get vmi --watch

当输出显示虚拟机处于“Running”阶段时,你可以“CTRL+C”结束监视命令。

访问 Windows 虚拟机

因为我们在本地机器上运行这个 VM,所以现在可以利用 virtctl 命令连接到虚拟机的 VNC 控制台。

$ virtctl vnc win10vm1

一个新的 VNC Viewer 窗口将打开,你现在应该会看到 Windows 10 安装屏幕。此时请遵循标准的 Windows 10 安装步骤。

安装完成后,你就拥有了一个运行有可用 GPU 的 Windows 10 虚拟机。你可以通过打开 Windows 10 任务管理器,选择 Advanced,然后选择“Performance”选项卡来测试 GPU 加速是否可用。注意,在你第一次启动时,Windows 仍然在检测和安装适当的驱动程序。在“Performance”页签中显示 GPU 信息可能需要一到两分钟。

尝试测试 GPU 加速。在你的虚拟机中打开浏览器,浏览到“http://www.fishgl.com”,但是不要对糟糕的性能感到惊讶。默认的KubeVirt控制台不利用GPU。为此,我们需要采取最后一步,使用Windows远程桌面协议(RDP),它可以使用GPU。

使用 GPU

为了利用我们添加的虚拟 GPU,我们需要通过远程桌面协议(RDP)连接到虚拟机。请按照以下步骤启用 RDP:

  • 在 Windows 10 搜索栏中,输入“Remote Desktop Settings”,然后打开结果。
  • 选择“Enable Remote Desktop”并确认更改。
  • 选择“Advanced settings”,取消勾选“Require computers to use Network level Authentication”,并确认此更改。
  • 最后重启 Windows 10 虚拟机。

现在,运行以下命令向 Kubernetes 集群外部暴露 RDP 服务器:

$ virtctl expose vm win10vm1 --port=3389 --type=NodePort --name=win10vm1-rdp
$ kubectl get svc
NAME           TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)          AGE
kubernetes     ClusterIP   10.96.0.1        <none>        443/TCP          18h
win10vm1-rdp   NodePort    10.105.159.184   <none>        3389:30627/TCP   39s

请注意分配给该服务的端口,我们将在下一步中使用它。在上面的输出中,端口是 30627。

我们现在可以使用 rdesktop 工具连接到我们的 VM,并充分利用 vGPU 的优势。从命令行运行 rdesktop localhost:端口,确保根据上面的输出更新端口。当 rdesktop 提示时,接受证书。登录到你的 Windows 10 客户端。现在可以测试 vGPU 了。

让我们再试试 FishGL。打开浏览器,登录http://www.fishgl.com。你应该注意到应用程序性能有了很大的改进。你也可以打开Task Manager,查看性能选项卡来查看 GPU 加载情况。

请注意,由于你在同一 GPU 上运行 Fedora 32 工作站,你已经在主桌面之间共享图形工作负载,并且虚拟 Windows 桌面也在此机器上运行。

恭喜你!你现在有了一个使用 Intel vGPU 在 Kubernetes 中运行的 VM。如果你的测试机器有足够的资源,你可以重复这些步骤并创建多个共享同一个 Intel GPU 的虚拟机。

参考资料

[1]

KubeVirt 0.40: https://github.com/kubevirt/kubevirt/releases/tag/v0.40.0

[2]

创建 vGPU(仅 KVMGT): https://github.com/intel/gvt-linux/wiki/GVTg_Setup_Guide#53-create-vgpu-kvmgt-only

[3]

minikube start: https://minikube.sigs.k8s.io/docs/start/

[4]

KubeVirt releases: https://github.com/kubevirt/kubevirt/releases

[5]

在 Linux 上安装和设置 kubectl: https://kubernetes.io/docs/tasks/tools/install-kubectl-linux/

[6]

下载 Windows 10 磁盘镜像文件: https://www.microsoft.com/en-us/software-download/windows10

[7]

Minikube: https://minikube.sigs.k8s.io/docs/

[8]

容器数据导入器(CDI)实验: https://kubevirt.io/labs/kubernetes/lab2.html

[9]

KubeVirt:从 ISO 安装 Microsoft Windows: https://kubevirt.io/2020/KubeVirt-installing_Microsoft_Windows_from_an_iso.html

[10]

下载 Windows 10 磁盘镜像: https://www.microsoft.com/en-us/software-download/windows10

文章分享自微信公众号:
CNCF

本文参与 腾讯云自媒体分享计划 ,欢迎热爱写作的你一起参与!

如有侵权,请联系 cloudcommunity@tencent.com 删除。
登录 后参与评论
0 条评论

相关文章

  • KubeVirt上的虚拟化GPU工作负载

    在这段2019年北美KubeCon视频中,Red Hat的David Vossel和NVIDIA的Vishesh Tanksale探索了KubeVirt背后的架...

    CNCF
  • 在gcc中使用intel风格的内联汇编

    很简单,内联汇编使用asm(“.intel_syntax noprefix/n”)声明一下,以后的内联汇编就可以用intel风格了,构建可执行文件时给gcc加上...

    战神伽罗
  • 在 k8s 中使用 Kubevirt 运行管理 Windows 10 操作系统

    既然闲置资源那么多,那我何不想办法利用一下。怎么用,用来干什么又是一个问题,想到我手中只有 MacBook,缺少 Windows 操作系统,那就先想办法用 Ku...

    米开朗基杨
  • GPU虚拟化哪家强

    2014年之前GPU虚拟化技术一直采用的是GPU直接passthrough技术,它分为GPU直接passthrough和使用VFIO的passthrough,后...

    虚拟化云计算
  • 几张图看一下Intel和NVIDIA显卡虚拟化

    GPU全虚拟化的方式由于其性能和多虚拟机共享性方面的优势,一直是GPU厂家所努力支持的方向。本文通过几张架构图,看一下GPU全虚拟化中的Intel GVT-g和...

    虚拟化云计算
  • XenServer 7 Tech Preview

      最近几天,伴随XenApp & XenDesktop 7.6 FP3的发布,Citrix也带来了XenServer最新版本的Preview版本,随着Citr...

    SuperDream
  • 为什么M1 Mac在日常使用中能击败Intel Mac

    在日常实践中,M1 Mac的使用者会很快注意到他们的ARM Mac速度异常快。主要原因之一与新CPU的设计有关。

    Mac精选
  • GPU虚拟化,算力隔离,和qGPU

    宋吉科,腾讯云异构计算研发负责人,专注系统虚拟化、操作系统内核十多年,KVM平台上第一个GPU全虚拟化项目KVMGT作者,对GPU、PCIe有深入的研究。 〇...

    腾讯云原生
  • 英伟达显卡虚拟化vGPU实践指南

    在前面的一篇文章中介绍了Intel、AMD、NIVIDA三个厂家的GPU虚拟化技术,有兴趣的可以看看本号之前的文章,今天就具体的实践一下英伟达的vGPU。

    虚拟化云计算
  • Kubernetes 管理虚拟机之 KubeVirt

    Kubevirt 是Redhat开源的以容器方式运行虚拟机的项目,以k8s add-on方式,利用k8s CRD为增加资源类型VirtualMachineIns...

    YP小站
  • [没接触过kubevirt?]15分钟快速入门kubevirt

    前者适合新手,后者适合老手**(方便大家查找,从而过滤掉某些步骤,节约时间成本)** 所以大家按需查看哟。

    CloudLog无名小歌
  • 在Kubernetes中利用 kubevirt 以容器方式运行虚拟机

    随着Docker和Kubernetes生态圈的发展,云计算领域对容器的兴趣达到了狂热的程度。 容器技术为应用程序提供了隔离的运行空间,每个容器内都包含一个独享的...

    SammyLiu
  • KubeVirt:使用CRD扩展Kubernetes来运行虚拟化工作负载

    KubeVirt是一个Kubernetes插件,为用户提供了与容器工作负载并排安排传统虚拟机工作负载的能力。通过使用自定义资源定义(CRD)和其它Kuberne...

    CNCF
  • 后Kubernetes时代的虚拟机管理技术之kubevirt篇

    kubevirt是Red Hat开源的以容器方式运行虚拟机的项目,是基于kubernetes运行,利用k8s CRD为增加资源类型VirtualMachineI...

    谐云
  • 后Kubernetes时代的虚拟机管理技术之kubevirt篇

    kubevirt是Red Hat开源的以容器方式运行虚拟机的项目,是基于kubernetes运行,利用k8s CRD为增加资源类型VirtualMachineI...

    CNCF
  • 云原生虚拟化的最佳拍档:Kube-OVN + KubeVirt

    随着云原生技术从应用侧向数据中心和基础设施下沉,越来越多的企业开始使用 Kubernetes 和 KubeVirt 来运行虚拟化工作负载,实现在统一的控制平面同...

    灵雀云
  • KubeVirt深度剖析系列之:virt-controller源码分析

    kubevirt 是一个围绕kubernetes构建的虚拟机管理架构,主要用于技术原因无法将虚拟机应用迁移到容器平台的场景,它提供了完善的虚拟机生命周期管理、在...

    CNCF
  • 【kubevirt】VirtualMachineInstanceReplicaSet(vmis)-扩缩容-弹性伸缩

    VirtualMachineInstanceReplicaSet(vmis)确保指定数量的 VirtualMachineInstance(vmi) 副本在任何时...

    CloudLog无名小歌
  • NVIDIA vGPU vApps/vWS/vCS适配GPU版本介绍

    NVIDIA vGPU 12.0版本-vGPU版本名称变化 - 注: 2021年1月生效

    Hum0ro

扫码关注云+社区

领取腾讯云代金券