braniz/virtualbox
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

VDIs verbessert

Browse Source
This commit is contained in:
braniz
2024-08-22 21:03:01 +02:00
parent 572a78597c
commit 28c2feee98
8 changed files with 1430 additions and 172 deletions
Download Patch File Download Diff File Expand all files Collapse all files

272
iso.sh_org Normal file
View File

@@ -0,0 +1,272 @@
#!/bin/bash
# Autor: Branislav Zeljak v0.9
# Beschreibung: Dieses Skript erstellt VirtualBox-VMs und klont Festplatten parallel.
# Verwendung: Führen Sie das Skript aus und befolgen Sie die Eingabeaufforderungen.
clear
# %--------------------start/Funktionen--------------------%
# Funktion zum Überprüfen der Benutzerexistenz
check_user_existence() {
local VAR_USER_IN_GROUP="$1"
if ! grep -q "^$VAR_USER_IN_GROUP:" /etc/passwd; then
echo "Der Benutzer $VAR_USER_IN_GROUP existiert nicht auf diesem System."
exit 1
fi
}
get_group_users() {
local groupname="$1"
local members
members=$(getent group "$groupname" | cut -d: -f4)
if [[ -n "$members" ]]; then
echo "$members" | tr ',' '\n'
else
echo "Die Gruppe $groupname existiert nicht oder hat keine Mitglieder."
fi
}
# Funktion, um einen zufälligen Host-Namen aus der Liste auszuwählen
get_random_name() {
# Liste der Namen
local names=("frodo" "samweis" "gandalf" "aragorn" "legolas" "gimli" "boromir" "meriadoc" "peregrin" "arwen" "galadriel" "celeborn" "elrond" "glorfindel" "faramir" "eowyn" "theoden" "treebeard" "gollum" "sauron" "saruman" "bilbo" "denethor" "radagast" "thranduil" "bard" "dori" )
# Zufälligen Index auswählen
local random_index=$((RANDOM % ${#names[@]}))
echo "${names[random_index]}"
}
# Funktion zur Generierung eines eindeutigen RDP-Ports
generate_rdp_port() {
local rdp_port
rdp_port=$(shuf -i 3390-49151 -n 1)
echo "$rdp_port"
}
# Funktion zum Suchen einer ISO-Datei basierend auf einem Muster
find_iso_files() {
local iso_dir="$1"
find "$iso_dir" -type f -name "*.iso" | sort
}
# Funktion, um das Betriebssystem basierend auf der ISO-Datei zu identifizieren
identify_os() {
local iso_file="$1"
case "$(basename "$iso_file")" in
*ubuntu*server*)
echo "Ubuntu_64"
;;
*ubuntu*desktop*)
echo "Ubuntu_64"
;;
*debian*)
echo "Debian_64"
;;
*rhel*)
echo "RedHat_64"
;;
*Fedora-Workstation*)
echo "Fedora_64"
;;
*Fedora-Server*)
echo "Fedora_64"
;;
*kali-linux*)
echo "kali-linux"
;;
*linuxmint*)
echo "Linux_64"
;;
*openSUSE*)
echo "OpenSUSE_64"
;;
*manjaro*)
echo "ArchLinux_64"
;;
*)
echo "Unbekannt"
;;
esac
}
# %--------------------end/Funktionen--------------------%
echo "User / Passwort: user00/Start1234"
echo "Welches VDI-OS soll installiert werden?"
echo
echo "Für wen soll es sein?"
echo
COLUMNS=10
PS3="Ihre Auswahl: "
options=("Aktueller Benutzer" "Anderer Benutzer" "Mitglieder einer Gruppe" "Beenden")
select opt in "${options[@]}"
do
case $opt in
"Aktueller Benutzer")
VAR_GROUP_MEMBERS=$(whoami)
;;
"Anderer Benutzer")
read -p "Bitte geben Sie einen Benutzernamen ein: " VAR_GROUP_MEMBERS
if grep -q "^$VAR_GROUP_MEMBERS:" /etc/passwd; then
echo "Der Benutzer $VAR_GROUP_MEMBERS existiert auf diesem System."
else
echo "Der Benutzer $VAR_GROUP_MEMBERS existiert nicht auf diesem System."
exit 1
fi
;;
"Mitglieder einer Gruppe")
read -p "Bitte geben Sie den Gruppennamen ein: " VAR_GROUP
if getent group "$VAR_GROUP" &>/dev/null; then
echo "Mitglieder der Gruppe $VAR_GROUP:"
get_group_users "$VAR_GROUP"
VAR_GROUP_MEMBERS=($(get_group_users "$VAR_GROUP"))
else
echo "Die Gruppe $VAR_GROUP existiert nicht auf diesem System."
exit 1
fi
;;
"Beenden")
exit
;;
esac
break
done
# Variable für das Verzeichnis
VAR_VB="/storage/vbox_storage"
# Verzeichnis mit ISO-Dateien
ISO_DIR="/srv/data/ISO/"
echo "Verfügbare ISO-Dateien werden durchsucht..."
echo
# Vorhandene ISO-Dateien finden und zur Auswahl anbieten
iso_files=($(find_iso_files "$ISO_DIR"))
if [ ${#iso_files[@]} -eq 0 ]; then
echo "Keine ISO-Dateien im Verzeichnis $ISO_DIR gefunden."
exit 1
fi
PS3="Bitte wählen Sie eine ISO-Datei aus: "
select iso_file in "${iso_files[@]}" "Beenden"
do
if [[ "$iso_file" == "Beenden" ]]; then
exit 0
fi
if [ -n "$iso_file" ]; then
selected_iso="$iso_file"
break
else
echo "Ungültige Auswahl. Bitte versuchen Sie es erneut."
fi
done
# Betriebssystem auf Basis der ausgewählten ISO identifizieren
os_name=$(identify_os "$selected_iso")
if [ "$os_name" == "Unbekannt" ]; then
echo "Das Betriebssystem konnte nicht automatisch erkannt werden."
read -p "Bitte geben Sie das Betriebssystem manuell ein: " os_name
fi
# Benutzerdefinierte Werte anfordern
default_name=$(get_random_name)
read -p "Wie viele VMs werden benötigt? [1]: " VAR_QUANTITY
VAR_QUANTITY=${VAR_QUANTITY:-1}
read -p "Präfix Host Name (Vorgabe: $default_name): " VAR_NAME_PREFIX
read -p "CPUs [2]: " VAR_CPU
VAR_CPU=${VAR_CPU:-2}
read -p "Memory [2048]: " VAR_MEM
VAR_MEM=${VAR_MEM:-2048}
read -p "Anzahl der HDDs (Standard: 1): " VAR_ADDITIONAL_HDD
VAR_ADDITIONAL_HDD=${VAR_ADDITIONAL_HDD:-1}
# Standardwerte festlegen, wenn keine Eingabe erfolgt
VAR_VIDEO_RAM=64
VAR_NIC1="nat"
VAR_NIC2="bridged"
VAR_NET=$(ip addr show | grep "^2: " | awk '{print $2}' | sed 's/://')
VAR_NAME_PREFIX=${VAR_NAME_PREFIX:-$default_name}
# Schleife zur Erzeugung der VMs für jeden Benutzer in der Gruppe
for VAR_USER_IN_GROUP in "${VAR_GROUP_MEMBERS[@]}"
do
# Generiere einen eindeutigen RDP-Port
VAR_RDP_PORT=$(generate_rdp_port)
# Schleife zur Erzeugung der angeforderten Anzahl von VMs
for ((i = 1; i <= VAR_QUANTITY; i++))
do
# VM erstellen
VM_NAME="${VAR_NAME_PREFIX}_${VAR_USER_IN_GROUP}_VM$(printf "%02d" $i)"
VM_DIR="$VAR_VB/$VAR_USER_IN_GROUP"
sudo -u "$VAR_USER_IN_GROUP" VBoxManage createvm \
--name "$VM_NAME" \
--ostype "$os_name" \
--register \
--basefolder "$VM_DIR"
# VM-Konfigurieren
sudo -u "$VAR_USER_IN_GROUP" VBoxManage modifyvm "$VM_NAME" \
--ioapic on \
--memory "$VAR_MEM" \
--cpus "$VAR_CPU" \
--vram "$VAR_VIDEO_RAM" \
--nic1 $VAR_NIC1 \
--nic2 $VAR_NIC2 \
--bridgeadapter2 ${VAR_NET} \
--graphicscontroller "vboxsvga" \
--vrde on \
--vrdemulticon on \
--vrdeport "$VAR_RDP_PORT"
# Festplattencontroller hinzufügen
sudo -u "$VAR_USER_IN_GROUP" VBoxManage storagectl "$VM_NAME" \
--name "SATA Controller" \
--add sata \
--controller IntelAhci
sudo -u "$VAR_USER_IN_GROUP" VBoxManage storagectl "$VM_NAME" \
--name "IDE Controller" \
--add ide \
--controller PIIX4
sudo -u "$VAR_USER_IN_GROUP" VBoxManage storageattach "$VM_NAME" \
--storagectl "IDE Controller" \
--port 1 \
--device 0 \
--type dvddrive \
--medium "$selected_iso"
# Schleife zur Erzeugung von zusätzlichen Festplatten
for ((j = 1; j <= VAR_ADDITIONAL_HDD; j++))
do
HDD_NUM=$(printf "%02d" $j)
HDD_NAME="${VM_NAME}-disk${HDD_NUM}.vdi"
sudo -u "$VAR_USER_IN_GROUP" VBoxManage createhd \
--filename "$VM_DIR/$VM_NAME/$HDD_NAME" \
--size 102400 \
--format VDI
sudo -u "$VAR_USER_IN_GROUP" VBoxManage storageattach "$VM_NAME" \
--storagectl "SATA Controller" \
--port "$HDD_NUM" \
--device 0 \
--type hdd \
--medium "$VM_DIR/$VM_NAME/$HDD_NAME"
done
done
done
echo "VMs wurden für alle wie angegeben erstellt."

279
iso_2.sh Normal file
View File

@@ -0,0 +1,279 @@
#!/bin/bash
# Autor: Branislav Zeljak
# Version: v0.9
# Beschreibung: Dieses Skript erstellt VirtualBox-VMs und klont Festplatten parallel.
# Verwendung: Führen Sie das Skript aus und befolgen Sie die Eingabeaufforderungen.
clear
# %--------------------start/Funktionen--------------------%
# Funktion zum Überprüfen der Benutzerexistenz
check_user_existence() {
local VAR_USER_IN_GROUP="$1"
if ! grep -q "^$VAR_USER_IN_GROUP:" /etc/passwd; then
echo "Der Benutzer $VAR_USER_IN_GROUP existiert nicht auf diesem System."
exit 1
fi
}
get_group_users() {
local groupname="$1"
local members
members=$(getent group "$groupname" | cut -d: -f4)
if [[ -n "$members" ]]; then
echo "$members" | tr ',' '\n'
else
echo "Die Gruppe $groupname existiert nicht oder hat keine Mitglieder."
fi
}
# Funktion, um einen zufälligen Host-Namen aus der Liste auszuwählen
get_random_name() {
# Liste der Namen
local names=("frodo" "samweis" "gandalf" "aragorn" "legolas" "gimli" "boromir" "meriadoc" "peregrin" "arwen" "galadriel" "celeborn" "elrond" "glorfindel" "faramir" "eowyn" "theoden" "treebeard" "gollum" "sauron" "saruman" "bilbo" "denethor" "radagast" "thranduil" "bard" "dori")
# Zufälligen Index auswählen
local random_index=$((RANDOM % ${#names[@]}))
echo "${names[random_index]}"
}
# Funktion zur Generierung eines eindeutigen RDP-Ports
generate_rdp_port() {
local rdp_port
rdp_port=$(shuf -i 3390-49151 -n 1)
echo "$rdp_port"
}
# Funktion zum Suchen einer ISO-Datei basierend auf einem Muster
find_iso_files() {
local iso_dir="$1"
find "$iso_dir" -type f -name "*.iso" | sort
}
# Funktion, um das Betriebssystem basierend auf der ISO-Datei zu identifizieren
identify_os() {
local iso_file="$1"
case "$(basename "$iso_file")" in
*ubuntu*server*)
echo "Ubuntu_64"
;;
*ubuntu*desktop*)
echo "Ubuntu_64"
;;
*debian*)
echo "Debian_64"
;;
*rhel*)
echo "RedHat_64"
;;
*CentOS*)
echo "RedHat_64"
;;
*Fedora-Workstation*)
echo "Fedora_64"
;;
*Fedora-Server*)
echo "Fedora_64"
;;
*kali-linux*)
echo "kali-linux"
;;
*linuxmint*)
echo "Linux_64"
;;
*openSUSE*)
echo "OpenSUSE_64"
;;
*manjaro*)
echo "ArchLinux_64"
;;
*)
echo "Unbekannt"
;;
esac
}
# %--------------------end/Funktionen--------------------%
echo "User / Passwort: user00/Start1234"
echo "Welches VDI-OS soll installiert werden?"
echo
echo "Für wen soll es sein?"
echo
COLUMNS=10
PS3="Ihre Auswahl: "
options=("Aktueller Benutzer" "Anderer Benutzer" "Mitglieder einer Gruppe" "Beenden")
select opt in "${options[@]}"
do
case $opt in
"Aktueller Benutzer")
VAR_GROUP_MEMBERS=$(whoami)
;;
"Anderer Benutzer")
read -p "Bitte geben Sie einen Benutzernamen ein: " VAR_GROUP_MEMBERS
if ! check_user_existence "$VAR_GROUP_MEMBERS"; then
exit 1
fi
;;
"Mitglieder einer Gruppe")
read -p "Bitte geben Sie den Gruppennamen ein: " VAR_GROUP
if getent group "$VAR_GROUP" &>/dev/null; then
echo "Mitglieder der Gruppe $VAR_GROUP:"
get_group_users "$VAR_GROUP"
VAR_GROUP_MEMBERS=($(get_group_users "$VAR_GROUP"))
else
echo "Die Gruppe $VAR_GROUP existiert nicht auf diesem System."
exit 1
fi
;;
"Beenden")
exit
;;
esac
break
done
# Variable für das Verzeichnis
VAR_VB="/storage/vbox_storage"
# Verzeichnis mit ISO-Dateien
ISO_DIR="/srv/data/ISO/"
echo "Verfügbare ISO-Dateien werden durchsucht..."
echo
# Vorhandene ISO-Dateien finden und zur Auswahl anbieten
iso_files=($(find_iso_files "$ISO_DIR"))
if [ ${#iso_files[@]} -eq 0 ]; then
echo "Keine ISO-Dateien im Verzeichnis $ISO_DIR gefunden."
exit 1
fi
PS3="Bitte wählen Sie eine ISO-Datei aus: "
select iso_file in "${iso_files[@]}" "Beenden"
do
if [[ "$iso_file" == "Beenden" ]]; then
exit 0
fi
if [ -n "$iso_file" ]; then
selected_iso="$iso_file"
break
else
echo "Ungültige Auswahl. Bitte versuchen Sie es erneut."
fi
done
# Betriebssystem auf Basis der ausgewählten ISO identifizieren
os_name=$(identify_os "$selected_iso")
if [ "$os_name" == "Unbekannt" ]; then
echo "Das Betriebssystem konnte nicht automatisch erkannt werden."
read -p "Bitte geben Sie das Betriebssystem manuell ein: " os_name
fi
# Benutzerdefinierte Werte anfordern
default_name=$(get_random_name)
read -p "Wie viele VMs werden benötigt? [1]: " VAR_QUANTITY
VAR_QUANTITY=${VAR_QUANTITY:-1}
read -p "Präfix Host Name (Vorgabe: $default_name): " VAR_NAME_PREFIX
read -p "CPUs [2]: " VAR_CPU
VAR_CPU=${VAR_CPU:-2}
read -p "Memory [2048]: " VAR_MEM
VAR_MEM=${VAR_MEM:-2048}
read -p "Anzahl der HDDs (Standard: 1): " VAR_ADDITIONAL_HDD
VAR_ADDITIONAL_HDD=${VAR_ADDITIONAL_HDD:-1}
# Standardwerte festlegen, wenn keine Eingabe erfolgt
VAR_VIDEO_RAM=64
VAR_NIC1="nat"
VAR_NIC2="bridged"
VAR_NET=$(ip addr show | grep "^2: " | awk '{print $2}' | sed 's/://')
VAR_NAME_PREFIX=${VAR_NAME_PREFIX:-$default_name}
# Schleife zur Erzeugung der VMs für jeden Benutzer in der Gruppe
for VAR_USER_IN_GROUP in "${VAR_GROUP_MEMBERS[@]}"
do
# Generiere einen eindeutigen RDP-Port
VAR_RDP_PORT=$(generate_rdp_port)
# Schleife zur Erzeugung der angeforderten Anzahl von VMs
for ((i = 1; i <= VAR_QUANTITY; i++))
do
# VM erstellen
VM_NAME="${VAR_NAME_PREFIX}_${VAR_USER_IN_GROUP}_VM$(printf "%02d" $i)"
VM_DIR="$VAR_VB/$VAR_USER_IN_GROUP"
sudo -u "$VAR_USER_IN_GROUP" VBoxManage createvm \
--name "$VM_NAME" \
--ostype "$os_name" \
--register \
--basefolder "$VM_DIR"
# Prüfen, ob der Befehl erfolgreich war
if [ $? -ne 0 ]; then
echo "Fehler beim Erstellen der VM $VM_NAME."
continue
fi
# VM-Konfigurieren
sudo -u "$VAR_USER_IN_GROUP" VBoxManage modifyvm "$VM_NAME" \
--ioapic on \
--memory "$VAR_MEM" \
--cpus "$VAR_CPU" \
--vram "$VAR_VIDEO_RAM" \
--nic1 $VAR_NIC1 \
--nic2 $VAR_NIC2 \
--bridgeadapter2 ${VAR_NET} \
--graphicscontroller "vboxsvga" \
--vrde on \
--vrdemulticon on \
--vrdeport "$VAR_RDP_PORT"
# Festplattencontroller hinzufügen
sudo -u "$VAR_USER_IN_GROUP" VBoxManage storagectl "$VM_NAME" \
--name "SATA Controller" \
--add sata \
--controller IntelAhci
sudo -u "$VAR_USER_IN_GROUP" VBoxManage storagectl "$VM_NAME" \
--name "IDE Controller" \
--add ide \
--controller PIIX4
sudo -u "$VAR_USER_IN_GROUP" VBoxManage storageattach "$VM_NAME" \
--storagectl "IDE Controller" \
--port 1 \
--device 0 \
--type dvddrive \
--medium "$selected_iso"
# Schleife zur Erzeugung von zusätzlichen Festplatten
for ((j = 1; j <= VAR_ADDITIONAL_HDD; j++))
do
HDD_NUM=$(printf "%02d" $j)
HDD_NAME="${VM_NAME}-disk${HDD_NUM}.vdi"
sudo -u "$VAR_USER_IN_GROUP" VBoxManage createhd \
--filename "$VM_DIR/$VM_NAME/$HDD_NAME" \
--size 102400 \
--format VDI
sudo -u "$VAR_USER_IN_GROUP" VBoxManage storageattach "$VM_NAME" \
--storagectl "SATA Controller" \
--port "$HDD_NUM" \
--device 0 \
--type hdd \
--medium "$VM_DIR/$VM_NAME/$HDD_NAME"
done
done
done
echo "VMs wurden für alle wie angegeben erstellt."

52
modul_vbox/iso_management.sh Normal file
View File

@@ -0,0 +1,52 @@
#!/bin/bash
# iso_management.sh
# Funktion zum Suchen einer ISO-Datei basierend auf einem Muster
find_iso_files() {
local iso_dir="$1"
find "$iso_dir" -type f -name "*.iso" | sort | xargs -n 1 basename
}
# Funktion, um das Betriebssystem basierend auf der ISO-Datei zu identifizieren
identify_os() {
local iso_file="$1"
case "$(basename "$iso_file")" in
*ubuntu*server*)
echo "Ubuntu_64"
;;
*ubuntu*desktop*)
echo "Ubuntu_64"
;;
*debian*)
echo "Debian_64"
;;
*rhel*)
echo "RedHat_64"
;;
*Fedora-Workstation*)
echo "Fedora_64"
;;
*Fedora-Server*)
echo "Fedora_64"
;;
*CentOS*)
echo "RedHat_64"
;;
*kali-linux*)
echo "kali-linux"
;;
*linuxmint*)
echo "Linux_64"
;;
*openSUSE*)
echo "OpenSUSE_64"
;;
*manjaro*)
echo "ArchLinux_64"
;;
*)
echo "Unbekannt"
;;
esac
}

26
modul_vbox/user_management.sh Normal file
View File

@@ -0,0 +1,26 @@
#!/bin/bash
# user_management.sh
# Funktion zum Überprüfen der Benutzerexistenz
check_user_existence() {
local VAR_USER_IN_GROUP="$1"
if ! grep -q "^$VAR_USER_IN_GROUP:" /etc/passwd; then
echo "Der Benutzer $VAR_USER_IN_GROUP existiert nicht auf diesem System."
exit 1
fi
}
# Funktion zum Abrufen der Mitglieder einer Gruppe
get_group_users() {
local groupname="$1"
local members
members=$(getent group "$groupname" | cut -d: -f4)
if [[ -n "$members" ]]; then
echo "$members" | tr ',' '\n'
else
echo "Die Gruppe $groupname existiert nicht oder hat keine Mitglieder."
fi
}

320
vbox_create.sh Normal file → Executable file
View File

@@ -1,6 +1,6 @@
#!/bin/bash
# Autor: Branislav Zeljak v0.8
# Autor: Branislav Zeljak v0.9
# Beschreibung: Dieses Skript erstellt VirtualBox-VMs und klont Festplatten parallel.
# Verwendung: Führen Sie das Skript aus und befolgen Sie die Eingabeaufforderungen.
clear
@@ -32,7 +32,7 @@ get_group_users() {
# Funktion, um einen zufälligen Host-Namen aus der Liste auszuwählen
get_random_name() {
# Liste der Namen
local names=("frodo" "samweis" "gandalf" "aragorn" "legolas" "gimli" "boromir" "meriadoc" "peregrin" "arwen" "galadriel" "celeborn" "elrond" "glorfindel" "faramir" "eowyn" "theoden" "treebeard" "gollum" "sauron" "saruman" "bilbo" "denethor" "radagast" "thranduil" "bard" "dori" "frodo")
local names=("samweis" "gandalf" "aragorn" "legolas" "gimli" "boromir" "meriadoc" "peregrin" "arwen" "galadriel" "celeborn" "elrond" "glorfindel" "faramir" "eowyn" "theoden" "treebeard" "gollum" "sauron" "saruman" "bilbo" "denethor" "radagast" "thranduil" "bard" "dori")
# Zufälligen Index auswählen
local random_index=$((RANDOM % ${#names[@]}))
@@ -47,17 +47,52 @@ generate_rdp_port() {
}
# Funktion zum Suchen einer ISO-Datei basierend auf einem Muster
find_iso_file() {
local iso_pattern="$1"
local iso_file
iso_file=$(find "$ISO_DIR" -type f -name "$iso_pattern")
echo "$iso_file"
find_iso_files() {
local iso_dir="$1"
find "$iso_dir" -type f -name "*.iso" | sort
}
# Funktion, um das Betriebssystem basierend auf der ISO-Datei zu identifizieren
identify_os() {
local iso_file="$1"
case "$(basename "$iso_file")" in
*ubuntu*server*|*ubuntu*desktop*)
echo "Ubuntu_64"
;;
*debian*)
echo "Debian_64"
;;
*rhel*)
echo "RedHat_64"
;;
*CentOS*)
echo "RedHat_64"
;;
*Fedora-Workstation*|*Fedora-Server*)
echo "Fedora_64"
;;
*kali-linux*)
echo "kali-linux"
;;
*linuxmint*)
echo "Linux_64"
;;
*openSUSE*)
echo "OpenSUSE_64"
;;
*manjaro*)
echo "ArchLinux_64"
;;
*)
echo "Unbekannt"
;;
esac
}
# %--------------------end/Funktionen--------------------%
echo "User / Passwort: user00/Start1234"
echo "Welches VDI-OS soll installiert werden?"
echo "Welches ISO-OS soll installiert werden?"
echo
echo "Für wen soll es sein?"
@@ -81,7 +116,8 @@ do
fi
;;
"Mitglieder einer Gruppe")
read -p "Bitte geben Sie den Gruppennamen ein: " VAR_GROUP
read -p "Bitte geben Sie den Gruppennamen ein. (Standard [workshop]): " VAR_GROUP
VAR_GROUP="${VAR_GROUP:-workshop}"
if getent group "$VAR_GROUP" &>/dev/null; then
echo "Mitglieder der Gruppe $VAR_GROUP:"
get_group_users "$VAR_GROUP"
@@ -104,141 +140,143 @@ VAR_VB="/storage/vbox_storage"
# Verzeichnis mit ISO-Dateien
ISO_DIR="/srv/data/ISO/"
echo "Welches Betriebssystem soll installiert werden?"
echo "Verfügbare ISO-Dateien werden durchsucht..."
echo
COLUMNS=10
PS3="Bitte Ihre Auswahl eingeben: "
# Betriebssysteme und ISO-Dateimuster
declare -A WieOS_MAP=(
["Ubuntu LTS SRV"]="Ubuntu_64 ubuntu-*-live-server-amd64.iso"
["Ubuntu LTS GUI"]="Ubuntu_64 ubuntu-*-desktop-amd64.iso"
["Debian"]="Debian_64 debian-*.iso"
["RHEL"]="RedHat_64 rhel-*.iso"
["Fedora-Workstation"]="Fedora_64 Fedora-Workstation*.iso"
["Fedora-Server"]="Fedora_64 Fedora-Server*.iso"
["kali-linux"]="Linux_64 kali-linux-*.iso"
["linuxmint"]="Linux_64 linuxmint-*.iso"
["openSUSE"]="OpenSUSE_64 openSUSE-*.iso"
["Manjaro"]="ArchLinux_64 manjaro-xfce-*.iso"
["Quit"]="Quit"
)
# Vorhandene ISO-Dateien finden und zur Auswahl anbieten
iso_files=($(find_iso_files "$ISO_DIR"))
# Alphabetisch sortieren, mit Quit am Ende
sorted_keys=($(for key in "${!WieOS_MAP[@]}"; do echo "$key"; done | sort | grep -v "Quit"))
sorted_keys+=("Quit")
if [ ${#iso_files[@]} -eq 0 ]; then
echo "Keine ISO-Dateien im Verzeichnis $ISO_DIR gefunden."
exit 1
fi
# Auswahlmenü für die Betriebssysteme anzeigen
select opt in "${sorted_keys[@]}"
do
if [ "$opt" == "Quit" ]; then
exit
fi
VAR_OS="${WieOS_MAP[$opt]%% *}" # Extrahiere den ersten Teil (Betriebssystem)
VAR_ISO_PATTERN="${WieOS_MAP[$opt]#* }" # Extrahiere den zweiten Teil (ISO-Muster)
# Finden der tatsächlichen ISO-Datei
VAR_ISO=$(find_iso_file "$VAR_ISO_PATTERN")
if [ -z "$VAR_ISO" ]; then
echo "Die ISO-Datei mit dem Muster '$VAR_ISO_PATTERN' wurde nicht gefunden."
exit 1
fi
default_name=$(get_random_name)
# Benutzereingaben für VM-Konfiguration
read -p "Wie viele VMs werden benötigt? [1]: " VAR_QUANTITY
VAR_QUANTITY=${VAR_QUANTITY:-1}
read -p "Präfix Host Name (Vorgabe: $default_name): " VAR_NAME_PREFIX
read -p "CPUs [2]: " VAR_CPU
VAR_CPU=${VAR_CPU:-2}
read -p "Memory [2048]: " VAR_MEM
VAR_MEM=${VAR_MEM:-2048}
read -p "Anzahl der HDDs (Standard: 1): " VAR_ADDITIONAL_HDD
VAR_ADDITIONAL_HDD=${VAR_ADDITIONAL_HDD:-1}
# Standardwerte
VAR_VIDEO_RAM=64
VAR_NIC1="nat"
VAR_NIC2="bridged"
VAR_NET=$(ip addr show | grep "^2: " | awk '{print $2}' | sed 's/://')
VAR_NAME_PREFIX=${VAR_NAME_PREFIX:-$default_name}
# Schleife zur Erzeugung der VMs für jeden Benutzer in der Gruppe
for VAR_USER_IN_GROUP in "${VAR_GROUP_MEMBERS[@]}"
do
# Generiere einen eindeutigen RDP-Port
VAR_RDP_PORT=$(generate_rdp_port)
# Schleife zur Erzeugung der angeforderten Anzahl von VMs
for ((i = 1; i <= VAR_QUANTITY; i++))
do
# VM erstellen
VM_NAME="${VAR_NAME_PREFIX}_${VAR_USER_IN_GROUP}_VM$(printf "%02d" $i)"
VM_DIR="$VAR_VB/$VAR_USER_IN_GROUP"
sudo -u "$VAR_USER_IN_GROUP" VBoxManage createvm \
--name "$VM_NAME" \
--ostype "$VAR_OS" \
--register \
--basefolder "$VM_DIR"
# VM-Konfiguration
sudo -u "$VAR_USER_IN_GROUP" VBoxManage modifyvm "$VM_NAME" \
--ioapic on \
--memory "$VAR_MEM" \
--cpus "$VAR_CPU" \
--vram "$VAR_VIDEO_RAM" \
--nic1 $VAR_NIC1 \
--nic2 $VAR_NIC2 \
--bridgeadapter2 ${VAR_NET} \
--graphicscontroller "vboxsvga" \
--vrde on \
--vrdemulticon on \
--vrdeport "$VAR_RDP_PORT"
# Festplattencontroller hinzufügen
sudo -u "$VAR_USER_IN_GROUP" VBoxManage storagectl "$VM_NAME" \
--name "SATA Controller" \
--add sata \
--controller IntelAhci
sudo -u "$VAR_USER_IN_GROUP" VBoxManage storagectl "$VM_NAME" \
--name "IDE Controller" \
--add ide \
--controller PIIX4
sudo -u "$VAR_USER_IN_GROUP" VBoxManage storageattach "$VM_NAME" \
--storagectl "IDE Controller" \
--port 1 \
--device 0 \
--type dvddrive \
--medium "$VAR_ISO"
# Schleife zur Erzeugung von zusätzlichen Festplatten
for ((j = 1; j <= VAR_ADDITIONAL_HDD; j++))
do
HDD_NUM=$(printf "%02d" $j)
HDD_NAME="${VM_NAME}-disk${HDD_NUM}.vdi"
sudo -u "$VAR_USER_IN_GROUP" VBoxManage createhd \
--filename "$VM_DIR/$VM_NAME/$HDD_NAME" \
--size 102400 \
--format VDI
sudo -u "$VAR_USER_IN_GROUP" VBoxManage storageattach "$VM_NAME" \
--storagectl "SATA Controller" \
--port "$HDD_NUM" \
--device 0 \
--type hdd \
--medium "$VM_DIR/$VM_NAME/$HDD_NAME"
done
done
done
echo "VMs wurden für alle wie angegeben erstellt."
break
# ISO-Dateinamen extrahieren
iso_names=()
for iso_file in "${iso_files[@]}"; do
iso_names+=("$(basename "$iso_file")")
done
PS3="Bitte wählen Sie eine ISO-Datei aus: "
select iso_name in "${iso_names[@]}" "Beenden"
do
if [[ "$iso_name" == "Beenden" ]]; then
exit 0
fi
if [ -n "$iso_name" ]; then
selected_iso="$ISO_DIR/$iso_name"
break
else
echo "Ungültige Auswahl. Bitte versuchen Sie es erneut."
fi
done
# Betriebssystem auf Basis der ausgewählten ISO identifizieren
os_name=$(identify_os "$selected_iso")
if [ "$os_name" == "Unbekannt" ]; then
echo "Das Betriebssystem konnte nicht automatisch erkannt werden."
read -p "Bitte geben Sie das Betriebssystem manuell ein: " os_name
fi
# Benutzerdefinierte Werte anfordern
default_name=$(get_random_name)
read -p "Wie viele VMs werden benötigt? [1]: " VAR_QUANTITY
VAR_QUANTITY=${VAR_QUANTITY:-1}
read -p "Präfix Host Name (Vorgabe: $default_name): " VAR_NAME_PREFIX
read -p "CPUs [2]: " VAR_CPU
VAR_CPU=${VAR_CPU:-2}
read -p "Memory [2048]: " VAR_MEM
VAR_MEM=${VAR_MEM:-2048}
read -p "Anzahl der HDDs (Standard: 1): " VAR_ADDITIONAL_HDD
VAR_ADDITIONAL_HDD=${VAR_ADDITIONAL_HDD:-1}
# Standardwerte festlegen, wenn keine Eingabe erfolgt
VAR_VIDEO_RAM=64
VAR_NIC1="nat"
VAR_NIC2="bridged"
VAR_NET=$(ip addr show | grep "^2: " | awk '{print $2}' | sed 's/://')
VAR_NAME_PREFIX=${VAR_NAME_PREFIX:-$default_name}
# Schleife zur Erzeugung der VMs für jeden Benutzer in der Gruppe
for VAR_USER_IN_GROUP in "${VAR_GROUP_MEMBERS[@]}"
do
# Generiere einen eindeutigen RDP-Port
VAR_RDP_PORT=$(generate_rdp_port)
# Schleife zur Erzeugung der angeforderten Anzahl von VMs
for ((i = 1; i <= VAR_QUANTITY; i++))
do
# VM erstellen
VM_NAME="${VAR_NAME_PREFIX}_${VAR_USER_IN_GROUP}_VM$(printf "%02d" $i)"
VM_DIR="$VAR_VB/$VAR_USER_IN_GROUP"
sudo -u "$VAR_USER_IN_GROUP" VBoxManage createvm \
--name "$VM_NAME" \
--ostype "$os_name" \
--register \
--basefolder "$VM_DIR"
# Fehlerbehandlung für die VM-Erstellung
if [ $? -ne 0 ]; then
echo "Fehler beim Erstellen der VM $VM_NAME."
continue
fi
# VM-Konfigurieren
sudo -u "$VAR_USER_IN_GROUP" VBoxManage modifyvm "$VM_NAME" \
--ioapic on \
--memory "$VAR_MEM" \
--cpus "$VAR_CPU" \
--vram "$VAR_VIDEO_RAM" \
--nic1 $VAR_NIC1 \
--nic2 $VAR_NIC2 \
--bridgeadapter2 ${VAR_NET} \
--graphicscontroller "vboxsvga" \
--vrde on \
--vrdemulticon on \
--vrdeport "$VAR_RDP_PORT"
# Festplattencontroller hinzufügen
sudo -u "$VAR_USER_IN_GROUP" VBoxManage storagectl "$VM_NAME" \
--name "SATA Controller" \
--add sata \
--controller IntelAhci
sudo -u "$VAR_USER_IN_GROUP" VBoxManage storagectl "$VM_NAME" \
--name "IDE Controller" \
--add ide \
--controller PIIX4
sudo -u "$VAR_USER_IN_GROUP" VBoxManage storageattach "$VM_NAME" \
--storagectl "IDE Controller" \
--port 1 \
--device 0 \
--type dvddrive \
--medium "$selected_iso"
# Schleife zur Erzeugung von zusätzlichen Festplatten
for ((j = 1; j <= VAR_ADDITIONAL_HDD; j++))
do
HDD_NUM=$(printf "%02d" $j)
HDD_NAME="${VM_NAME}-disk${HDD_NUM}.vdi"
sudo -u "$VAR_USER_IN_GROUP" VBoxManage createhd \
--filename "$VM_DIR/$VM_NAME/$HDD_NAME" \
--size 102400 \
--format VDI
sudo -u "$VAR_USER_IN_GROUP" VBoxManage storageattach "$VM_NAME" \
--storagectl "SATA Controller" \
--port "$HDD_NUM" \
--device 0 \
--type hdd \
--medium "$VM_DIR/$VM_NAME/$HDD_NAME"
done
done
done
echo "VMs wurden für alle wie angegeben erstellt."

126
vdi_create.sh
View File

@@ -48,6 +48,57 @@ generate_rdp_port() {
echo "$rdp_port"
}
# Funktion zum Suchen einer VDI-Datei basierend auf einem Muster
find_vdi_files() {
local vdi_dir="$1"
find "$vdi_dir" -type f -name "*.vdi" | sort
}
# Funktion, um das Betriebssystem basierend auf der VDI-Datei zu identifizieren
identify_os() {
local vdi_file="$1"
case "$(basename "$vdi_file")" in
*ubu*_GUI_*)
echo "Ubuntu_64"
;;
*ubuntu*desktop*)
echo "Ubuntu_64"
;;
*debian*)
echo "Debian_64"
;;
*rhel*)
echo "RedHat_64"
;;
*CentOS*)
echo "RedHat_64"
;;
*Fedora-Workstation*)
echo "Fedora_64"
;;
*Fedora-Server*)
echo "Fedora_64"
;;
*kali-linux*)
echo "kali-linux"
;;
*linuxmint*)
echo "Linux_64"
;;
*openSUSE*)
echo "OpenSUSE_64"
;;
*manjaro*)
echo "ArchLinux_64"
;;
*)
echo "Unbekannt"
;;
esac
}
# %--------------------end/Funktionen--------------------%
echo "User / Passwort: user00/Start1234"
@@ -92,38 +143,51 @@ do
break
done
COLUMNS=8
PS3='Bitte wählen Sie die VM-Option: '
OPTIONS=("Ubuntu 2204 GUI BASE" "Ubuntu 2204 GUI BASE EXT" "Ubuntu 2204 SRV" "Ubuntu 2204 GUI GER" "Ubuntu 2204 GUI GER EXT" "Beenden")
select opt in "${OPTIONS[@]}"
VDI_DIR="/srv/data/VDI"
echo "Verfügbare VDI-Dateien werden durchsucht..."
echo
# Vorhandene VDI-Dateien finden und zur Auswahl anbieten
vdi_files=($(find_vdi_files "$VDI_DIR"))
if [ ${#vdi_files[@]} -eq 0 ]; then
echo "Keine VDI-Dateien im Verzeichnis $VDI_DIR gefunden."
exit
fi
# VDI-Dateinamen extrahieren
vdi_names=()
for vdi_file in "${vdi_files[@]}"; do
vdi_names+=("$(basename "$vdi_file")")
done
S3="Bitte wählen Sie eine VDI-Datei aus: "
select vdi_name in "${vdi_names[@]}" "Beenden"
do
case $opt in
"Ubuntu 2204 GUI BASE")
VAR_OS="Ubuntu_64"
VAR_VDI="ubu2204_GUI_BASE.vdi"
;;
"Ubuntu 2204 GUI BASE EXT")
VAR_OS="Ubuntu_64"
VAR_VDI="ubu2204_GUI_BASE_EXT.vdi"
;;
"Ubuntu 2204 SRV")
VAR_OS="Ubuntu_64"
VAR_VDI="ubu2204_SRV.vdi"
;;
"Ubuntu 2204 GUI GER")
VAR_OS="Ubuntu_64"
VAR_VDI="ubu2204_GUI_GER.vdi"
;;
"Ubuntu 2204 GUI GER EXT")
VAR_OS="Ubuntu_64"
VAR_VDI="ubu2204_GUI_GER_EXT.vdi"
;;
"Beenden")
exit
;;
esac
default_name=$(get_random_name)
if [[ "$vdi_name" == "Beenden" ]]; then
exit 0
fi
if [ -n "$vdi_name" ]; then
selected_vdi="$VDI_DIR/$vdi_name"
break
else
echo "Ungültige Auswahl. Bitte versuchen Sie es erneut."
fi
done
# Betriebssystem auf Basis der ausgewählten VDI identifizieren
os_name=$(identify_os "$selected_vdi")
if [ "$os_name" == "Unbekannt" ]; then
echo "Das Betriebssystem konnte nicht automatisch erkannt werden."
read -p "Bitte geben Sie das Betriebssystem manuell ein: " os_name
fi
# Benutzerdefinierte Werte anfordern
default_name=$(get_random_name)
# Benutzereingaben
read -p "Wie viele VMs werden benötigt? [1]: " VAR_QUANTITY

244
vdi_create.sh_org Executable file
View File

@@ -0,0 +1,244 @@
#!/bin/bash
# Autor: Branislav Zeljak v0.7
# Beschreibung: Dieses Skript erstellt VirtualBox-VMs und klonet Festplatten parallel.
# Verwendung: Führen Sie das Skript aus und befolgen Sie die Eingabeaufforderungen.
clear
# %--------------------start/Funktionen--------------------%
# Funktion zum Überprüfen der Benutzerexistenz
check_user_existence() {
local VAR_USER_IN_GROUP="$1"
if ! grep -q "^$VAR_USER_IN_GROUP:" /etc/passwd; then
echo "Der Benutzer $VAR_USER_IN_GROUP existiert nicht auf diesem System."
exit 1
fi
}
get_group_users() {
local groupname="$1"
local members
members=$(getent group "$groupname" | cut -d: -f4)
if [[ -n "$members" ]]; then
echo "$members" | tr ',' '\n'
else
echo "Die Gruppe $groupname existiert nicht oder hat keine Mitglieder."
fi
}
# Funktion, um einen zufälligen Host-Namen aus der Liste auszuwählen
get_random_name() {
# Liste der Namen
local names=("frodo" "samweis" "gandalf" "aragorn" "legolas" "gimli" "boromir" "meriadoc" "peregrin" "arwen" "galadriel" "celeborn" "elrond" "glorfindel" "faramir" "eowyn" "theoden" "treebeard" "gollum" "sauron" "saruman" "bilbo" "denethor" "radagast" "thranduil" "bard" "dori" "frodo")
# Zufälligen Index auswählen
local random_index=$((RANDOM % ${#names[@]}))
echo "${names[random_index]}"
}
# Funktion zur Generierung eines eindeutigen RDP-Ports
generate_rdp_port() {
local rdp_port
rdp_port=$(shuf -i 3390-49151 -n 1)
echo "$rdp_port"
}
# %--------------------end/Funktionen--------------------%
echo "User / Passwort: user00/Start1234"
echo "Welches VDI-OS soll installiert werden"
echo
echo "Für wen soll es sein?"
echo
COLUMNS=10
PS3="Ihre Auswahl: "
options=("Aktueller Benutzer" "Anderer Benutzer" "Mitglieder einer Gruppe" "Beenden")
select opt in "${options[@]}"
do
case $opt in
"Aktueller Benutzer")
VAR_GROUP_MEMBERS=$(whoami)
;;
"Anderer Benutzer")
read -p "Bitte geben Sie einen Benutzernamen ein: " VAR_GROUP_MEMBERS
if grep -q "^$VAR_GROUP_MEMBERS:" /etc/passwd; then
echo "Der Benutzer $VAR_GROUP_MEMBERS existiert auf diesem System."
else
echo "Der Benutzer $VAR_GROUP_MEMBERS existiert nicht auf diesem System."
exit 1
fi
;;
"Mitglieder einer Gruppe")
read -p "Bitte geben Sie den Gruppennamen ein: " VAR_GROUP
if getent group "$VAR_GROUP" &>/dev/null; then
echo "Mitglieder der Gruppe $VAR_GROUP:"
get_group_users "$VAR_GROUP"
VAR_GROUP_MEMBERS=($(get_group_users "$VAR_GROUP"))
else
echo "Die Gruppe $VAR_GROUP existiert nicht auf diesem System."
exit 1
fi
;;
"Beenden")
exit
;;
esac
break
done
COLUMNS=8
PS3='Bitte wählen Sie die VM-Option: '
OPTIONS=("Ubuntu 2204 GUI BASE" "Ubuntu 2204 GUI BASE EXT" "Ubuntu 2204 SRV" "Ubuntu 2204 SRV mini" "Ubuntu 2204 GUI GER" "Ubuntu 2204 GUI GER EXT" "Beenden")
select opt in "${OPTIONS[@]}"
do
case $opt in
"Ubuntu 2204 GUI BASE")
VAR_OS="Ubuntu_64"
VAR_VDI="ubu2204_GUI_BASE.vdi"
;;
"Ubuntu 2204 GUI BASE EXT")
VAR_OS="Ubuntu_64"
VAR_VDI="ubu2204_GUI_BASE_EXT.vdi"
;;
"Ubuntu 2204 SRV")
VAR_OS="Ubuntu_64"
VAR_VDI="ubu2204_SRV.vdi"
;;
"Ubuntu 2204 SRV mini")
VAR_OS="Ubuntu_64"
VAR_VDI="ubu2204_SRV_mini.vdi"
;;
"Ubuntu 2204 GUI GER")
VAR_OS="Ubuntu_64"
VAR_VDI="ubu2204_GUI_GER.vdi"
;;
"Ubuntu 2204 GUI GER EXT")
VAR_OS="Ubuntu_64"
VAR_VDI="ubu2204_GUI_GER_EXT.vdi"
;;
"Beenden")
exit
;;
esac
default_name=$(get_random_name)
# Benutzereingaben
read -p "Wie viele VMs werden benötigt? [1]: " VAR_QUANTITY
VAR_QUANTITY=${VAR_QUANTITY:-1}
read -p "Präfix Host Name (Vorgabe: $default_name): " VAR_NAME_PREFIX
read -p "CPUs [2]: " VAR_CPU
VAR_CPU=${VAR_CPU:-2}
read -p "Memory [2048]: " VAR_MEM
VAR_MEM=${VAR_MEM:-2048}
read -p "Anzahl der zusätzlichen HDDs (Standard: 0): " VAR_ADDITIONAL_HDD
VAR_ADDITIONAL_HDD=${VAR_ADDITIONAL_HDD:-0}
# Variablen
VAR_PATH_TO_VDI="/srv/data/VDI"
VAR_VIDEO_RAM=64
VAR_NIC=bridged
#VAR_NET=enp4s0f1
VAR_NET=$(ip addr show | grep "^2: " | awk '{print $2}' | sed 's/://')
VAR_NAME_PREFIX=${VAR_NAME_PREFIX:-$default_name}
# Schleife zur Erzeugung der VMs für jeden Benutzer in der Gruppe
for VAR_USER_IN_GROUP in "${VAR_GROUP_MEMBERS[@]}"
do
# Generiere einen eindeutigen RDP-Port
VAR_RDP_PORT=$(generate_rdp_port)
# Schleife zur Erzeugung der angeforderten Anzahl von VMs
for ((i = 1; i <= VAR_QUANTITY; i++))
do
# VM erstellen
VM_NAME="${VAR_NAME_PREFIX}-${VAR_USER_IN_GROUP}-VM$(printf "%02d" $i)"
VM_DIR="/storage/vbox_storage/$VAR_USER_IN_GROUP"
sudo -u "$VAR_USER_IN_GROUP" VBoxManage createvm \
--name "$VM_NAME" \
--ostype "$VAR_OS" \
--register \
--basefolder "$VM_DIR"
# VM-Konfigurieren
sudo -u "$VAR_USER_IN_GROUP" VBoxManage modifyvm "$VM_NAME" \
--ioapic on \
--memory "$VAR_MEM" \
--cpus "$VAR_CPU" \
--vram "$VAR_VIDEO_RAM" \
--nic1 Nat \
--nic2 ${VAR_NIC} \
--bridgeadapter2 ${VAR_NET} \
--graphicscontroller vmsvga \
--vrde on \
--vrdemulticon on \
--vrdeport "$VAR_RDP_PORT"
# Festplattencontroller hinzufügen
sudo -u "$VAR_USER_IN_GROUP" VBoxManage storagectl "$VM_NAME" \
--name "SATA Controller" \
--add sata \
--controller IntelAhci
# IDE-Controller für DVD
sudo -u "$VAR_USER_IN_GROUP" VBoxManage storagectl "$VM_NAME" \
--name "IDE Controller" \
--add ide \
--controller PIIX4
sudo -u "$VAR_USER_IN_GROUP" VBoxManage storageattach "$VM_NAME" \
--storagectl "IDE Controller" \
--port 1 \
--device 0 \
--type dvddrive \
--medium emptydrive
# Host Name und RDP Port
echo "${VM_NAME}-${VAR_RDP_PORT}" >> /tmp/rdp_port.txt
# Schleife zur Erzeugung von zusätzlichen Festplatten
for ((j = 1; j <= VAR_ADDITIONAL_HDD; j++))
do
HDD_NUM=$(printf "%02d" $j)
HDD_NAME="${VM_NAME}-disk${HDD_NUM}.vdi"
sudo -u "$VAR_USER_IN_GROUP" VBoxManage createhd \
--filename "$VM_DIR/$VM_NAME/$HDD_NAME" \
--size 102400 \
--format VDI
sudo -u "$VAR_USER_IN_GROUP" VBoxManage storageattach "$VM_NAME" \
--storagectl "SATA Controller" \
--port "$HDD_NUM" \
--device 0 \
--type hdd \
--medium "$VM_DIR/$VM_NAME/$HDD_NAME"
done
# Klonen der ersten Festplatte und Registrieren (in Hintergrundprozessen)
{
sudo -u "$VAR_USER_IN_GROUP" VBoxManage clonehd "${VAR_PATH_TO_VDI}/${VAR_VDI}" "$VM_DIR/$VM_NAME/${VM_NAME}-disk00.vdi"
sudo -u "$VAR_USER_IN_GROUP" VBoxManage storageattach "$VM_NAME" \
--storagectl "SATA Controller" \
--port 0 \
--device 0 \
--type hdd \
--medium "$VM_DIR/$VM_NAME/${VM_NAME}-disk00.vdi"
} &
done
done
# Warten auf das Ende der Hintergrundprozesse
wait
echo "VMs wurden für alle wie angegeben erstellt."
break
done

283
vdi_create_new.sh Executable file
View File

@@ -0,0 +1,283 @@
#!/bin/bash
# Autor: Branislav Zeljak v0.8
# Beschreibung: Dieses Skript erstellt VirtualBox-VMs und klont Festplatten parallel.
# Verwendung: Führen Sie das Skript aus und befolgen Sie die Eingabeaufforderungen.
clear
# %--------------------start/Funktionen--------------------%
# Funktion zum Überprüfen der Benutzerexistenz
check_user_existence() {
local VAR_USER_IN_GROUP="$1"
if ! grep -q "^$VAR_USER_IN_GROUP:" /etc/passwd; then
echo "Der Benutzer $VAR_USER_IN_GROUP existiert nicht auf diesem System."
exit 1
fi
}
# Funktion, um Mitglieder einer Gruppe abzurufen
get_group_users() {
local groupname="$1"
local members
members=$(getent group "$groupname" | cut -d: -f4)
if [[ -n "$members" ]]; then
echo "$members" | tr ',' '\n'
else
echo "Die Gruppe $groupname existiert nicht oder hat keine Mitglieder."
fi
}
# Funktion, um einen zufälligen Host-Namen aus der Liste auszuwählen
get_random_name() {
local names=("frodo" "samweis" "gandalf" "aragorn" "legolas" "gimli" "boromir" "meriadoc" "peregrin" "arwen" "galadriel" "celeborn" "elrond" "glorfindel" "faramir" "eowyn" "theoden" "treebeard" "gollum" "sauron" "saruman" "bilbo" "denethor" "radagast" "thranduil" "bard" "dori" "frodo")
local random_index=$((RANDOM % ${#names[@]}))
echo "${names[random_index]}"
}
# Funktion zur Generierung eines eindeutigen RDP-Ports
generate_rdp_port() {
local rdp_port
rdp_port=$(shuf -i 3390-49151 -n 1)
echo "$rdp_port"
}
# Funktion zum Suchen einer VDI-Datei basierend auf einem Muster
find_vdi_files() {
local vdi_dir="$1"
find "$vdi_dir" -type f -name "*.vdi" | sort
}
# Funktion, um das Betriebssystem basierend auf der VDI-Datei zu identifizieren
identify_os() {
local vdi_file="$1"
case "$(basename "$vdi_file")" in
*ubu*_GUI_*|*ubuntu*desktop*)
echo "Ubuntu_64"
;;
*debian*)
echo "Debian_64"
;;
*rhel*|*CentOS*)
echo "RedHat_64"
;;
*Fedora-Workstation*|*Fedora-Server*)
echo "Fedora_64"
;;
*kali-linux*)
echo "kali-linux"
;;
*linuxmint*)
echo "Linux_64"
;;
*openSUSE*)
echo "OpenSUSE_64"
;;
*manjaro*)
echo "ArchLinux_64"
;;
*)
echo "Unbekannt"
;;
esac
}
# %--------------------end/Funktionen--------------------%
echo "User / Passwort: user00/Start1234"
echo "Welches VDI-OS soll installiert werden"
echo
echo "Für wen soll es sein?"
echo
COLUMNS=10
PS3="Ihre Auswahl: "
options=("Aktueller Benutzer" "Anderer Benutzer" "Mitglieder einer Gruppe" "Beenden")
select opt in "${options[@]}"
do
case $opt in
"Aktueller Benutzer")
VAR_GROUP_MEMBERS=$(whoami)
;;
"Anderer Benutzer")
read -p "Bitte geben Sie einen Benutzernamen ein: " VAR_GROUP_MEMBERS
check_user_existence "$VAR_GROUP_MEMBERS"
;;
"Mitglieder einer Gruppe")
read -p "Bitte geben Sie den Gruppennamen ein: " VAR_GROUP
if getent group "$VAR_GROUP" &>/dev/null; then
VAR_GROUP_MEMBERS=($(get_group_users "$VAR_GROUP"))
if [ ${#VAR_GROUP_MEMBERS[@]} -eq 0 ]; then
echo "Die Gruppe $VAR_GROUP hat keine Mitglieder."
exit 1
fi
else
echo "Die Gruppe $VAR_GROUP existiert nicht auf diesem System."
exit 1
fi
;;
"Beenden")
exit
;;
esac
break
done
VDI_DIR="/srv/data/VDI"
echo "Verfügbare VDI-Dateien werden durchsucht..."
echo
# Vorhandene VDI-Dateien finden und zur Auswahl anbieten
vdi_files=($(find_vdi_files "$VDI_DIR"))
if [ ${#vdi_files[@]} -eq 0 ]; then
echo "Keine VDI-Dateien im Verzeichnis $VDI_DIR gefunden."
exit 1
fi
# VDI-Dateinamen extrahieren
vdi_names=()
for vdi_file in "${vdi_files[@]}"; do
vdi_names+=("$(basename "$vdi_file")")
done
S3="Bitte wählen Sie eine VDI-Datei aus: "
select vdi_name in "${vdi_names[@]}" "Beenden"
do
if [[ "$vdi_name" == "Beenden" ]]; then
exit 0
fi
if [ -n "$vdi_name" ]; then
selected_vdi="$VDI_DIR/$vdi_name"
break
else
echo "Ungültige Auswahl. Bitte versuchen Sie es erneut."
fi
done
# Betriebssystem auf Basis der ausgewählten VDI identifizieren
os_name=$(identify_os "$selected_vdi")
if [ "$os_name" == "Unbekannt" ]; then
echo "Das Betriebssystem konnte nicht automatisch erkannt werden."
read -p "Bitte geben Sie das Betriebssystem manuell ein: " os_name
fi
# Benutzerdefinierte Werte anfordern
default_name=$(get_random_name)
read -p "Wie viele VMs werden benötigt? [1]: " VAR_QUANTITY
VAR_QUANTITY=${VAR_QUANTITY:-1}
read -p "Präfix Host Name (Vorgabe: $default_name): " VAR_NAME_PREFIX
read -p "CPUs [2]: " VAR_CPU
VAR_CPU=${VAR_CPU:-2}
read -p "Memory [2048]: " VAR_MEM
VAR_MEM=${VAR_MEM:-2048}
read -p "Anzahl der zusätzlichen HDDs (Standard: 0): " VAR_ADDITIONAL_HDD
VAR_ADDITIONAL_HDD=${VAR_ADDITIONAL_HDD:-0}
# Variablen
VAR_PATH_TO_VDI="$VDI_DIR"
VAR_VIDEO_RAM=64
VAR_NIC=bridged
VAR_NET=$(ip addr show | grep "^2: " | awk '{print $2}' | sed 's/://')
VAR_NAME_PREFIX=${VAR_NAME_PREFIX:-$default_name}
# Schleife zur Erzeugung der VMs für jeden Benutzer in der Gruppe
for VAR_USER_IN_GROUP in "${VAR_GROUP_MEMBERS[@]}"
do
check_user_existence "$VAR_USER_IN_GROUP"
# Generiere einen eindeutigen RDP-Port
VAR_RDP_PORT=$(generate_rdp_port)
# Schleife zur Erzeugung der angeforderten Anzahl von VMs
for ((i = 1; i <= VAR_QUANTITY; i++))
do
(
# VM erstellen
VM_NAME="${VAR_NAME_PREFIX}-${VAR_USER_IN_GROUP}-VM$(printf "%02d" $i)"
VM_DIR="/storage/vbox_storage/$VAR_USER_IN_GROUP"
sudo -u "$VAR_USER_IN_GROUP" VBoxManage createvm \
--name "$VM_NAME" \
--ostype "$os_name" \
--register \
--basefolder "$VM_DIR"
# VM-Konfigurieren
sudo -u "$VAR_USER_IN_GROUP" VBoxManage modifyvm "$VM_NAME" \
--ioapic on \
--memory "$VAR_MEM" \
--cpus "$VAR_CPU" \
--vram "$VAR_VIDEO_RAM" \
--nic1 Nat \
--nic2 "$VAR_NIC" \
--bridgeadapter2 "$VAR_NET" \
--graphicscontroller vmsvga \
--vrde on \
--vrdemulticon on \
--vrdeport "$VAR_RDP_PORT"
# Festplattencontroller hinzufügen
sudo -u "$VAR_USER_IN_GROUP" VBoxManage storagectl "$VM_NAME" \
--name "SATA Controller" \
--add sata \
--controller IntelAhci
# IDE-Controller für DVD
sudo -u "$VAR_USER_IN_GROUP" VBoxManage storagectl "$VM_NAME" \
--name "IDE Controller" \
--add ide \
--controller PIIX4
sudo -u "$VAR_USER_IN_GROUP" VBoxManage storageattach "$VM_NAME" \
--storagectl "IDE Controller" \
--port 1 \
--device 0 \
--type dvddrive \
--medium emptydrive
# Host Name und RDP Port
echo "${VM_NAME}-${VAR_RDP_PORT}"
# VDI klonen
sudo -u "$VAR_USER_IN_GROUP" VBoxManage clonehd "$selected_vdi" "$VM_DIR/${VM_NAME}-disk00.vdi"
# VDI an VM anhängen
sudo -u "$VAR_USER_IN_GROUP" VBoxManage storageattach "$VM_NAME" \
--storagectl "SATA Controller" \
--port 0 \
--device 0 \
--type hdd \
--medium "$VM_DIR/${VM_NAME}-disk00.vdi"
# Zusätzliche Festplatten (falls angegeben)
for ((j = 1; j <= VAR_ADDITIONAL_HDD; j++))
do
HDD_NAME="${VM_DIR}/${VM_NAME}-disk0${j}.vdi"
sudo -u "$VAR_USER_IN_GROUP" VBoxManage createmedium disk \
--filename "$HDD_NAME" \
--size 10240 \
--format VDI
sudo -u "$VAR_USER_IN_GROUP" VBoxManage storageattach "$VM_NAME" \
--storagectl "SATA Controller" \
--port "$j" \
--device 0 \
--type hdd \
--medium "$HDD_NAME"
done
) &
done
done
wait
echo "Alle VMs wurden erfolgreich erstellt."