Ubuntu 24.04 VM using HashiCorp Packer and vSphere ISO Plugin

In this post I am going to create an Ubuntu 24.04 virtual machine image using HashiCorp Packer, Autoinstall, Cloud-init and the Ansible provisioner.

Running Packer command, the vSphere builder will request vSphere through API to create a new VM with the parameters found in Packer template. It will boot from the image iso file and it will start the installation automatically following the parameters in the user-data file.

Prerequisites

Before starting, make sure you have the following tools installed:

Packer: Download and install from HashiCorp’s website.
Access to a vSphere environment.
An ISO image of Ubuntu 25.04.
Ansible installed on your local machine.

Directory Structure

Here is an example structure of the project:

ubuntu-vm-setup/
├── ubuntu_template.pkr.hcl
├── user-data
├── meta-data
├── almalinux_ed25519
├── almalinux_ed25519.pub
└── ansible/
    └── playbook.yml

Step 1: Create the Packer Template

In case of vSphere ISO plugin, the boot process is configured via the boot_command and the path of the ISO image file defined in the HCL2 file. On top of the packer template we can assign the variables or we can create a separate file for this.

# ubuntu_template.pkr.hcl

variable "vsphere_server" {
  type    = string
  default = "10.3.2.50"
}

variable "vsphere_user" {
  type    = string
  default = "[email protected]"
}

variable "vsphere_password" {
  type    = string
  default = "userpass"
}

variable "datacenter" {
  type    = string
  default = "ESXDataCenter"
}

variable "host" {
  type    = string
  default = "esxi.example.com"
}

variable "datastore" {
  type    = string
  default = "ESXSystemStore"
}

variable "network_name" {
  type    = string
  default = "VM Network"
}

variable "network_card" {
  type    = string
  default = "vmxnet3"
}

variable "ssh_host" {
  type    = string
  default = "10.3.2.5"
}

The required plugins and versions are defined under the packer block.

packer {
  required_plugins {
    vsphere = {
      version = ">= 1.4.2"
      source  = "github.com/hashicorp/vsphere"
    }
    ansible = {
      version = "~> 1"
      source = "github.com/hashicorp/ansible"
    }
  }
}

In the source block, there is the configuration for vCenter connection, the new VM parameters and the boot command with source installation image. Also the cd-files and cd-label paramters are used to copy the local user-data and meta-data files to the virtual cd-rom in the OS. The cd-label should be cidata. When the VM boots, the Ubuntu ISO is mounted and starts the initial installation process. To automate this, Packer uses boot commands to select the appropriate installer options and trigger autoinstall.

source "vsphere-iso" "this" {
  vcenter_server      = var.vsphere_server
  username            = var.vsphere_user
  password            = var.vsphere_password
  datacenter          = var.datacenter
  host                = var.host
  insecure_connection = true

  vm_name       = "UbuntuTF"
  guest_os_type = "ubuntu64Guest"

  CPUs            = 2
  RAM             = 4096
  RAM_reserve_all = true

  ssh_host = var.ssh_host 
  ssh_username = "ubuntu"
  ssh_password = "ubuntu"
  ssh_timeout  = "60m"
  ssh_handshake_attempts = 1000
  ssh_private_key_file = "ubuntu_ed25519"

  disk_controller_type = ["pvscsi"]
  datastore            = var.datastore
  storage {
    disk_size             = 16384
    disk_thin_provisioned = true
  }

  iso_paths = ["[ESXNFS] _ISOs/ubuntu-24.04-live-server-amd64.iso"]

  network_adapters {
    network = var.network_name
    network_card = var.network_card
  }

  cd_files = ["./meta-data", "./user-data"]
  cd_label = "cidata"

  boot_command = ["<wait>e<down><down><down><end> autoinstall ds=nocloud;<F10>"]
 
  boot_wait = "3s"
  
}

And the last block is the build. It defines what the builders are going to do. It will start to build the VM that is in source block and at the end it will start the Ansible provisioner.

build {
  sources = [
    "source.vsphere-iso.this"
  ]

  provisioner "ansible" {
    playbook_file = "./ansible/playbook.yml"
    use_proxy = false
    ansible_env_vars = [
      "ANSIBLE_HOST_KEY_CHECKING=False"
    ]
  }
}

Step 2: Create user-data file

Once the ISO boots, the Ubuntu installer finds the user-data file (served locally via cd-files parameter in source block) and starts to perform an automated installation according to user-data configuration. This is the Autoinstall format that is supported from Ubuntu Server, version 20.04 and later. Key tasks include:

Configuring user accounts
Setting up partitions
Configure networking
Installing essential packages like curl, vim, and htop

The installer follows the instructions in the user-data file to streamline the entire process without manual input.

#cloud-config
autoinstall:
  version: 1
  identity:
    hostname: ubuntutf 
    password: "$6$exDY1mhS4KUYCE/2$zmn9ToZwTKLhCw.b4/b.ZRTIZM30JZ4QrOQ2aOXJ8yk96xpcCof0kxKwuX1kqLG/ygbJ1f8wxED22bTL4F46P0"
    username: ubuntu
  storage:
    config:
      - id: disk0
        type: disk
        ptable: gpt
        path: /dev/sda
        name: Disk0 
        wipe: superblock
        grub_device: true
      - id: disk0-part1
        type: partition
        number: 1
        size: 1M
        device: disk0
        flag: bios_grub
      - id: disk0-part2
        type: partition
        number: 2
        size: 13GB
        device: disk0
        flag: boot
        name: SystemHDD
      - id: disk0-swap
        type: partition
        number: 3
        size: 2GB
        device: disk0
        name: SwapHDD
        flag: swap
      - id: disk0-part2-format-root
        type: format
        fstype: ext4
        volume: disk0-part2
      - id: disk0-swap-format
        type: format
        fstype: swap
        volume: disk0-swap
      - id: disk0-part1-mount-root
        type: mount
        path: /
        device: disk0-part2-format-root 

  install:
    log_file: /tmp/install.log
    post_files: [/tmp/install.log, /var/log/syslog]

  ssh:
    install-server: true
    allow-pw: true
  packages:
    - open-vm-tools
    
  network:
    version: 2
    ethernets:
      ens192:
        dhcp4: false
        dhcp6: false
        addresses:
          - "10.3.2.5/22"
        gateway4: "10.3.2.1"
        nameservers:
          search: ["example.com"]
          addresses: ["10.3.2.1"]

  user-data:
    allow_public_ssh_keys: true
    disable_root: false
    users:
      - name: root
        hashed_passwd: $6$rounds=500000$1PfCX.1gBiGAs4/K$T9bWwTYauGq7VcVXNjeZbXKyGoP058eQXjnqX4PVHLV56jksCRWgdXD/n8OJCFMTdc9RRyToPSYP9jQLKV1qq.
      - name: ubuntu
        ssh_authorized_keys: [ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIH4KzuyoCJwfiDJS07mcWzPDxhBKhwtZLgrPPX37uU1m ubuntu]
        sudo: "ALL=(ALL) NOPASSWD:ALL"
        
    runcmd: 
      - apt-get update
      - apt-get upgrade -y

For the encrypted password you can use the command:

oppenssl passwd -6

After the initial OS setup, at the first boot of the OS, cloud-init will make post installation tasks according to the user-data file. Under user-data block in user-data file is the configuration for cloud-init. Key tasks here include:

Create users
Run post install commands

Cloud-init is an open source initialization tool that was designed to make it easier to get your systems up and running with a minimum of effort, already configured according to your needs.

Cloud-init takes an initial configuration that you supply, and it automatically applies those settings when the instance is created. It’s rather like writing a to-do list, and then letting cloud-init deal with that list for you.

Meta-data file is another configuration file and provides instance-specific metadata, such as the hostname, instance ID, or network settings. It can be used to clone a VM and give an instance-id, hostname, network ip etc. In our example this file is empty.

Sterp 3: Create the Ansible Playbook

Once Cloud-init completes, Packer invokes the Ansible provisioner to configure the VM further. Ansible will use the ubuntu user to connect and the private key ubuntu_ed25519 found in the local directory. Tasks in the playbook might include:

Installing services (e.g., nginx, git)
Starting and enabling services

# playbook.yml
---
- name: Install additional packages and start nginx
  hosts: all 
  become: true
  
  tasks:
  - name: Install packages
    apt:
      name: ["nginx", "git"]
      state: present
  - name: Enable and start Nginx
    service:
      name: nginx
      state: started
      enabled: true

Once Ansible completes, Packer finalizes the image creation. If configured with the convert_to_template option, the VM is saved as a template ready for deployment.

Step 4: Build the VM

Run the packer init command to setup the required plugins.

# packer init .
Installed plugin github.com/hashicorp/vsphere v1.4.2 in "/root/.config/packer/plugins/github.com/hashicorp/vsphere/packer-plugin-vsphere_v1.4.2_x5.0_linux_amd64"
Installed plugin github.com/hashicorp/ansible v1.1.2 in "/root/.config/packer/plugins/github.com/hashicorp/ansible/packer-plugin-ansible_v1.1.2_x5.0_linux_amd64"

Then run the packer build command.

$ packer build .

Once completed, the VM will shutdown. This is the normal process for the Packer. We can boot the VM in order to use it or we can add the convert_to_template: true parameter to convert it to a template in order to make clones from it.

Bellow is an example of packer command output:

# packer build .
vsphere-iso.this: output will be in this color.

==> vsphere-iso.this: Creating CD disk...
    vsphere-iso.this: Warning: creating filesystem with Joliet extensions but without Rock Ridge
    vsphere-iso.this: extensions. It is highly recommended to add Rock Ridge.
    vsphere-iso.this: I: -input-charset not specified, using utf-8 (detected in locale settings)
    vsphere-iso.this: Total translation table size: 0
    vsphere-iso.this: Total rockridge attributes bytes: 0
    vsphere-iso.this: Total directory bytes: 0
    vsphere-iso.this: Path table size(bytes): 10
    vsphere-iso.this: Max brk space used 0
    vsphere-iso.this: 183 extents written (0 MB)
    vsphere-iso.this: Done copying paths from CD_dirs
==> vsphere-iso.this: Uploading packer235402034.iso to [ESXSystemStore] packer_cache...
==> vsphere-iso.this: Creating virtual machine...
==> vsphere-iso.this: Customizing hardware...
==> vsphere-iso.this: Mounting ISO images...
==> vsphere-iso.this: Adding configuration parameters...
==> vsphere-iso.this: Setting temporary boot order...
==> vsphere-iso.this: Powering on virtual machine...
==> vsphere-iso.this: Waiting 3s for boot...
==> vsphere-iso.this: Typing boot command...
==> vsphere-iso.this: Waiting for IP...
==> vsphere-iso.this: IP address: 10.3.2.15
==> vsphere-iso.this: Using SSH communicator to connect: 10.3.2.5
==> vsphere-iso.this: Waiting for SSH to become available...
==> vsphere-iso.this: Connected to SSH!
==> vsphere-iso.this: Running local shell script: /tmp/packer-shell2521629893
    vsphere-iso.this: the address is: 10.3.2.22:0 and build name is: this
==> vsphere-iso.this: Provisioning with Ansible...
    vsphere-iso.this: Not using Proxy adapter for Ansible run:
    vsphere-iso.this:   Using ssh keys from Packer communicator...
==> vsphere-iso.this: Executing Ansible: ansible-playbook -e packer_build_name="this" -e packer_builder_type=vsphere-iso -e packer_http_addr=10.3.2.22:0 --ssh-extra-args '-o IdentitiesOnly=yes' -e ansible_ssh_private_key_file=*****_ed25519 -i /tmp/packer-provisioner-ansible1702141653 /root/terraform/learn-terraform-vsphere/*****/packer/test/ansible/playbook.yml
    vsphere-iso.this:
    vsphere-iso.this: PLAY [Install additional packages and start nginx] *****************************
    vsphere-iso.this:
    vsphere-iso.this: TASK [Gathering Facts] *********************************************************
    vsphere-iso.this: ok: [default]
    vsphere-iso.this:
    vsphere-iso.this: TASK [Install packages] ********************************************************
    vsphere-iso.this: changed: [default]
    vsphere-iso.this:
    vsphere-iso.this: TASK [Enable and start Nginx] **************************************************
    vsphere-iso.this: ok: [default]
    vsphere-iso.this:
    vsphere-iso.this: PLAY RECAP *********************************************************************
    vsphere-iso.this: default                    : ok=3    changed=1    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0
    vsphere-iso.this:
==> vsphere-iso.this: Shutting down virtual machine...
==> vsphere-iso.this: Deleting floppy drives...
==> vsphere-iso.this: Ejecting CD-ROM media...
==> vsphere-iso.this: Clearing boot order...
    vsphere-iso.this: Closing sessions ....
Build 'vsphere-iso.this' finished after 14 minutes 9 seconds.

==> Wait completed after 14 minutes 9 seconds

==> Builds finished. The artifacts of successful builds are:
--> vsphere-iso.this: UbuntuTF