VM Creation Stalling with Cloud Init and QEMU

[DevelopingGamer]

Hi,

I am having issues when attempting to use Cloud Init when provisioning a VM from a template created in Terraform. I have modularized template creations and have included all the relevant configurations below. I am deliberately attempting to configure Cloud Init separately on each VM rather than it being in the template to begin with.

modules/vm-template/main.tf

locals {
  lowercase_os_name = lower(var.os_details["name"])
  local_tags        = ["template", "${local.lowercase_os_name}${var.os_details["version"]}", "vm", "terraform"]
}

resource "proxmox_virtual_environment_vm" "vm_template" {
  name        = "vm-template-${substr(local.lowercase_os_name, 0, var.short_name_os_length)}${var.os_details["version"]}"
  description = "Simple VM template for ${var.os_details["name"]} ${var.os_details["version"]}. Managed by Terraform."
  node_name   = var.node_name
  vm_id       = var.vm_id

  cpu {
    cores   = var.cpu_core_config["cores"]
    sockets = var.cpu_core_config["sockets"]
    type    = var.cpu_type
    flags   = var.cpu_flags
    numa    = var.numa_enabled
  }

  memory {
    dedicated = var.memory.max
    floating  = var.memory.min
  }

  bios          = var.bios_type
  scsi_hardware = var.disks_type

  disk {
    size         = var.disk_config_main["size"]
    datastore_id = var.disk_config_main["datastore"]
    cache        = var.disk_config_main["cache"]
    interface    = "${var.disk_config_main["interface"]}0"
    ssd          = var.disk_config_main["ssd"]
    import_from  = var.disk_config_main["image_file"]
    file_format  = var.disk_config_main["image_format"]
    iothread     = true
  }

  dynamic "disk" {
    for_each = var.disk_configs_additional
    content {
      size         = each.value["size"]
      datastore_id = each.value["datastore"]
      cache        = each.value["cache"]
      interface    = "${each.value["interface"]}index(var.disk_configs_additional, each.value"
      ssd          = each.value["ssd"]
      iothread     = true
    }
  }

  network_device {
    bridge   = var.network_config["bridge"]
    firewall = var.network_config["firewall"]
  }

  keyboard_layout = var.keyboard_layout


  operating_system {
    type = var.os_type
  }

  agent {
    enabled = var.qemu_details["timeout"] != null ? true : false
    timeout = "${var.qemu_details["timeout"]}m"
    wait_for_ip {
      disabled = var.qemu_details["timeout"] != null && var.qemu_details["no_ip_wait"] == null ? false : var.qemu_details["no_ip_wait"] 
    }
  }

  vga {
    type = var.display_type
  }

  audio_device {
    enabled = var.audio_device != null ? true : false
    device  = var.audio_device
  }

  tags     = concat(tolist(local.local_tags), var.additional_tags)
  template = true
}

modules/vm-template/variables.tf

variable "os_details" {
  type        = map(string)
  description = "Details about the OS used by the VM, used in the template name and description."
}

variable "short_name_os_length" {
  type        = number
  description = "Number of characters to use from the os_name for the template name. Must be between 3 and 5."
  default     = 3

  validation {
    condition     = var.short_name_os_length >= 3 && var.short_name_os_length <= 5
    error_message = "Invalid 'short_name_os_length'. Must be between 3 and 5."
  }
}

variable "node_name" {
  type        = string
  description = "Name of the node to deploy to."
  default     = "pve"
}

variable "vm_id" {
  type        = number
  description = "ID of the VM - Convention is by last 5 of IP. Example: Last 2 octets .12.3 = 12003."
}

variable "cpu_core_config" {
  type        = map(number)
  description = "Number of CPU cores and sockets"
  default = {
    cores   = 2
    sockets = 1
  }

  validation {
    condition     = var.cpu_core_config.cores > 0 && (var.cpu_core_config.sockets == 1 || var.cpu_core_config.sockets == 2)
    error_message = "'cpu_core_config.cores' must be a positive integer and 'cpu_core_config.sockets' must be either 1 or 2."
  }
}

variable "cpu_type" {
  type        = string
  description = "CPU type to use for the VM"
  default     = "x86-64-v2-AES"
}

variable "cpu_flags" {
  type        = list(string)
  description = "Which CPU flags to enable"
  default     = ["+aes", "+pcid", "+pcid", "+spec-ctrl", "+ssbd"]
}

variable "memory" {
  type        = map(number)
  description = "Amount of CPU memory in MB"
  default = {
    max = 4096,
    min = 2048
  }

  validation {
    condition     = var.memory.min > 0 && var.memory.max >= var.memory.min
    error_message = "'memory' values must be a positive integer and 'memory.max' must >= 'memory.min'."
  }
}

variable "numa_enabled" {
  type        = bool
  description = "Whether to enable NUMA for the VM"
  default     = true

}

variable "disk_config_main" {
  type = object({
    size         = optional(number, 100)
    datastore    = optional(string, "pool0")
    cache        = optional(string, "none")
    interface    = optional(string, "scsi")
    ssd          = optional(bool, false)
    image_file   = string
    image_format = string
  })
  description = "Configuration options for main boot disk"

  validation {
    condition     = contains(["none", "directsync", "writethrough", "writeback", "unsafe"], var.disk_config_main.cache)
    error_message = "Invalid 'disk_config_main.cache'. Valid options are: 'none', 'directsync', 'writethrough', 'writeback', 'unsafe'."
  }

  validation {
    condition     = contains([true, false], var.disk_config_main.ssd)
    error_message = "Invalid 'disk_config_main.ssd'. Valid options are: true, false'."
  }
}

variable "disk_configs_additional" {
  type = list(object({
    size      = optional(number, 100)
    datastore = optional(string, "pool0")
    cache     = optional(string, "none")
    interface = optional(string, "scsi")
    ssd       = optional(bool, false)
  }))
  description = "Configurations for additional disks"
  default     = []
}

variable "bios_type" {
  type        = string
  description = "Type of BIOS"
  default     = "seabios"

  validation {
    condition     = contains(["ovmf", "seabios"], var.bios_type)
    error_message = "Invalid 'bios_type'. Valid options are: 'ovmf', 'seabios'."
  }
}

variable "disks_type" {
  type        = string
  description = "Type of virtual storage used for the disks"
  default     = "virtio-scsi-single"
}

variable "network_config" {
  type = object({
    bridge   = string
    firewall = optional(bool, true)
  })
  description = "Name of the network bridge to use"
  default = {
    bridge   = "vmbr0"
    firewall = true
  }
}

variable "keyboard_layout" {
  type        = string
  description = "The default keyboard language and region"
  default     = "en-gb"
}

variable "os_type" {
  type        = string
  description = "Type of operating system for the VM"
  default     = "l26"

  validation {
    condition     = contains(["l26", "win10", "win11", "other"], var.os_type)
    error_message = "Invalid 'os_type'. Valid options are: 'l26', 'win10', 'win11', 'other'."
  }
}

variable "qemu_details" {
  type = object({
    timeout = optional(number, 5)
    no_ip_wait = optional(bool, null)
  })
  description = "Timeout (in minutes), and whether to wait for ip for QEMU guest agent operations."

  validation {
    condition     = var.qemu_details["timeout"] == null ? true : var.qemu_details["timeout"] > 0
    error_message = "'qemu_details.timeout' must be a positive integer or null."
  }
}

variable "display_type" {
  type = string
  description = "Type of display device to use"
  default = "qxl"
}

variable "audio_device" {
  type        = string
  description = "Type of virtualized audio device"
  default     = "intel-hda"
  nullable    = true

  validation {
    condition     = var.audio_device == null ? true : contains(["AC97", "ich9-intel-hda", "intel-hda"], var.audio_device)
    error_message = "Invalid 'audio_device'. Valid options are: 'AC97', 'ich9-intel-hda', 'intel-hda' or null."
  }
}

variable "additional_tags" {
  type        = list(string)
  description = "List of additional tags to apply to the VM"
  default     = []
}

vm-templates.tf

locals {
  template_ids = [12030]
}

module "template_debian13" {
  source = "./modules/vm-template"
  os_details = {
    name    = "Debian"
    version = "13"
  }

  short_name_os_length = 3

  disk_config_main = {
    image_file   = module.debian_13_trixie_latest_image.image_location
    image_format = "raw"
  }

  qemu_details = {
    no_ip_wait = true
  }

  vm_id = local.template_ids[0]
}

virtual-machines.tf

locals {
  node_name            = "pve"
  cloud_init_datastore = "local"
  vm_tags_default      = ["vm", "terraform"]
  vm_ids               = [12030]
  vm_ids_string        = distinct(flatten([for id in local.vm_ids : tostring(id)]))
  local_tags           = []
}

resource "proxmox_virtual_environment_file" "cloud_init_metadata" {
  node_name    = local.node_name
  content_type = "snippets"
  datastore_id = local.cloud_init_datastore
  source_file {
    path = "./cloud-init/metadata.yml"
  }
}

resource "proxmox_virtual_environment_file" "cloud_init_user_default" {
  node_name    = local.node_name
  content_type = "snippets"
  datastore_id = local.cloud_init_datastore
  source_file {
    path = "./cloud-init/user-data-default.yml"
  }
}

resource "proxmox_virtual_environment_vm" "vm_debian13_0" {
  node_name   = local.node_name
  name        = "vm-deb13-test"
  description = "Test Debian 13 VM created via Terraform"
  vm_id       = local.vm_ids[0]

  clone {
    vm_id = module.template_debian13.vm_id
  }

  initialization {
    datastore_id = "local-zfs"
    interface = "sata2"

    ip_config {
      ipv4 {
        address = "172.16.12.30/16"
        gateway = "172.16.0.1"
      }
    }

    meta_data_file_id = proxmox_virtual_environment_file.cloud_init_metadata.id
    user_data_file_id = proxmox_virtual_environment_file.cloud_init_user_default.id
  }

  boot_order = ["scsi0", "sata2"]

  started = true

  tags = concat(tolist(["debian13"]), tolist(local.local_tags))
}

cloud-init/metadata.yml

#cloud-config
hostname: vm-deb13-test

cloud-init/user-default.yml

#cloud-config
timezone: America/Denver
keyboard:
  layout: gb

package_update: true
package_reboot_if_required: true
packages:
  - qemu-guest-agent
  - openssh-server
  - net-tools
  - wget
  - apt-transport-https
  - build-essential
  - zip
  - tmux
  - fzf

users:
  - default

runcmd:
  - systemctl enable qemu-guest-agent
  - systemctl start qemu-guest-agent
  - echo "qemu done" > /tmp/cloud-config.done

When applying it gets stuck on Still creating and eventually times out saying that QEMU is waiting for the network interfaces even though it is getting the right IP address. It does not appear to be acknowledging ether of the Cloud Init files that I created.

I know this is a lot to go through and I appreciate any help people can give me!

[bpg-dev]

Hey @DevelopingGamer

All these modularization and variables make the examples really hard to read. What would help better understand what's going on is the output of terraform apply for the template and for the cloned VM.

Anyway, I feed the description to an AI agent and it came up with this analysis and a few recommendations that seems reasonable.

1. Why it hangs. Your template module enables the QEMU agent (agent.enabled = true), and a clone inherits agent: 1 from the template's PVE config. When the provider starts a VM whose config has the agent enabled, it waits for the guest agent to report network interfaces — it never looks at the guest's actual IP directly. The Debian genericcloud image doesn't ship qemu-guest-agent, so until your user-data installs and starts it, the provider will sit in "Still creating" and eventually time out. That's why you see the right IP on the console while the provider still waits.

2. Your meta-data file format is wrong. meta_data_file_id is passed to cloud-init as the NoCloud meta-data file — it's not a #cloud-config document. It should look like:

instance-id: vm-deb13-test
local-hostname: vm-deb13-test

Easier: drop meta_data_file_id entirely (Proxmox generates meta-data for you) and set hostname: in your user-data instead.

3. Your user-data may actually be running — just slowly. package_update: true plus installing build-essential & friends can take well over the agent timeout on first boot, and package_reboot_if_required: true can reboot the VM mid-provisioning. To verify, log in on the console and run cloud-init status --long and check /var/log/cloud-init-output.log and your /tmp/cloud-config.done marker. Also confirm the snippets are attached: qm config <vmid> should show a cicustom: user=local:snippets/user-data-default.yml,... line and a sata2: ...cloudinit drive.

Suggestions:

• Don't enable the agent on the template resource (a template never boots, so the only effect is that every clone inherits the agent wait). Set agent { enabled = true, timeout = "20m" } explicitly on the clone instead, or add wait_for_ip { disabled = true } there while debugging.
• Consider baking qemu-guest-agent into the image (e.g. via virt-customize --install qemu-guest-agent) instead of installing it through user-data — it makes first boot much faster and more reliable.
• As posted, your template and clone both use vm_id 12030 (template_ids[0] == vm_ids[0]) — that can't apply cleanly, so double-check the IDs. And in the dynamic "disk" block, the iterator is disk.value, not each.value (and the interface string there looks mangled).

Particularly, the agent flag enabled in the template is what causing troubles for you I think.