### Build Ubuntu VM Rootfs from Container Image

Source: https://github.com/smartxworks/virtink/blob/main/docs/disks_and_volumes.md

This Dockerfile example demonstrates how to build a Ubuntu VM root filesystem from an official Ubuntu container image. It installs necessary packages like systemd, cloud-init, and openssh-server, then copies the rootfs into the Virtink base image.

```dockerfile
FROM ubuntu:jammy AS rootfs
RUN apt-get update -y && \
    apt-get install -y --no-install-recommends systemd-sysv udev lsb-release cloud-init sudo openssh-server && \
    rm -rf /var/lib/apt/lists/*

FROM smartxworks/virtink-container-rootfs-base
COPY --from=rootfs / /rootfs
RUN ln -sf ../run/systemd/resolve/stub-resolv.conf /rootfs/etc/resolv.conf
```

--------------------------------

### Build Custom Kernel for Direct Boot

Source: https://github.com/smartxworks/virtink/blob/main/docs/direct_kernel_boot.md

Dockerfile example for building a custom kernel image. The `vmlinux` file must be copied to the `/vmlinux` path in an image based on `smartxworks/virtink-kernel-base`.

```dockerfile
FROM smartxworks/virtink-kernel-base
COPY vmlinux /vmlinux
```

--------------------------------

### Access VM via SSH using kubectl run

Source: https://github.com/smartxworks/virtink/blob/main/README.md

Connect to a running Virtink VM via SSH. This example uses `kubectl run` to launch an Alpine container, install an SSH client, and then connect to the VM's IP address.

```bash
export VM_NAME=ubuntu-container-rootfs
export VM_POD_NAME=$(kubectl get vm $VM_NAME -o jsonpath='{.status.vmPodName}')
export VM_IP=$(kubectl get pod $VM_POD_NAME -o jsonpath='{.status.podIP}')
kubectl run ssh-$VM_NAME --rm --image=alpine --restart=Never -it -- /bin/sh -c "apk add openssh-client && ssh ubuntu@$VM_IP"
```

--------------------------------

### Create a Virtual Machine with Container Rootfs

Source: https://github.com/smartxworks/virtink/blob/main/README.md

Define and apply a Kubernetes VirtualMachine manifest. This example creates an Ubuntu VM using a container rootfs and cloud-init for configuration.

```yaml
apiVersion: virt.virtink.smartx.com/v1alpha1
kind: VirtualMachine
metadata:
  name: ubuntu-container-rootfs
spec:
  instance:
    memory:
      size: 1Gi
    kernel:
      image: smartxworks/virtink-kernel-5.15.12
      cmdline: "console=ttyS0 root=/dev/vda rw"
    disks:
      - name: ubuntu
      - name: cloud-init
    interfaces:
      - name: pod
  volumes:
    - name: ubuntu
      containerRootfs:
        image: smartxworks/virtink-container-rootfs-ubuntu
        size: 4Gi
    - name: cloud-init
      cloudInit:
        userData: |-
          #cloud-config
          password: password
          chpasswd: { expire: False }
          ssh_pwauth: True
  networks:
    - name: pod
      pod: {}

```

--------------------------------

### Install Virtink Components

Source: https://github.com/smartxworks/virtink/blob/main/README.md

Apply the Virtink YAML manifest to install all necessary components into your Kubernetes cluster. This command deploys the controller, daemon, and other required resources.

```bash
kubectl apply -f https://github.com/smartxworks/virtink/releases/download/v0.13.0/virtink.yaml
```

--------------------------------

### Install Cert-Manager

Source: https://github.com/smartxworks/virtink/blob/main/README.md

Install cert-manager, a requirement for Virtink, using its official YAML manifest. Ensure you are using a compatible version.

```bash
kubectl apply -f https://github.com/cert-manager/cert-manager/releases/download/v1.8.2/cert-manager.yaml
```

--------------------------------

### Reference DataVolume for VM Disk

Source: https://github.com/smartxworks/virtink/blob/main/docs/disks_and_volumes.md

This YAML manifest demonstrates how to use a DataVolume to provide a disk for a Virtink VirtualMachine. This automates the creation of a PVC and the import of data into it. The VM will not start until the DataVolume import is complete.

```yaml
apiVersion: virt.virtink.smartx.com/v1alpha1
kind: VirtualMachine
spec:
  instance:
    disks:
      - name: ubuntu
  volumes:
    - name: ubuntu
      dataVolume:
        volumeName: ubuntu
```

--------------------------------

### Attach PersistentVolumeClaim to VM Disk

Source: https://github.com/smartxworks/virtink/blob/main/docs/disks_and_volumes.md

This YAML manifest shows how to attach a PersistentVolumeClaim (PVC) as a disk to a Virtink VirtualMachine. Use this when the VM's disk data needs to persist after the VM terminates. The PVC must be named 'ubuntu' in this example.

```yaml
apiVersion: virt.virtink.smartx.com/v1alpha1
kind: VirtualMachine
spec:
  instance:
    disks:
      - name: ubuntu
  volumes:
    - name: ubuntu
      persistentVolumeClaim:
        claimName: ubuntu
```

--------------------------------

### Embed Cloud-Init User Data in VM Spec

Source: https://github.com/smartxworks/virtink/blob/main/docs/disks_and_volumes.md

Attach cloud-init data-sources to a VM by embedding user-data directly in the VM specification. This allows the VM's cloud-init setup to pick up the disk as a user-data source. Supports `userData`, `userDataBase64`, and `userDataSecretName`.

```yaml
apiVersion: virt.virtink.smartx.com/v1alpha1
kind: VirtualMachine
spec:
  instance:
    disks:
      - name: ubuntu
      - name: cloud-init
  volumes:
    - name: ubuntu
      containerDisk:
        image: smartxworks/virtink-container-disk-ubuntu
    - name: cloud-init
      cloudInit:
        userData: |-
          #cloud-config
          password: password
          chpasswd: { expire: False }
          ssh_pwauth: True
```

--------------------------------

### Configure SR-IOV Device Plugin

Source: https://github.com/smartxworks/virtink/blob/main/docs/interfaces_and_networks.md

Create a ConfigMap for the SR-IOV Device Plugin to recognize and allocate the prepared VF. Ensure VENDOR_ID and DEVICE_ID variables are set correctly.

```bash
echo $VENDOR_ID # make sure it's the vendor ID of your VF
echo $DEVICE_ID # make sure it's the device ID of your VF
cat <<EOF | kubectl apply -f -
apiVersion: v1
kind: ConfigMap
metadata:
  name: sriovdp-config
  namespace: kube-system
data:
  config.json: |
    {
      "resourceList": [{
        "resourceName": "mellanox_SRIOV_25G",
        "selectors": {
          "vendors": ["$VENDOR_ID"],
          "devices": ["$DEVICE_ID"],
          "drivers": ["vfio-pci"]
        }
      }]
    }
EOF
```

--------------------------------

### Direct Kernel Boot with Pre-built Kernel

Source: https://github.com/smartxworks/virtink/blob/main/docs/direct_kernel_boot.md

Configure a VirtualMachine to use a pre-built kernel image for direct kernel booting. Specify the kernel image name and the command line arguments for the Linux kernel.

```yaml
apiVersion: virt.virtink.smartx.com/v1alpha1
kind: VirtualMachine
spec:
  instance:
    kernel:
      image: smartxworks/virtink-kernel-5.15.12
      cmdline: "console=ttyS0 root=/dev/vda rw"
    disks:
      - name: ubuntu
  volumes:
    - name: ubuntu
      containerRootfs:
        image: smartxworks/virtink-container-rootfs-ubuntu
        size: 4Gi
```

--------------------------------

### Direct Kernel Boot with Container Disk Rootfs

Source: https://github.com/smartxworks/virtink/blob/main/docs/direct_kernel_boot.md

Configure a VirtualMachine to use a `containerDisk` volume as the root filesystem for direct kernel booting. Ensure the kernel command line correctly points to the root partition.

```yaml
apiVersion: virt.virtink.smartx.com/v1alpha1
kind: VirtualMachine
spec:
  instance:
    kernel:
      image: smartxworks/virtink-kernel-5.15.12
      cmdline: "console=ttyS0 root=/dev/vda1 rw"
    disks:
      - name: ubuntu
  volumes:
    - name: ubuntu
      containerDisk:
        image: smartxworks/virtink-container-disk-ubuntu
```

--------------------------------

### Requesting Dedicated CPU Resources for a VM

Source: https://github.com/smartxworks/virtink/blob/main/docs/dedicated_cpu_placement.md

Set `spec.instance.cpu.dedicatedCPUPlacement` to `true` and define the guest CPU topology to request dedicated CPU resources for a virtual machine.

```yaml
apiVersion: virt.virtink.smartx.com/v1alpha1
kind: VirtualMachine
spec:
  instance:
    cpu:
      sockets: 2
      coresPerSocket: 1
      dedicatedCPUPlacement: true
```

--------------------------------

### Build Container Image with VM Disk

Source: https://github.com/smartxworks/virtink/blob/main/docs/disks_and_volumes.md

Inject a remote VM disk image into a container image. Disks must be placed at the `/disk` path and support raw and QCOW2 formats. QCOW2 is recommended for smaller image sizes. The base image must be `smartxworks/virtink-container-disk-base`.

```dockerfile
FROM smartxworks/virtink-container-disk-base
ADD https://cloud-images.ubuntu.com/jammy/current/jammy-server-cloudimg-amd64.img /disk
```

--------------------------------

### Unbind and Rebind VF Driver to vfio-pci

Source: https://github.com/smartxworks/virtink/blob/main/docs/interfaces_and_networks.md

Prepare an SR-IOV Virtual Function (VF) by unbinding its current driver and binding it to vfio-pci. This is a prerequisite for exposing the VF to Virtink.

```bash
export VF_ADDR=0000:58:01.2 # change it to your VF's PCI address
modprobe vfio_pci
export DRIVER=$(lspci -s $VF_ADDR -k | grep driver | awk '{print $5}')
echo $VF_ADDR > /sys/bus/pci/drivers/$DRIVER/unbind
export VENDOR_ID=$(lspci -s $VF_ADDR -Dn | awk '{split($3,a,":"); print a[1]}')
export DEVICE_ID=$(lspci -s $VF_ADDR -Dn | awk '{split($3,a,":"); print a[2]}')
echo $VENDOR_ID $DEVICE_ID > /sys/bus/pci/drivers/vfio-pci/new_id
```

--------------------------------

### Create SR-IOV NetworkAttachmentDefinition

Source: https://github.com/smartxworks/virtink/blob/main/docs/interfaces_and_networks.md

Define a Multus NetworkAttachmentDefinition to make the SR-IOV VF available as a network for Virtink VMs. The resourceName annotation must match the device plugin's resourceList.

```bash
cat <<EOF | kubectl apply -f -
apiVersion: k8s.cni.cncf.io/v1
kind: NetworkAttachmentDefinition
metadata:
  name: mellanox-sriov-25g
  annotations:
    k8s.v1.cni.cncf.io/resourceName: intel.com/mellanox_SRIOV_25G
spec:
  config: |
    {
      "cniVersion": "0.3.1",
      "type": "sriov"
    }
EOF
```

--------------------------------

### Check SR-IOV VF Exposure

Source: https://github.com/smartxworks/virtink/blob/main/docs/interfaces_and_networks.md

Verify that the SR-IOV VF has been successfully exposed as a node resource by the device plugin.

```bash
kubectl get nodes -o=jsonpath-as-json="{.items[*]['status.capacity']}" | grep mellanox_SRIOV_25G
```

--------------------------------

### Power Off VM

Source: https://github.com/smartxworks/virtink/blob/main/README.md

Use this command to power off a VM. Ensure the VM_NAME and POWER_ACTION environment variables are set correctly.

```bash
export VM_NAME=ubuntu-container-rootfs
export POWER_ACTION=PowerOff
kubectl patch vm $VM_NAME --subresource=status --type=merge -p "{"status":{"powerAction":"$POWER_ACTION"}}"
```

--------------------------------

### VirtualMachine Specification for vDPA Interfaces

Source: https://github.com/smartxworks/virtink/blob/main/docs/interfaces_and_networks.md

This VirtualMachine specification demonstrates how to attach vDPA interfaces to a VM. It defines two vDPA interfaces, 'vdpa1' and 'vdpa2', each with specified queue numbers and IOMMU settings, and configures corresponding Multus networks.

```yaml
apiVersion: virt.virtink.smartx.com/v1alpha1
kind: VirtualMachine
spec:
  instance:
    interfaces:
      - name: pod
      - name: vdpa1
        vdpa: { numQueues: 9, iommu: False }
      - name: vdpa2
        vdpa: { numQueues: 9, iommu: False }
  networks:
    - name: pod
      pod: {}
    - name: vdpa1
      multus:
        networkName: offload-ovn1
    - name: vdpa2
      multus:
        networkName: offload-ovn2

```

--------------------------------

### Configure Multus Network for VM

Source: https://github.com/smartxworks/virtink/blob/main/docs/interfaces_and_networks.md

Connects a VirtualMachine to a secondary network defined by a Multus NetworkAttachmentDefinition named 'ovs-br1'.

```yaml
apiVersion: virt.virtink.smartx.com/v1alpha1
kind: VirtualMachine
spec:
  instance:
    interfaces:
      - name: ovs
        bridge: {}
  networks:
    - name: ovs
      multus:
        networkName: ovs-br1
```

--------------------------------

### SR-IOV VM Network Configuration

Source: https://github.com/smartxworks/virtink/blob/main/docs/interfaces_and_networks.md

Configure a VM to attach to an SR-IOV network using Multus. Ensure the networkName in the VM spec matches the created NetworkAttachmentDefinition.

```yaml
apiVersion: virt.virtink.smartx.com/v1alpha1
kind: VirtualMachine
spec:
  instance:
    interfaces:
      - name: sriov
        sriov: {}
  networks:
    - name: sriov
      multus:
        networkName: mellanox-sriov-25g
```

--------------------------------

### Wait for Virtual Machine to Reach Running State

Source: https://github.com/smartxworks/virtink/blob/main/README.md

Monitor the status of a VirtualMachine resource until it reaches the 'Running' phase. This command uses `kubectl wait` with a JSONPath expression to check the VM's status.

```bash
kubectl wait vm ubuntu-container-rootfs --for jsonpath='{.status.phase}'=Running --timeout -1s
```

--------------------------------

### Configure Pod Network for VM

Source: https://github.com/smartxworks/virtink/blob/main/docs/interfaces_and_networks.md

Defines a VirtualMachine with a 'pod' network interface. This uses the default Kubernetes network for the VM.

```yaml
apiVersion: virt.virtink.smartx.com/v1alpha1
kind: VirtualMachine
spec:
  instance:
    interfaces:
      - name: pod
        bridge: {}
  networks:
    - name: pod
      pod: {}
```

--------------------------------

### Masquerade Network Configuration

Source: https://github.com/smartxworks/virtink/blob/main/docs/interfaces_and_networks.md

Configure a VM to use masquerade mode for NAT networking. This mode hides VMs behind pod IPs and requires guest OS to use DHCP.

```yaml
apiVersion: virt.virtink.smartx.com/v1alpha1
kind: VirtualMachine
spec:
  instance:
    interfaces:
      - name: pod
        masquerade: {}
  networks:
    - name: pod
      pod: {}
```

--------------------------------

### vDPA Configuration for SR-IOV Network Device Plugin

Source: https://github.com/smartxworks/virtink/blob/main/docs/interfaces_and_networks.md

This ConfigMap configures the SR-IOV Network Device Plugin to manage vDPA resources. It specifies selectors for vendors, devices, and drivers, along with the vDPA type.

```yaml
apiVersion: v1
kind: ConfigMap
metadata:
  name: sriovdp-config
  namespace: kube-system
data:
  config.json: |
    {
        "resourceList": [
            {
                "resourceName": "jaguar",
                "resourcePrefix": "jaguarmicro.com",
                "selectors": {
                    "vendors": ["1f53"],
                    "devices": ["1000"],
                    "drivers": ["jaguar"],
                    "vdpaType": "vhost"
                }
            }
        ]
    }
 
```

--------------------------------

### Define Multus NetworkAttachmentDefinition

Source: https://github.com/smartxworks/virtink/blob/main/docs/interfaces_and_networks.md

Creates a NetworkAttachmentDefinition for Multus CNI to configure a secondary network using the Open vSwitch CNI plugin, connecting to bridge 'br1'.

```yaml
apiVersion: k8s.cni.cncf.io/v1
kind: NetworkAttachmentDefinition
metadata:
  name: ovs-br1
spec:
  config: |
    {
      "cniVersion": "0.3.1",
      "type": "ovs",
      "bridge": "br1"
    }
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.