kubevirt 源码阅读

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

+---------------------+
| KubeVirt            |  ← 虚拟化层
+---------------------+
| Orchestration (K8s) |  ← 编排层
+---------------------+
| Container Runtime   |  ← 容器运行时
+---------------------+
| Operating System    |  ← 操作系统层
+---------------------+
| Physical            |  ← 物理硬件
+---------------------+

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

apiVersion: kubevirt.io/v1
kind: VirtualMachineInstance
metadata:
  name: my-vmi
spec:
  domain:
    cpu:
      cores: 2
    memory:
      guest: 4Gi
    devices:
      disks:
      - disk:
          bus: virtio
        name: containerdisk
  volumes:
  - containerDisk:
      image: quay.io/containerdisks/fedora:latest
    name: containerdisk

1
2
3
4
5
6

type VirtualMachine struct {
    metav1.TypeMeta
    metav1.ObjectMeta
    Spec   VirtualMachineSpec   // 虚拟机规格
    Status VirtualMachineStatus // 虚拟机状态
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

func (vm *VirtualMachine) RunStrategy() (VirtualMachineRunStrategy, error) {
    // running 和 runStrategy 互斥
    if vm.Spec.Running != nil && vm.Spec.RunStrategy != nil {
        return RunStrategyUnknown, fmt.Errorf("running and runstrategy are mutually exclusive")
    }
    RunStrategy := RunStrategyHalted
    if vm.Spec.Running != nil {
        if (*vm.Spec.Running) == true {
            RunStrategy = RunStrategyAlways
        }
    } else if vm.Spec.RunStrategy != nil {
        RunStrategy = *vm.Spec.RunStrategy
    }
    return RunStrategy, nil
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

func (c *Controller) syncRunStrategy(vm *virtv1.VirtualMachine, vmi *virtv1.VirtualMachineInstance, runStrategy virtv1.VirtualMachineRunStrategy) {
    switch runStrategy {
    case virtv1.RunStrategyAlways:
        // VMI 应该始终运行
        if vmi == nil { c.startVMI(vm) }
    case virtv1.RunStrategyHalted:
        // 不应该有 VMI 运行
        if vmi != nil { c.stopVMI(vm, vmi) }
    case virtv1.RunStrategyManual:
        // 手动启停
        if vmi == nil && hasStartRequest(vm) { c.startVMI(vm) }
    case virtv1.RunStrategyRerunOnFailure:
        // 失败时重启
    case virtv1.RunStrategyOnce:
        // 只运行一次
        if vmi == nil { c.startVMI(vm) }
    }
}

1
2
3
4
5
6
7
8
9

spec:
  instancetype:
    name: "standard-2"      # 引用集群级别的 instancetype
    # kind: "VirtualMachineInstancetype" 或 "VirtualMachineClusterInstancetype"
  preference:
    name: "fedora"          # 引用偏好设置
  template:
    spec:
      domain: {}            # instancetype 会自动填充

1

syncedVM, err := c.instancetypeController.Sync(vm, vmi)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

func SetupVMIFromVM(vm *virtv1.VirtualMachine) *virtv1.VirtualMachineInstance {
    vmi := libvmi.New()
    // 从 template 复制元数据和规格
    vmi.ObjectMeta = *vm.Spec.Template.ObjectMeta.DeepCopy()
    vmi.ObjectMeta.Name = vm.ObjectMeta.Name
    vmi.ObjectMeta.Namespace = vm.ObjectMeta.Namespace
    vmi.Spec = *vm.Spec.Template.Spec.DeepCopy()
    // 设置 OwnerReference
    vmi.ObjectMeta.OwnerReferences = []metav1.OwnerReference{
        *metav1.NewControllerRef(vm, virtv1.VirtualMachineGroupVersionKind),
    }
    return vmi
}

1
2
3
4
5
6
7
8
9

domain:
  resources:
    requests:
      memory: "4Gi"
      cpu: "2"
    limits:
      memory: "8Gi"
      cpu: "4"
    overcommitGuestOverhead: false

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# 场景1：最小资源保证
resources:
  requests:
    memory: "2Gi"          # 最小内存
    cpu: "1"               # 最小 CPU

# 场景2：与 limits 相同（Guaranteed QoS）
resources:
  requests:
    memory: "4Gi"
    cpu: "2"
  limits:
    memory: "4Gi"
    cpu: "2"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# 场景1：限制最大资源
resources:
  limits:
    memory: "8Gi"          # 最大内存
    cpu: "4"               # 最大 CPU

# 场景2：开发测试环境（宽松限制）
resources:
  requests:
    memory: "1Gi"
    cpu: "500m"
  limits:
    memory: "2Gi"
    cpu: "1"

# 场景3：生产环境（Guaranteed QoS）
resources:
  requests:
    memory: "16Gi"
    cpu: "8"
  limits:
    memory: "16Gi"         # 与 requests 相同
    cpu: "8"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

# 场景1：默认行为（保守）
resources:
  requests:
    memory: "4Gi"
  limits:
    memory: "4Gi"
  overcommitGuestOverhead: false  # 开销不计入限制

# 场景2：超卖模式（激进）
resources:
  requests:
    memory: "4Gi"
  limits:
    memory: "4Gi"
  overcommitGuestOverhead: true   # 开销计入限制
  # 实际可用内存 = 4Gi - 开销（约 100-300MB）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

# 生产环境推荐配置
resources:
  requests:
    memory: "8Gi"           # VM 需要的内存
    cpu: "4"
  limits:
    memory: "8Gi"           # 与 requests 相同（Guaranteed QoS）
    cpu: "4"
  overcommitGuestOverhead: false  # 保守配置

# 开发测试环境配置
resources:
  requests:
    memory: "2Gi"
    cpu: "1"
  limits:
    memory: "4Gi"           # 允许突发
    cpu: "2"
  overcommitGuestOverhead: true   # 节省资源

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

# 场景1：单 socket 多 core（节省许可证成本）
cpu:
  sockets: 1
  cores: 8
  threads: 1      # 总 vCPU = 8，但只有 1 个 socket

# 场景2：多 socket（模拟 NUMA 拓扑）
cpu:
  sockets: 2
  cores: 4
  threads: 1      # 总 vCPU = 8，2 个 socket，模拟 NUMA

# 场景3：启用超线程
cpu:
  sockets: 1
  cores: 4
  threads: 2      # 总 vCPU = 8，每个 core 有 2 个线程

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# 场景1：高兼容性（适合迁移）
cpu:
  model: "host-model"

# 场景2：嵌套虚拟化
cpu:
  model: "host-passthrough"

# 场景3：特定 CPU 特性
cpu:
  model: "Skylake-Client"
  features:
  - name: "avx512f"
    policy: "require"

1
2
3
4
5

cpu:
  dedicatedCpuPlacement: true
  isolateEmulatorThread: true   # 隔离模拟器线程，进一步降低延迟
  realtime:
    mask: "0-3"                 # 使用 CPU 0-3 进行实时任务

1
2
3
4

cpu:
  sockets: 2
  cores: 4
  maxSockets: 4      # 可以热插拔到 4 个 socket（16 vCPU）

1
2
3
4
5
6
7

domain:
  cpu:
    features:
    - name: "vmx"
      policy: "require"
    - name: "sse4.1"
      policy: "optional"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

# 场景1：小型应用
memory:
  guest: "2Gi"

# 场景2：大型数据库
memory:
  guest: "64Gi"

# 场景3：内存与资源请求不同
resources:
  requests:
    memory: "4Gi"
  limits:
    memory: "4Gi"
memory:
  guest: "3.5Gi"      # Guest 看到的内存略小于请求（预留 overhead）

1
2
3

memory:
  guest: "4Gi"
  maxGuest: "8Gi"      # 可以热插拔到 8Gi

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# 场景1：使用 2Mi 大页
memory:
  guest: "16Gi"
  hugepages:
    pageSize: "2Mi"

# 场景2：使用 1Gi 大页（需要节点支持）
memory:
  guest: "64Gi"
  hugepages:
    pageSize: "1Gi"

1
2
3
4

memory:
  guest: "8Gi"
  reservedOverhead:
    memLock: "Required"      # 锁定内存

1
2
3

domain:
  machine:
    type: "q35"

1
2
3
4
5
6
7
8

domain:
  firmware:
    uuid: "5d30b294-1f6d-11e9-bb3a-0242ac130002"
    bootloader:
      efi:
        secureBoot: true
        persistent: true
    serial: "my-vm-serial"

1
2
3
4

# 场景：许可证绑定 UUID
volumes:
firmware:
  uuid: "5d30b294-1f6d-11e9-bb3a-0242ac130002"  # 固定 UUID

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

# 场景1：UEFI + Secure Boot
firmware:
  bootloader:
    efi:
      secureBoot: true       # 启用 Secure Boot
      persistent: true       # NVRAM 持久化

# 场景2：BIOS 串口输出
firmware:
  bootloader:
    bios:
      useSerial: true        # BIOS 输出到串口

# 场景3：传统 BIOS（默认）
firmware:
  bootloader:
    bios: {}                 # 或省略

1
2
3

# 场景：资产管理序列号
firmware:
  serial: "VM-PROD-001"      # 自定义序列号

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

domain:
  devices:
    disks:
    - name: "root-disk"
      disk:
        bus: virtio
    interfaces:
    - name: "default"
      masquerade: {}
    autoattachGraphicsDevice: true
    autoattachSerialConsole: true

1
2
3
4
5
6
7
8

# 场景1：禁用网络
devices:
  autoattachPodInterface: false  # 无网络连接

# 场景2：使用 Multus 多网络
devices:
  autoattachPodInterface: false  # 禁用默认 Pod 网络
# 然后通过 interfaces 配置 Multus 网络

1
2
3
4
5
6
7
8

# 场景1：无头服务器
devices:
  autoattachGraphicsDevice: false  # 禁用 VNC
  autoattachSerialConsole: true    # 启用串口

# 场景2：图形界面
devices:
  autoattachGraphicsDevice: true   # 启用 VNC（默认）

1
2
3
4
5
6
7
8
9

# 场景1：启用串口控制台（默认）
devices:
  autoattachSerialConsole: true
  logSerialConsole: true  # 记录串口日志

# 场景2：仅串口，无图形
devices:
  autoattachGraphicsDevice: false
  autoattachSerialConsole: true

1
2
3
4
5
6
7

# 场景1：启用内存气球（默认）
devices:
  autoattachMemBalloon: true  # 默认值

# 场景2：性能敏感应用
devices:
  autoattachMemBalloon: false  # 禁用内存气球

1
2
3

# 场景：高性能数据库
devices:
  blockMultiQueue: true  # 启用多队列

1
2
3

# 场景：高流量 Web 服务器
devices:
  networkInterfaceMultiqueue: true  # 启用多队列

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

domain:
  devices:
    disks:
    - name: "root-disk"
      disk:
        bus: virtio
      bootOrder: 1
      cache: "none"
    - name: "cdrom"
      cdrom:
        bus: sata
        readonly: true

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

# 场景1：高性能 Linux VM
disks:
- name: "root-disk"
  disk:
    bus: virtio        # 推荐用于现代 OS

# 场景2：需要 SCSI 持久预留
disks:
- name: "shared-disk"
  lun:
    bus: scsi
    reservation: true  # SCSI PR 支持

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

# 场景1：数据库磁盘
disks:
- name: "db-data"
  disk:
    bus: virtio
  cache: "none"          # 数据安全优先

# 场景2：只读数据
disks:
- name: "static-data"
  disk:
    bus: virtio
  cache: "writeback"     # 性能优先

# 场景3：临时数据
disks:
- name: "temp-data"
  disk:
    bus: virtio
  cache: "unsafe"        # 仅测试环境

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

# 场景1：从磁盘启动
disks:
- name: "root-disk"
  disk:
    bus: virtio
  bootOrder: 1           # 第一启动
- name: "cdrom"
  cdrom:
    bus: sata
  bootOrder: 2           # 第二启动

# 场景2：PXE 安装后从磁盘启动
disks:
- name: "install-cdrom"
  cdrom:
    bus: sata
  bootOrder: 2
interfaces:
- name: "pxe-net"
  bootOrder: 1           # PXE 启动优先

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

# 场景1：关键数据库
disks:
- name: "db-data"
  disk:
    bus: virtio
  errorPolicy: "stop"     # 错误时停止 VM

# 场景2：日志磁盘
disks:
- name: "logs"
  disk:
    bus: virtio
  errorPolicy: "ignore"   # 忽略错误继续运行

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

# 场景1：高性能数据库
disks:
- name: "db-data"
  disk:
    bus: virtio
  dedicatedIOThread: true  # 专用 I/O 线程

# 场景2：多个高 I/O 磁盘
disks:
- name: "data-1"
  disk:
    bus: virtio
  dedicatedIOThread: true
- name: "data-2"
  disk:
    bus: virtio
  dedicatedIOThread: true

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

# 场景1：共享数据磁盘
disks:
- name: "shared-data"
  disk:
    bus: virtio
  shareable: true        # 多 VM 可同时访问

# 场景2：集群文件系统
disks:
- name: "gfs2-disk"
  lun:
    bus: scsi
  shareable: true

1
2
3
4
5
6

# 场景：启用增量备份
disks:
- name: "data-disk"
  disk:
    bus: virtio
  changedBlockTracking: true  # 支持增量备份

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

volumes:
- name: "root-disk"
  persistentVolumeClaim:
    claimName: "my-pvc"
- name: "containerdisk"
  containerDisk:
    image: "quay.io/containerdisks/fedora:latest"
    imagePullPolicy: "IfNotPresent"
- name: "cloudinit"
  cloudInitNoCloud:
    userData: |
      #cloud-config
      password: fedora
      chpasswd: { expire: False }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

# 场景1：使用 PVC 作为根磁盘
volumes:
- name: "root-disk"
  persistentVolumeClaim:
    claimName: "vm-root-pvc"  # 引用已存在的 PVC

# 场景2：可热插拔数据盘
volumes:
- name: "data-disk"
  persistentVolumeClaim:
    claimName: "data-pvc"
    hotpluggable: true       # 支持热插拔

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# 场景1：使用标准 OS 镜像
volumes:
- name: "os-disk"
  containerDisk:
    image: "quay.io/containerdisks/fedora:latest"
    imagePullPolicy: "IfNotPresent"  # 本地优先

# 场景2：私有镜像仓库
volumes:
- name: "custom-os"
  containerDisk:
    image: "registry.example.com/vm-images/ubuntu:20.04"
    imagePullSecret: "registry-credentials"  # 拉取密钥
    path: "disk.img"  # 磁盘文件在容器中的路径

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# 场景1：临时数据盘
volumes:
- name: "temp-data"
  emptyDisk:
    capacity: "10Gi"  # 大小

# 场景2：交换分区
volumes:
- name: "swap"
  emptyDisk:
    capacity: "4Gi"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

# 场景1：基础用户配置
volumes:
- name: "cloudinit"
  cloudInitNoCloud:
    userData: |
      #cloud-config
      hostname: my-vm
      users:
      - name: admin
        sudo: ALL=(ALL) NOPASSWD:ALL
        ssh_authorized_keys:
        - ssh-rsa AAAA... [email protected]
      packages:
      - nginx
      - docker

# 场景2：网络配置
volumes:
- name: "cloudinit"
  cloudInitNoCloud:
    userData: |
      #cloud-config
      hostname: web-server
    networkData: |
      version: 2
      ethernets:
        eth0:
          addresses:
          - 192.168.1.100/24
          gateway4: 192.168.1.1
          nameservers:
            addresses:
            - 8.8.8.8

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# 场景1：使用已存在的磁盘文件
volumes:
- name: "local-disk"
  hostDisk:
    path: "/data/vms/vm1.qcow2"
    type: Disk  # 文件必须存在

# 场景2：自动创建磁盘文件
volumes:
- name: "auto-disk"
  hostDisk:
    path: "/data/vms/auto.qcow2"
    type: DiskOrCreate  # 不存在则创建
    capacity: "20Gi"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

# 场景1：从 URL 导入镜像
volumes:
- name: "root-disk"
  dataVolume:
    name: "fedora-dv"  # 引用 DataVolume
---
# DataVolume 定义（需要单独创建）
apiVersion: cdi.kubevirt.io/v1beta1
kind: DataVolume
metadata:
  name: fedora-dv
spec:
  source:
    http:
      url: "https://example.com/fedora.qcow2"
  pvc:
    accessModes:
    - ReadWriteOnce
    resources:
      requests:
        storage: 10Gi

# 场景2：可热插拔 DataVolume
volumes:
- name: "data-disk"
  dataVolume:
    name: "data-dv"
    hotpluggable: true

1
2
3
4
5
6
7

interfaces:
- name: "primary"
  bridge: {}
  acpiIndex: 1        # 稳定的索引，不会因 PCI 地址变化而改变
- name: "secondary"
  bridge: {}
  acpiIndex: 2

1
2
3
4
5
6
7

interfaces:
- name: "pxe-boot"
  bridge: {}
  dhcpOptions:
    bootFileName: "pxelinux.0"        # DHCP 选项 67：引导文件名
    tftpServerName: "192.168.1.100"   # DHCP 选项 66：TFTP 服务器地址
  bootOrder: 1                        # 从网络启动

1
2
3
4
5
6
7

interfaces:
- name: "default"
  masquerade: {}
  dhcpOptions:
    ntpServers:
    - "192.168.1.1"
    - "192.168.1.2"                   # DHCP 选项 042：NTP 服务器列表

1
2
3
4
5
6
7

interfaces:
- name: "custom"
  bridge: {}
  dhcpOptions:
    privateOptions:
    - option: 224                     # 私有选项编号（224-254）
      value: "custom-value"           # 选项值

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

interfaces:
- name: "management"
  bridge: {}
  tag: "management-network"      # 管理网络
- name: "storage"
  bridge: {}
  tag: "storage-network"         # 存储网络
- name: "application"
  bridge: {}
  tag: "app-network"             # 业务网络

1
2

# 在 Guest OS 内
curl http://169.254.169.254/openstack/latest/network_data.json

1
2
3
4

interfaces:
- name: "temporary"
  bridge: {}
  state: absent          # 删除这个接口

1
2
3
4

interfaces:
- name: "backup"
  bridge: {}
  state: down            # 关闭但不删除，需要时可以重新启用

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

# 场景1：高性能网络（推荐）
interfaces:
- name: "default"
  masquerade: {}
  model: "virtio"           # 最佳性能

# 场景2：兼容性优先（旧版 OS）
interfaces:
- name: "legacy"
  bridge: {}
  model: "e1000"            # 无需 virtio 驱动

# 场景3：Windows 旧版本
interfaces:
- name: "win-network"
  bridge: {}
  model: "e1000e"           # Windows 7/Server 2008

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

# 场景1：固定 MAC 地址
interfaces:
- name: "default"
  bridge: {}
  macAddress: "de:ad:00:00:be:af"  # 自定义 MAC

# 场景2：软件许可绑定
interfaces:
- name: "license-if"
  bridge: {}
  macAddress: "52:54:00:12:34:56"  # 许可证绑定的 MAC

# 场景3：多网卡固定 MAC
interfaces:
- name: "eth0"
  bridge: {}
  macAddress: "52:54:00:01:02:03"
- name: "eth1"
  bridge: {}
  macAddress: "52:54:00:04:05:06"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

# 场景1：Web 服务端口转发
interfaces:
- name: "default"
  masquerade:
    ports:
    - name: "http"
      port: 80              # VM 内部端口
      protocol: "TCP"
    - name: "https"
      port: 443
      protocol: "TCP"

# 场景2：SSH 访问
interfaces:
- name: "default"
  masquerade:
    ports:
    - name: "ssh"
      port: 22
      protocol: "TCP"

# 场景3：自定义应用端口
interfaces:
- name: "default"
  masquerade:
    ports:
    - name: "app-port"
      port: 8080
      protocol: "TCP"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

# 场景1：PXE 安装
interfaces:
- name: "pxe-boot"
  bridge: {}
  bootOrder: 1              # 网络启动优先
  dhcpOptions:
    bootFileName: "pxelinux.0"
    tftpServerName: "192.168.1.100"

disks:
- name: "local-disk"
  disk:
    bus: virtio
  bootOrder: 2              # 本地磁盘第二启动

# 场景2：无盘工作站
interfaces:
- name: "network-boot"
  bridge: {}
  bootOrder: 1              # 仅网络启动

1
2
3
4
5
6
7
8

# 场景：固定 PCI 地址
interfaces:
- name: "primary"
  bridge: {}
  pciAddress: "0000:01:00.0"  # 固定 PCI 地址
- name: "secondary"
  bridge: {}
  pciAddress: "0000:02:00.0"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

spec:
  networks:
  - name: "default"
    pod: {}
  - name: "multus-net"
    multus:
      networkName: "macvlan-network"
  interfaces:
  - name: "default"
    masquerade: {}
    model: "virtio"
  - name: "multus-net"
    bridge: {}
    macAddress: "02:00:00:00:00:01"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

spec:
  dataVolumeTemplates:
  - metadata:
      name: "root-disk"
    spec:
      source:
        http:
          url: "https://example.com/disk.qcow2"
      pvc:
        accessModes: ["ReadWriteOnce"]
        resources:
          requests:
            storage: 10Gi
  template:
    spec:
      domain:
        devices:
          disks:
          - disk: {}
            name: "root-disk"
      volumes:
      - dataVolume:
          name: "root-disk"
        name: "root-disk"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

func (c *Controller) handleDataVolumes(vm *virtv1.VirtualMachine) (bool, error) {
    for _, template := range vm.Spec.DataVolumeTemplates {
        curDataVolume, err := storagetypes.GetDataVolumeFromCache(vm.Namespace, template.Name, c.dataVolumeStore)
        if curDataVolume == nil {
            // 创建 DataVolume
            newDataVolume, err := watchutil.CreateDataVolumeManifest(c.clientset, template, vm)
            curDataVolume, err = c.clientset.CdiClient().CdiV1beta1().DataVolumes(vm.Namespace).Create(ctx, newDataVolume, metav1.CreateOptions{})
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

apiVersion: kubevirt.io/v1
kind: VirtualMachine
metadata:
  name: my-vm
  labels:
    app: my-app
spec:
  runStrategy: Always                      # 运行策略
  instancetype:                            # 实例类型
    name: "standard-2"
  preference:                              # 偏好设置
    name: "fedora"
  dataVolumeTemplates:                     # 数据卷模板
  - metadata:
      name: "root-disk"
    spec:
      source:
        registry:
          url: "docker://quay.io/containerdisks/fedora:latest"
      pvc:
        accessModes: ["ReadWriteOnce"]
        resources:
          requests:
            storage: 10Gi
  template:                                # VMI 模板
    metadata:
      labels:
        kubevirt.io/vm: my-vm
    spec:
      domain:
        cpu:
          cores: 2
        memory:
          guest: 4Gi
        devices:
          disks:
          - disk:
              bus: virtio
            name: "root-disk"
      volumes:
      - dataVolume:
          name: "root-disk"
        name: "root-disk"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

func (c *VMController) syncRunStrategy(vm *virtv1.VirtualMachine, vmi *virtv1.VirtualMachineInstance, createVMI bool) (bool, error) {
    switch runStrategy {
    case virtv1.RunStrategyAlways:
        // 总是保持 VMI 运行
        if vmi == nil {
            return c.startVMI(vm)  // 创建 VMI
        }
        if vmi.IsFinal() {
            return c.startVMI(vm)  // 重启 VMI
        }
        
    case virtv1.RunStrategyHalted:
        // 停止状态，删除 VMI
        if vmi != nil {
            return c.stopVMI(vm, vmi)
        }
        
    case virtv1.RunStrategyManual:
        // 手动控制，不自动操作
        // 需要通过 virtctl start/stop 控制
        
    case virtv1.RunStrategyRerunOnFailure:
        // 仅在失败时重启
        if vmi != nil && vmi.Status.Phase == virtv1.Failed {
            return c.startVMI(vm)
        }
        
    case virtv1.RunStrategyOnce:
        // 只运行一次
        if vmi == nil {
            return c.startVMI(vm)
        }
        // 退出后不再重启
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

apiVersion: kubevirt.io/v1
kind: VirtualMachine
metadata:
  name: production-vm
spec:
  runStrategy: Always
  template:
    spec:
      domain:
        cpu:
          cores: 4
        memory:
          guest: "8Gi"

1
2
3
4
5
6

apiVersion: kubevirt.io/v1
kind: VirtualMachine
metadata:
  name: stopped-vm
spec:
  runStrategy: Halted