Ubuntu 2404 - Template keeps the old network configuration

[dauphinpasdroit]

Hello,

Once packer have created a template in a content library, when I use the template to create a new virtual machine (using terraform) the virtual machine keeps using the IP Address that been used by packer. It also keep the old hostname as well.

Here are the packer configuration files:

/*
    DESCRIPTION:
    Ubuntu Server 20.04 LTS template using the Packer Builder for VMware vSphere (vsphere-iso).
*/

//  BLOCK: packer
//  The Packer configuration.

packer {
  required_version = ">= 1.7.7"
  required_plugins {
    vsphere = {
      version = ">= v1.4.2"
      source  = "github.com/hashicorp/vsphere"
    }
    ansible = {
      version = ">= 1.1.2"
      source  = "github.com/hashicorp/ansible"
    }
  }
}

//  BLOCK: locals
//  Defines the local variables.

locals {
  buildtime     = formatdate("YYYY-MM-DD hh:mm ZZZ", timestamp())
  manifest_date = formatdate("YYYY-MM-DD hh:mm:ss", timestamp())
  manifest_path = "${path.cwd}/pipelines/images/Packer/manifests/"
  data_source_content = {
    "/meta-data" = file("${abspath(path.root)}/data/meta-data")
    "/user-data" = templatefile("${abspath(path.root)}/data/user-data.pkrtpl.hcl", {
      build_username           = var.build_username
      build_password_encrypted = var.build_password_encrypted
      vm_guest_os_language     = var.vm_guest_os_language
      vm_guest_os_keyboard     = var.vm_guest_os_keyboard
      vm_guest_os_timezone     = var.vm_guest_os_timezone
      build_key                = var.build_key
    })
  }
  data_source_command = var.common_data_source == "http" ? "ds=\"nocloud-net;seedfrom=http://{{.HTTPIP}}:{{.HTTPPort}}/\"" : "ds=\"nocloud\""
}


//  BLOCK: source
//  Defines the builder configuration blocks.

source "vsphere-iso" "linux-ubuntu-server" {

  // vCenter Server Endpoint Settings and Credentials
  vcenter_server      = var.vsphere_endpoint
  username            = var.vsphere_username
  password            = var.vsphere_password
  insecure_connection = var.vsphere_insecure_connection

  // vSphere Settings
  datacenter = var.vsphere_datacenter
  cluster    = var.vsphere_cluster
  datastore  = var.vsphere_datastore
  folder     = var.vsphere_folder

  // Virtual Machine Settings
  guest_os_type        = var.vm_guest_os_type
  vm_name              = var.vm_name
  firmware             = var.vm_firmware
  CPUs                 = var.vm_cpu_sockets
  cpu_cores            = var.vm_cpu_cores
  CPU_hot_plug         = var.vm_cpu_hot_add
  RAM                  = var.vm_mem_size
  RAM_hot_plug         = var.vm_mem_hot_add
  cdrom_type           = var.vm_cdrom_type
  disk_controller_type = var.vm_disk_controller_type
  storage {
    disk_size             = var.vm_disk_size
    disk_thin_provisioned = var.vm_disk_thin_provisioned
  }
  network_adapters {
    network      = var.vsphere_network
    network_card = var.vm_network_card
  }
  vm_version           = var.common_vm_version
  remove_cdrom         = var.common_remove_cdrom
  tools_upgrade_policy = var.common_tools_upgrade_policy
  notes                = "Built by HashiCorp Packer on ${local.buildtime}."

  // Removable Media Settings
  iso_paths    = ["[${var.common_iso_datastore}] ${var.iso_path}/${var.iso_file}"]
  iso_checksum = "${var.iso_checksum_type}:${var.iso_checksum_value}"
  http_content = var.common_data_source == "http" ? local.data_source_content : null
  cd_content   = var.common_data_source == "disk" ? local.data_source_content : null
  cd_label     = var.common_data_source == "disk" ? "cidata" : null

  // Boot and Provisioning Settings
  http_ip       = var.common_data_source == "http" ? var.common_http_ip : null
  http_port_min = var.common_data_source == "http" ? var.common_http_port_min : null
  http_port_max = var.common_data_source == "http" ? var.common_http_port_max : null
  boot_order    = var.vm_boot_order
  boot_wait     = var.vm_boot_wait
  boot_command = [
    // This waits for 3 seconds, sends the "c" key, and then waits for another 3 seconds. In the GRUB boot loader, this is used to enter command line mode.
    "<wait3s>c<wait3s>",
    // This types a command to load the Linux kernel from the specified path with the 'autoinstall' option and the value of the 'data_source_command' local variable.
    // The 'autoinstall' option is used to automate the installation process.
    // The 'data_source_command' local variable is used to specify the kickstart data source configured in the common variables.
    "linux /casper/vmlinuz --- autoinstall ${local.data_source_command}",
    // This sends the "enter" key and then waits. This is typically used to execute the command and give the system time to process it.
    "<enter><wait>",
    // This types a command to load the initial RAM disk from the specified path.
    "initrd /casper/initrd",
    // This sends the "enter" key and then waits. This is typically used to execute the command and give the system time to process it.
    "<enter><wait>",
    // This types the "boot" command. This starts the boot process using the loaded kernel and initial RAM disk.
    "boot",
    // This sends the "enter" key. This is typically used to execute the command.
    "<enter>"
  ]
  ip_wait_timeout  = var.common_ip_wait_timeout
  shutdown_command = "echo '${var.build_password}' | sudo -S -E shutdown -P now"
  shutdown_timeout = var.common_shutdown_timeout

  // Communicator Settings and Credentials
  communicator       = "ssh"
  ssh_proxy_host     = var.communicator_proxy_host
  ssh_proxy_port     = var.communicator_proxy_port
  ssh_proxy_username = var.communicator_proxy_username
  ssh_proxy_password = var.communicator_proxy_password
  ssh_username       = var.build_username
  ssh_password       = var.build_password
  ssh_port           = var.communicator_port
  ssh_timeout        = var.communicator_timeout

  // Template and Content Library Settings
  convert_to_template = var.common_template_conversion
  dynamic "content_library_destination" {
    for_each = var.common_content_library_name != null ? [1] : []
    content {
      library     = var.common_content_library_name
      ovf         = var.common_content_library_ovf
      destroy     = var.common_content_library_destroy
      skip_import = var.common_content_library_skip_import
    }
  }
}

//  BLOCK: build
//  Defines the builders to run, provisioners, and post-processors.

build {
  sources = ["source.vsphere-iso.linux-ubuntu-server"]

  # provisioner "ansible" {
  #   playbook_file    = "${path.cwd}${var.main_ansible}"
  #   roles_path       = "${path.cwd}${var.role_ansible}"
  #   ansible_env_vars = [
  #     "ANSIBLE_CONFIG=${path.cwd}${var.conf_ansible}"
  #     ]
  #   extra_arguments  = [
  #     "-e", "display_skipped_hosts = false" 
  #   ]
  #   user             = "${var.ansible_username}"
  # }

  provisioner "shell" {
    execute_command = "echo '${var.build_password}' | {{.Vars}} sudo -E -S sh -eux '{{.Path}}'"
    environment_vars = [
      "BUILD_USERNAME=${var.build_username}",
      "BUILD_KEY=${var.build_key}",
      "ANSIBLE_USERNAME=${var.ansible_username}",
      "ANSIBLE_KEY=${var.ansible_key}"
    ]
    scripts = formatlist("${path.cwd}/%s", var.scripts)
  }

  post-processor "manifest" {
    output     = "${local.manifest_path}${local.manifest_date}.json"
    strip_path = true
    strip_time = true
    custom_data = {
      ansible_username         = var.ansible_username
      build_username           = var.build_username
      buildtime                = local.buildtime
      common_data_source       = var.common_data_source
      common_vm_version        = var.common_vm_version
      vm_cpu_cores             = var.vm_cpu_cores
      vm_cpu_sockets           = var.vm_cpu_sockets
      vm_disk_size             = var.vm_disk_size
      vm_disk_thin_provisioned = var.vm_disk_thin_provisioned
      vm_firmware              = var.vm_firmware
      vm_guest_os_type         = var.vm_guest_os_type
      vm_mem_size              = var.vm_mem_size
      vm_network_card          = var.vm_network_card
      vsphere_cluster          = var.vsphere_cluster
      vsphere_datacenter       = var.vsphere_datacenter
      vsphere_datastore        = var.vsphere_datastore
      vsphere_endpoint         = var.vsphere_endpoint
      vsphere_folder           = var.vsphere_folder
      vsphere_iso_path         = "[${var.common_iso_datastore}] ${var.iso_path}/${var.iso_file}"
    }
  }
}

Here is user-data.pkrtpl.hcl file:

#cloud-config

autoinstall:
  version: 1
  apt:
    geoip: true
    preserve_sources_list: false
    primary:
      - arches: [amd64, i386]
        uri: http://archive.ubuntu.com/ubuntu
      - arches: [default]
        uri: http://ports.ubuntu.com/ubuntu-ports
  early-commands:
    - sudo systemctl stop ssh
  locale: en_US
  keyboard:
    layout: fr
  storage:
    layout:
      name: direct
  network:
    version: 2
    ethernets:
      ens192:
        dhcp4: false
        dhcp6: false
        addresses: [10.217.184.70/22]
        gateway4: 10.217.184.1
        nameservers:
          addresses: [10.217.0.10]
  identity:
    hostname: ubuntu-server
    username: wsl
    password: password
  ssh:
    install-server: true
    allow-pw: true
    authorized-keys:
      - key
  packages:
    - openssh-server
    - open-vm-tools
    - cloud-init
    # - net-tools
  user-data:
    disable_root: false
    package_update: true
    package_upgrade: true
    package_reboot_if_required: true
    timezone: Europe/Paris
  late-commands:
    - sed -i -e 's/^#\?PasswordAuthentication.*/PasswordAuthentication yes/g' /target/etc/ssh/sshd_config
    # - sudo systemctl enable ssh
    # - sudo systemctl start ssh
    - echo 'wsl ALL=(ALL) NOPASSWD:ALL' > /target/etc/sudoers.d/wsl
    - curtin in-target --target=/target -- chmod 440 /etc/sudoers.d/wsl
    - curtin in-target --target=/target -- sed -i 's/^GRUB_CMDLINE_LINUX_DEFAULT=.*$/GRUB_CMDLINE_LINUX_DEFAULT=""/' /etc/default/grub
    - curtin in-target --target=/target -- update-grub

here is the script to start the build:

xport CONFIG_PATH=./pipelines/images/Packer/config/vsphere
export INPUT_PATH=./pipelines/images/Packer/builds/linux/vsphere/$GO_PIPELINE_NAME
sed -i -r "s/^vm_name +=.*/vm_name = \"$GO_PIPELINE_NAME-tmp\"/g" ./pipelines/images/Packer/builds/linux/vsphere/$GO_PIPELINE_NAME/linux-ubuntu-server.auto.pkrvars.hcl


# export CONFIG_PATH=./pipelines/images/Packer/config/northEu
# export INPUT_PATH=./pipelines/images/Packer/builds/windows/vsphere/$GO_PIPELINE_NAME

### Initialize HashiCorp Packer and required plugins. ###
echo "Initializing HashiCorp Packer and required plugins..."
packer init "$INPUT_PATH"

### Start the HashiCorp Packer Build ###
echo "Starting the HashiCorp Packer build..."

packer build -force \
    -var-file="$CONFIG_PATH/vsphere.pkrvars.hcl" \
    -var-file="$CONFIG_PATH/build.pkrvars.hcl" \
    -var-file="$CONFIG_PATH/ansible.pkrvars.hcl" \
    -var-file="$CONFIG_PATH/proxy.pkrvars.hcl" \
    -var-file="$CONFIG_PATH/common.pkrvars.hcl" \
    -var-file="$CONFIG_PATH/network.pkrvars.hcl" \
    "$INPUT_PATH"
### All done. ###
echo "Done."

And here is network.pkrvars.hcl:

vm_ip_address = "10.217.184.70"
vm_ip_netmask = 22
vm_ip_gateway = "10.217.184.1"
vm_dns_list   = [ "10.217.0.10" ]

For example, I've deployed a VM with terraform, and it keeps old settings:

I've tried a lot of configuration. If you have any clue, let me know.

[tenthirtyam]

It's a bit to say at the moment since the contents of the project have been modified as provided above - playbooks disabled; hard coded bs dynamic user data, missing terraform configuration and possible environmental nuances.

Do you have the same issue with the project defaults?

[dauphinpasdroit]

Here are the terraform configuration:

main.tf:

provider "vsphere" {
  vsphere_server       = var.vsphere_server
  user                 = var.vsphere_username
  password             = var.vsphere_password
  allow_unverified_ssl = true
}

# Awx account service 

data "template_file" "metadata_yml" {
  template = file("${path.module}/templates/metadata.yml")
  vars = {
    vm_ip       = join("/", ["${var.vm_ipv4}", "${var.vm_ipv4_netmask}"])
    vm_name   = var.vm_name
    vm_ipv4_gateway = var.vm_ipv4_gateway 
    vm_netmask = var.vm_ipv4_netmask
  }
}

data "template_file" "userdata_yml" {
  template = file("${path.module}/templates/userdata.yml")
  vars = {
  public_key = "key"
  }
}

data "vsphere_datacenter" "datacenter" {
  name = var.vsphere_datacenter
}

data "vsphere_network" "network" {
  name          = var.vsphere_network
  datacenter_id = data.vsphere_datacenter.datacenter.id
}

data "vsphere_compute_cluster" "cluster" {
  name          = var.vsphere_cluster
  datacenter_id = data.vsphere_datacenter.datacenter.id
}

data "vsphere_resource_pool" "pool" {
  name          = format("%s%s", data.vsphere_compute_cluster.cluster.name, "/Resources")
  datacenter_id = data.vsphere_datacenter.datacenter.id
}

data "vsphere_datastore" "datastore" {
  name          = var.vsphere_datastore
  datacenter_id = data.vsphere_datacenter.datacenter.id
}

data "vsphere_content_library" "content_library" {
  name = var.vsphere_content_library
}

data "vsphere_content_library_item" "content_library_item" {
  name       = var.vsphere_content_library_ovf
  type       = "ovf"
  library_id = data.vsphere_content_library.content_library.id
}

resource "vsphere_virtual_machine" "vm" {
  name                       = var.vm_name
  folder                     = var.vsphere_folder
  num_cpus                   = var.vm_cpus
  memory                     = var.vm_memory
  firmware                   = var.vm_firmware
  efi_secure_boot_enabled    = var.vm_efi_secure_boot_enabled
  datastore_id               = data.vsphere_datastore.datastore.id
  resource_pool_id           = data.vsphere_resource_pool.pool.id
  wait_for_guest_net_timeout = 0
  
  network_interface {
    network_id = data.vsphere_network.network.id
  }
  disk {
    label            = "${var.vm_name}-disk"
    size             = var.vm_disk_size
    thin_provisioned = true
  }
  clone {
    template_uuid = data.vsphere_content_library_item.content_library_item.id
  }
  lifecycle {
    ignore_changes = [
      clone[0].template_uuid,
    ]
  }

  extra_config = {
    "guestinfo.metadata"          = "${base64encode(data.template_file.metadata_yml.rendered)}"
    "guestinfo.metadata.encoding" = "base64"
    "guestinfo.userdata"          = "${base64encode(data.template_file.userdata_yml.rendered)}"
    "guestinfo.userdata.encoding" = "base64"
  }

}

terraform.tfvars:

vsphere_server   = "server"
vsphere_username = ""
vsphere_password = ""

vsphere_datacenter          = "datacenter"
vsphere_cluster             = "cluster"
vsphere_datastore           = "datastore"
vsphere_folder              = "LAB"

vsphere_content_library     = "Test"
vsphere_content_library_ovf = ""

vm_name                     = ""
vm_cpus                     = 2
vm_memory                   = 4096
vm_disk_size                = 100

vm_ipv4_netmask             = "22"
vm_ipv4                     = "10.217.168.130"
vm_ipv4_gateway             = "10.217.168.1"
vsphere_network             = "vds-network"

metadata.yml:

instance-id: ubuntu-cloud-init
local-hostname: '${vm_name}'
network:
  version: 2
  ethernets:
    ens192:
      dhcp4: false
      dhcp6: false
      addresses:
        - '${vm_ip}'
      gateway4: '${vm_ipv4_gateway}'
      nameservers:
        addresses:
          - 10.217.0.10
          - 10.217.0.11
runcmd:
  - netplan apply

I'll try with the default project. I'll post results asap.