Proxmox VE: Automatische Generierung von Templates für VMs

In der Welt der Servervirtualisierung spielt Effizienz eine entscheidende Rolle. Proxmox VE, eine führende Open-Source-Plattform für Virtualisierung und Containerisierung, bietet eine robuste und flexible Umgebung für das Management von virtuellen Maschinen und Containern. Doch selbst mit den fortschrittlichen Funktionen von Proxmox kann die Erstellung und Verwaltung von VM-Templates zeitaufwendig und komplex sein.

Warum Templates automatisch erstellen?

Proxmox bietet seit geraumer Zeit die Möglichkeit Cloud-init Images zu verwenden und somit automatisch Benutzername, Passwort und Netzwerkadressen direkt bei der Erstellung zu vergeben. Jedoch gibt es oft Probleme, da nicht alle Images SSH aktiviert oder den Qemu Guest Agent vorinstalliert haben,

Als Hosting-Anbieter störte uns die lange Auswahl von geeigneten Cloud-Images, die auch noch unterschiedliche VM-Konfigurationen benötigen, weswegen wir nach einer besseren Lösung suchten. Wir wollten einheitliche Templates mit einer großen Auswahl an Distributionen für unsere Kundenserver erstellen, die eine entsprechende Hardwarekonfigurationen vorweisen und für Kunden direkt ab Start via Login zugänglich sind.

Wie funktioniert Cloud-init?

Um unser vorgestelltes Bash-Skript zu verstehen sind grundlegende Kenntnisse im Umgang mit Cloud-init erforderlich. An dieser Stelle kann ich dazu den Wiki-Beitrag von Proxmox empfehlen.

Vorstellung des Skriptes

Die resultierende Lösung ist ein selbst programmiertes Bash-Skript, dass alle ausgewählten Distributionen in mehreren Versionen automatisch herunterladen kann und diese in Proxmox einpflegt.

Quellen für Cloud-init Images

Viele der verfügbaren Images sind über die Websites der Distributionen erhältlich, eine Liste zur Übersicht findet man auch auf OpenStack.

Hier verwenden wir hauptsächlich Images von Debian, Ubuntu, Fedora, CentOS, aber auch AlmaLinux. Über die Liste können aber beliebig viele weitere hinzugefügt werden.

Entsprechend beginnen wir unser Skript mit der Definition der Download-Quellen der Images. Zu beachten ist hier die Reservierung der IDs. In unserem Beispiel haben wir den 9000er Block gewählt, wobei jede Distribution einen 100er Block erhält. Sollten also zukünftig neue Versionen der Distributionen veröffentlicht werden, wird sichergestellt, dass diese sich nicht überschneiden und in aufsteigender Reihenfolge angelegt werden.

Definition der Quell-Images

# Sources using Openstack images
declare -A sources
declare -A template_ids
declare -A result_ids

template_ids["debian"]=9000
template_ids["ubuntu"]=9100
template_ids["almalinux"]=9200
template_ids["fedora"]=9300
template_ids["centos"]=9400

# Debian Versions
sources["debian-12"]="http://cdimage.debian.org/cdimage/cloud/bookworm/latest/debian-12-generic-amd64.qcow2"
sources["debian-11"]="http://cdimage.debian.org/cdimage/cloud/bullseye/latest/debian-11-generic-amd64.qcow2"
sources["debian-10"]="http://cdimage.debian.org/cdimage/openstack/current-10/debian-10-openstack-amd64.qcow2"

# Ubuntu Versions
# Here we use a kvm image, because they are smaller than the openstack images
sources["ubuntu-23.10"]="https://cloud-images.ubuntu.com/mantic/current/mantic-server-cloudimg-amd64-disk-kvm.img"
sources["ubuntu-23.04"]="https://cloud-images.ubuntu.com/lunar/current/lunar-server-cloudimg-amd64-disk-kvm.img"
sources["ubuntu-22.10"]="https://cloud-images.ubuntu.com/kinetic/current/kinetic-server-cloudimg-amd64-disk-kvm.img"
sources["ubuntu-22.04"]="https://cloud-images.ubuntu.com/jammy/current/jammy-server-cloudimg-amd64-disk-kvm.img"
sources["ubuntu-20.04"]="https://cloud-images.ubuntu.com/focal/current/focal-server-cloudimg-amd64-disk-kvm.img"
sources["ubuntu-18.04"]="https://cloud-images.ubuntu.com/bionic/current/bionic-server-cloudimg-amd64.img"
sources["ubuntu-16.04"]="https://cloud-images.ubuntu.com/xenial/current/xenial-server-cloudimg-amd64-disk1.img"

# AlmaLinux Versions
sources["almalinux-9"]="https://repo.almalinux.org/almalinux/9/cloud/x86_64/images/AlmaLinux-9-GenericCloud-latest.x86_64.qcow2"
sources["almalinux-8"]="https://repo.almalinux.org/almalinux/8/cloud/x86_64/images/AlmaLinux-8-GenericCloud-latest.x86_64.qcow2"

# Fedora Versions
sources["fedora-38"]="https://download.fedoraproject.org/pub/fedora/linux/releases/38/Cloud/x86_64/images/Fedora-Cloud-Base-38-1.6.x86_64.qcow2"

# CentOS Versions
sources["centos-stream-9"]="https://cloud.centos.org/centos/9-stream/x86_64/images/CentOS-Stream-GenericCloud-9-latest.x86_64.qcow2"

Images automatisch herunterladen

Weiterhin wollen wir eine Funktion definieren um die Templates herunterzuladen, sowie eine Funktion, um zu überprüfen ob ein Template mit der vergebenen ID bereits existiert. Wir verwenden hier wget, natürlich kann aber auch eine Alternative wie curl eingesetzt werden.

Funktionen download_template und vm_exists

download_template() {
    echo "[*] Downloading template $1..."
    wget -q --show-progress -O "$2" "$1"
    echo "[*] Download complete."
}

vm_exists() {
  qm list | grep -q "$1"
}

Überprüfungen und Benutzereingaben im Skript

Zunächst wollen wir überprüfen ob das Skript auch als root ausgeführt wird und es überhaupt auf einem Proxmox Node ausgeführt wird. Das machen wir wie folgt:

Grundlegende Überprüfungen

# Check if script is run with root permissions
if [ "$(id -u)" != "0" ]; then
    echo "[x] Please run this script with root privileges."
    exit 1
fi

# Check if Proxmox is installed
if ! [ -f /etc/pve/pve-root-ca.pem ]; then
    echo "[x] Proxmox is not installed, please run this script in a Proxmox Environment."
    exit 1
fi

Als nächstes installieren wir ein paar Dependencies. Wir haben hier dialog für Benutzereingaben und libguestfs-tools zum Editieren der Images verwendet - dazu aber gleich mehr.

Wichtige Dependencies installieren

echo "[*] Installing dependencies..."
apt -qq install -y libguestfs-tools wget dialog &> /dev/null

Nun wollen wir aber auch ein paar Eingaben vom Benutzer abfragen. Wichtig ist hier auf welchem Storage in Proxmox die Templates erstellt werden, ob die verwendeten Images wieder gelöscht werden, aber auch ob existierende Templates neu erstellt werden sollen. Ein weiterer Punkt ist, ob standartmäßig der CPU Typ auf host statt kvm64 gesetzt werden sollte, da dieser meist eine etwas bessere Performance bietet.

Danach lassen wir den Anwender auswählen welche der zuvor definierten Images auch eingepflegt werden sollen. Das geschieht über eine interaktive Auswahl als Checkliste.

Benutzereingaben realisieren

# Let user enter a storage name
read -p "[?] Please enter a the name for the storage to save the template machines to (default=local-lvm): " -r storage
storage=${storage:-"local-lvm"}

# Let user choose whether to delete templates after creation
read -p "[?] Do you want to delete the downloaded images after creation? (y/n, default=y): " -r delete_templates
delete_templates=${delete_templates:-y}

read -p "[?] Do you want to delete existing templates? (y/n, default=n): " -r delete_previous
delete_previous=${delete_previous:-n}

read -p "[?] Use CPU type host instead of kvm64 by default? (y/n, default=y): " -r use_cpu_host
use_cpu_host=${use_cpu_host:-y}

clear

# Let user select distros to download
cmd=(dialog --separate-output --title "Distro Selection" --checklist "Select distros to create templates for:" 22 76 16)
options=(
    $(for key in "${!sources[@]}"; do
        echo "$key"
        echo "$key"
        echo "on"
    done)
)
choices=$("${cmd[@]}" "${options[@]}" 2>&1 >/dev/tty)

clear

Die Umsetzung der Eingaben sieht nun so aus:

Löschung vorheriger Templates

# Check if storage exists in Proxmox
if ! (pvesm list "$storage" | grep -q "$storage"); then
    echo "[x] Storage does not exist in Proxmox or does not have any hosts, please choose another name."
    exit 1
fi

# Delete existing templates
if [ "$delete_previous" = "y" ]; then
    echo "[*] Deleting existing templates..."

    vm_list=$(qm list | grep template | awk '{print $1}')
    for vm_id in "${template_ids[@]}"; do
        for i in $(seq $vm_id $(($vm_id + ${#sources[@]}))); do
            if echo "$vm_list" | grep -q "$i"; then
                qm destroy "$i"
            fi
        done
    done

    echo "[*] Deletion complete."
fi

Erstellung der VM-Templates

Jetzt kommen wir zum Herzstück des Skripts. Wir gehen durch alle ausgewählten Distributionen und erstellen diese, falls sie noch nicht existieren.

Download der Templates in das /tmp Verzeichnis

start=$(date +%s)

sorted=$(for i in "${!choices[@]}"; do echo "${choices[i]}"; done | sort)
for source in $sorted; do
   if vm_exists "template-$source"; then
       echo "[*] Template for $source already exists, skipping..."
       continue
    fi

   distro=$(echo "$source" | cut -d'-' -f1)
   vm_id=${template_ids[$distro]}

   while vm_exists "$vm_id"; do
       echo "[*] VM with ID $vm_id already exists, trying next id..."
       vm_id=$(($vm_id + 1))
    done

    echo "[*] Creating template for $source..."

    extension="${sources[$source]##*.}"
    image_path="/tmp/$source.$extension"
    download_template "${sources[$source]}" "$image_path"

Im ersten Teil der Schleifen haben wir die Templates im /tmp Verzeichnis gespeichert. Damit die Images aber direkt SSH Login aktiviert haben, müssen wir die sshd_config und die cloud.cfg des Images anpassen. Dazu verwenden wir das Tool virt-customize, mit dem man direkt im Image Dateien bearbeiten kann. Gleichzeitig installieren wir den Qemu Quest Agent (qemu-quest-agent). Wir gleichen durch sed verschiedene SSH Szenarien ab und setzen die notwendigen Optionen auf yes.

Anpassung des Images mittels virt-customize

    echo "[*] Customizing image, please wait..."
    virt-customize -a "$image_path" \
        --install qemu-guest-agent \
        --run-command 'sed -i "s/ssh_pwauth:.*0/ssh_pwauth: 1/" /etc/cloud/cloud.cfg' \
        --run-command 'sed -i "s/ssh_pwauth:.*[Ff]alse/ssh_pwauth: true/" /etc/cloud/cloud.cfg' \
        --run-command 'sed -i "s/disable_root:.*[Tt]rue/disable_root: false/" /etc/cloud/cloud.cfg' \
        --run-command 'sed -i "s/disable_root:.*1/disable_root: 0/" /etc/cloud/cloud.cfg' \
        --run-command 'sed -i "s/lock_passwd:.*[Tt]rue/lock_passwd: false/" /etc/cloud/cloud.cfg' \
        --run-command 'sed -i "s/lock_passwd:.*1/lock_passwd: 0/" /etc/cloud/cloud.cfg' \
        --run-command 'sed -i "s/PasswordAuthentication no/PasswordAuthentication yes/" /etc/ssh/sshd_config' \
        --run-command 'sed -i "s/PermitRootLogin [Nn]o/PermitRootLogin yes/" /etc/ssh/sshd_config' \
        --run-command 'sed -i "s/#PermitRootLogin [Yy]es/PermitRootLogin yes/" /etc/ssh/sshd_config' \
        --run-command 'sed -i "s/#PermitRootLogin prohibit-password/PermitRootLogin yes/" /etc/ssh/sshd_config' \
        --run-command 'sed -i "s/KbdInteractiveAuthentication [Nn]o/#KbdInteractiveAuthentication no/" /etc/ssh/sshd_config' \
        --run-command 'sed -i "s/[#M]axAuthTries 6/MaxAuthTries 20/" /etc/ssh/sshd_config' \
        --no-logfile

Abschließend muss natürlich das Template selbst in Proxmox erstellt werden. Hierfür generieren wir programmatisch eine VM, die wir danach in ein Template umwandeln.

Dazu einige wichtige Hinweise:

CPU Typ: Manche Cloud-init Images benötigen den CPU Typ x86_64. Diesen Fall haben wir abgedeckt in dem die URL der Quelle auf dieses Flag überprüft wird. Ob ein Image dieses Flag benötigt lässt sich manchmal nicht direkt sagen, jedoch kommt es hauptsächlich bei neueren Images vor.
Hardware Einstellungen: Hier erstellen wir die Templates mit 512 MiB RAM und 4 Kernen, einer Netzwerkkarte auf vmbr0 und mit aktiver Firewall-Funktion, sowie aktivem Quest Agent. Das sollte an eure Anforderungen angepasst werden, falls andere Einstellungen benötigt werden.
Speicherplatz: Am Ende wird auf den Speicherplatz der VM 2 GiB draufgerechnet, da diese sonst nicht bootfähig ist. Der ursprüngliche Speicher ist nämlich nur auf die Größe des Images beschränkt. An dieser Stelle kann aber auch beliebig viel zugewiesen werden.

Wir speichern die generierten Templates in einer Liste, um sie am Ende auszugeben.

Erstellung der VM-Templates in Proxmox

    echo "[*] Creating new VM with ID $vm_id..."
    is_x86_64_v2=$(echo "${sources[$source]}" | grep -c "x86_64")
    cpu_type="kvm64"
    if [ "$use_cpu_host" = "y" ]; then
        cpu_type="host"
    fi

    if [ "$is_x86_64_v2" -eq 1 ]; then
        cpu_type="x86-64-v2"
    fi

    qm create $vm_id --name "template-$source" --memory 512 --cores 4 --net0 virtio,bridge=vmbr0,firewall=1 --agent enabled=1,fstrim_cloned_disks=1 --cpu $cpu_type

    echo "[*] Importing template image..."
    qm importdisk $vm_id "/tmp/$source.$extension" "$storage" -format qcow2

    echo "[*] Attaching disk to template..."
    qm set $vm_id --scsihw virtio-scsi-pci --scsi0 "$storage:vm-$vm_id-disk-0"

    echo "[*] Applying important settings..."
    qm set $vm_id --ide2 "$storage:cloudinit" --boot c --bootdisk scsi0 --serial0 socket --vga serial0

    echo "[*] Resizing disk..."
    qm resize $vm_id scsi0 +2G

    echo "[*] Creating template from VM..."
    qm template $vm_id

    if [ "$delete_templates" = "y" ]; then
      echo "[*] Deleting downloaded image file:"
      rm -v $image_path
    fi

    result_ids[$source]="$vm_id"
    template_ids[$distro]=$(($vm_id+1))

    echo "[*] Template creation for $source complete."
done

Ausgabe der erstellten Templates

Damit wir den Überblick behalten geben wir nach Beendigung des Skripts noch aus welche Templates genau unter welcher ID angelegt wurden und wie lange es gedauert hat.

Abschluss: Ausgabe der erstellten Templates

end=$(date +%s)
echo "[*] Script execution finished after $((($end-$start)/60)) min $((($end-$start)%60)) sec."

created_count=${#result_ids[@]}
if [ "$created_count" -eq 0 ]; then
    echo "[!] No new templates were created."
    exit 0
else
  echo "[*] The following templates were created:"
  for source in "${!result_ids[@]}"; do
      echo "    - $source: ${result_ids[$source]}"
  done
fi

Das vollständige Skript

Wer das Skript nun selbst einmal ausprobieren möchte oder Anpassungen vornehmen will, findet hier die komplette Version. Ich taufe dieses Skript auf den Namen "t-create" und werde es auch auf meinem GitHub zu Verfügung stellen. Das Gist dazu findet ihr hier.

Vollständiges Skript zur Erstellung von Proxmox Templates

#!/bin/bash

# Sources using Openstack images
declare -A sources
declare -A template_ids
declare -A result_ids

template_ids["debian"]=9000
template_ids["ubuntu"]=9100
template_ids["almalinux"]=9200
template_ids["fedora"]=9300
template_ids["centos"]=9400

# Debian Versions
sources["debian-12"]="http://cdimage.debian.org/cdimage/cloud/bookworm/latest/debian-12-generic-amd64.qcow2"
sources["debian-11"]="http://cdimage.debian.org/cdimage/cloud/bullseye/latest/debian-11-generic-amd64.qcow2"
sources["debian-10"]="http://cdimage.debian.org/cdimage/openstack/current-10/debian-10-openstack-amd64.qcow2"

# Ubuntu Versions
# Here we use a kvm image, because they are smaller than the openstack images
sources["ubuntu-23.10"]="https://cloud-images.ubuntu.com/mantic/current/mantic-server-cloudimg-amd64-disk-kvm.img"
sources["ubuntu-23.04"]="https://cloud-images.ubuntu.com/lunar/current/lunar-server-cloudimg-amd64-disk-kvm.img"
sources["ubuntu-22.10"]="https://cloud-images.ubuntu.com/kinetic/current/kinetic-server-cloudimg-amd64-disk-kvm.img"
sources["ubuntu-22.04"]="https://cloud-images.ubuntu.com/jammy/current/jammy-server-cloudimg-amd64-disk-kvm.img"
sources["ubuntu-20.04"]="https://cloud-images.ubuntu.com/focal/current/focal-server-cloudimg-amd64-disk-kvm.img"
sources["ubuntu-18.04"]="https://cloud-images.ubuntu.com/bionic/current/bionic-server-cloudimg-amd64.img"
sources["ubuntu-16.04"]="https://cloud-images.ubuntu.com/xenial/current/xenial-server-cloudimg-amd64-disk1.img"

# AlmaLinux Versions
sources["almalinux-9"]="https://repo.almalinux.org/almalinux/9/cloud/x86_64/images/AlmaLinux-9-GenericCloud-latest.x86_64.qcow2"
sources["almalinux-8"]="https://repo.almalinux.org/almalinux/8/cloud/x86_64/images/AlmaLinux-8-GenericCloud-latest.x86_64.qcow2"

# Fedora Versions
sources["fedora-38"]="https://download.fedoraproject.org/pub/fedora/linux/releases/38/Cloud/x86_64/images/Fedora-Cloud-Base-38-1.6.x86_64.qcow2"

# CentOS Versions
sources["centos-stream-9"]="https://cloud.centos.org/centos/9-stream/x86_64/images/CentOS-Stream-GenericCloud-9-latest.x86_64.qcow2"

download_template() {
    echo "[*] Downloading template $1..."
    wget -q --show-progress -O "$2" "$1"
    echo "[*] Download complete."
}

vm_exists() {
  qm list | grep -q "$1"
}

echo "  _                             _       "
echo " | |                           | |      "
echo " | |_ ______ ___ _ __ ___  __ _| |_ ___ "
echo " | __|______/ __| '__/ _ \\/ _\` | __/ _ \\"
echo " | |_      | (__| | |  __/ (_| | ||  __/"
echo "  \__|      \___|_|  \___|\__,_|\__\___|"
echo ""
echo "   > Create Proxmox Templates <"
echo "        by @masterjanic"
echo ""


# Check if script is run with root permissions
if [ "$(id -u)" != "0" ]; then
    echo "[x] Please run this script with root privileges."
    exit 1
fi

# Check if Proxmox is installed
if ! [ -f /etc/pve/pve-root-ca.pem ]; then
    echo "[x] Proxmox is not installed, please run this script in a Proxmox Environment."
    exit 1
fi

echo "[*] Installing dependencies..."
apt -qq install -y libguestfs-tools wget dialog &> /dev/null

# Let user enter a storage name
read -p "[?] Please enter a the name for the storage to save the template machines to (default=local-lvm): " -r storage
storage=${storage:-"local-lvm"}

# Let user choose whether to delete templates after creation
read -p "[?] Do you want to delete the downloaded images after creation? (y/n, default=y): " -r delete_templates
delete_templates=${delete_templates:-y}

read -p "[?] Do you want to delete existing templates? (y/n, default=n): " -r delete_previous
delete_previous=${delete_previous:-n}

read -p "[?] Use CPU type host instead of kvm64 by default? (y/n, default=y): " -r use_cpu_host
use_cpu_host=${use_cpu_host:-y}

clear

# Let user select distros to download
cmd=(dialog --separate-output --title "Distro Selection" --checklist "Select distros to create templates for:" 22 76 16)
options=(
    $(for key in "${!sources[@]}"; do
        echo "$key"
        echo "$key"
        echo "on"
    done)
)
choices=$("${cmd[@]}" "${options[@]}" 2>&1 >/dev/tty)

clear

# Check if storage exists in Proxmox
if ! (pvesm list "$storage" | grep -q "$storage"); then
    echo "[x] Storage does not exist in Proxmox or does not have any hosts, please choose another name."
    exit 1
fi

# Delete existing templates
if [ "$delete_previous" = "y" ]; then
    echo "[*] Deleting existing templates..."

    vm_list=$(qm list | grep template | awk '{print $1}')
    for vm_id in "${template_ids[@]}"; do
        for i in $(seq $vm_id $(($vm_id + ${#sources[@]}))); do
            if echo "$vm_list" | grep -q "$i"; then
                qm destroy "$i"
            fi
        done
    done

    echo "[*] Deletion complete."
fi

start=$(date +%s)

sorted=$(for i in "${!choices[@]}"; do echo "${choices[i]}"; done | sort)
for source in $sorted; do
   if vm_exists "template-$source"; then
       echo "[*] Template for $source already exists, skipping..."
       continue
    fi

   distro=$(echo "$source" | cut -d'-' -f1)
   vm_id=${template_ids[$distro]}

   while vm_exists "$vm_id"; do
       echo "[*] VM with ID $vm_id already exists, trying next id..."
       vm_id=$(($vm_id + 1))
    done

    echo "[*] Creating template for $source..."

    extension="${sources[$source]##*.}"
    image_path="/tmp/$source.$extension"
    download_template "${sources[$source]}" "$image_path"

    echo "[*] Customizing image, please wait..."
    virt-customize -a "$image_path" \
        --install qemu-guest-agent \
        --run-command 'sed -i "s/ssh_pwauth:.*0/ssh_pwauth: 1/" /etc/cloud/cloud.cfg' \
        --run-command 'sed -i "s/ssh_pwauth:.*[Ff]alse/ssh_pwauth: true/" /etc/cloud/cloud.cfg' \
        --run-command 'sed -i "s/disable_root:.*[Tt]rue/disable_root: false/" /etc/cloud/cloud.cfg' \
        --run-command 'sed -i "s/disable_root:.*1/disable_root: 0/" /etc/cloud/cloud.cfg' \
        --run-command 'sed -i "s/lock_passwd:.*[Tt]rue/lock_passwd: false/" /etc/cloud/cloud.cfg' \
        --run-command 'sed -i "s/lock_passwd:.*1/lock_passwd: 0/" /etc/cloud/cloud.cfg' \
        --run-command 'sed -i "s/PasswordAuthentication no/PasswordAuthentication yes/" /etc/ssh/sshd_config' \
        --run-command 'sed -i "s/PermitRootLogin [Nn]o/PermitRootLogin yes/" /etc/ssh/sshd_config' \
        --run-command 'sed -i "s/#PermitRootLogin [Yy]es/PermitRootLogin yes/" /etc/ssh/sshd_config' \
        --run-command 'sed -i "s/#PermitRootLogin prohibit-password/PermitRootLogin yes/" /etc/ssh/sshd_config' \
        --run-command 'sed -i "s/KbdInteractiveAuthentication [Nn]o/#KbdInteractiveAuthentication no/" /etc/ssh/sshd_config' \
        --run-command 'sed -i "s/[#M]axAuthTries 6/MaxAuthTries 20/" /etc/ssh/sshd_config' \
        --no-logfile

    echo "[*] Creating new VM with ID $vm_id..."
    is_x86_64_v2=$(echo "${sources[$source]}" | grep -c "x86_64")
    cpu_type="kvm64"
    if [ "$use_cpu_host" = "y" ]; then
        cpu_type="host"
    fi

    if [ "$is_x86_64_v2" -eq 1 ]; then
        cpu_type="x86-64-v2"
    fi

    qm create $vm_id --name "template-$source" --memory 512 --cores 4 --net0 virtio,bridge=vmbr0,firewall=1 --agent enabled=1,fstrim_cloned_disks=1 --cpu $cpu_type

    echo "[*] Importing template image..."
    qm importdisk $vm_id "/tmp/$source.$extension" "$storage" -format qcow2

    echo "[*] Attaching disk to template..."
    qm set $vm_id --scsihw virtio-scsi-pci --scsi0 "$storage:vm-$vm_id-disk-0"

    echo "[*] Applying important settings..."
    qm set $vm_id --ide2 "$storage:cloudinit" --boot c --bootdisk scsi0 --serial0 socket --vga serial0

    echo "[*] Resizing disk..."
    qm resize $vm_id scsi0 +2G

    echo "[*] Creating template from VM..."
    qm template $vm_id

    if [ "$delete_templates" = "y" ]; then
      echo "[*] Deleting downloaded image file:"
      rm -v $image_path
    fi

    result_ids[$source]="$vm_id"
    template_ids[$distro]=$(($vm_id+1))

    echo "[*] Template creation for $source complete."
done

end=$(date +%s)
echo "[*] Script execution finished after $((($end-$start)/60)) min $((($end-$start)%60)) sec."

created_count=${#result_ids[@]}
if [ "$created_count" -eq 0 ]; then
    echo "[!] No new templates were created."
    exit 0
else
  echo "[*] The following templates were created:"
  for source in "${!result_ids[@]}"; do
      echo "    - $source: ${result_ids[$source]}"
  done
fi

Fazit: Sollte ich Templates generieren?

Zusammenfassend lässt sich sagen, dass das Skript zur Generierung von Templates in Proxmox VE eine wertvolle Ressource für eine Vielzahl von Anwendern darstellt. Es ist besonders vorteilhaft für Systemadministratoren und IT-Fachleute, die regelmäßig mit der Einrichtung und Verwaltung von virtuellen Maschinen in einer Proxmox-Umgebung betraut sind. Durch die Automatisierung des Erstellungsprozesses von VM-Templates spart das Skript nicht nur wertvolle Zeit, sondern reduziert auch das Risiko von menschlichen Fehlern, die bei manueller Einrichtung auftreten können.

Darüber hinaus ist dieses Tool eine ausgezeichnete Wahl für Organisationen, die ihre IT-Infrastruktur skalieren möchten. Es ermöglicht eine schnelle und effiziente Bereitstellung von VMs, was für Unternehmen entscheidend ist, die auf eine agile und reaktionsfähige IT angewiesen sind. Auch für Bildungseinrichtungen und Forschungsabteilungen, die häufig experimentelle oder temporäre VM-Umgebungen benötigen, kann das Skript von großem Nutzen sein.

Letztlich bietet unser Skript eine Lösung, die nicht nur Zeit und Aufwand spart, sondern auch die Konsistenz und Qualität der VM-Templates in Proxmox VE-Umgebungen erhöht. Es ist ein unverzichtbares Werkzeug für jeden, der nach einer effizienteren, zuverlässigeren und automatisierten Methode zur Verwaltung seiner virtuellen Infrastruktur sucht.

Proxmox VE: Skript zur Generierung von Templates