After installing a fresh instance of OpenNebula, the next logical step for some users might be the creation of a Virtual Machine (VM) image. The OpenNebula project provides many ready-to-use appliances as part of its public marketplace, but sometimes you need to produce your own image for a specific purpose. In this post I will guide you through the process of creating a customized VM image ready for production. Ready, steady, go! 🙂
Creating a base VM image
The main tool we’ll use for this is called
libguestfs, which is defined in its own website as a set of “tools for accessing and modifying virtual machine disk images”. More importantly for our purposes, these tools can also be used to create VM images.
Let’s install them by using one of these commands, depending on your Linux distribution.
sudo yum install libguestfs-tools
sudo apt-get install libguestfs-tools
The first step is to double-check all the possible VM images that we can create with
libguestfs. To do so, let’s execute the following command to have a look at the full list of all base images available to us (in this example we will be working only with CentOS 7.7):
If we were only interested at this stage in creating a simple CentOS VM image, we could do that by using the following command, and it would create a local file called
centos-7.7.qcow2 containing our new image:
virt-builder centos-7.7 --format qcow2
After this, a new CentOS VM image has been created but it’s not ready yet for OpenNebula. For that, we need to take a crucial step: to install the context packages inside the VM.
To make sure that the new VM comes with all the necessary packages already preinstalled, we can create a local file in our computer called
script.sh, which will be executed inside our VM image at the time we generate it.
We need this script to contain the context that turns a generic CentOS VM image into an OpenNebula-ready CentOS VM image:
curl -L https://github.com/OpenNebula/addon-context-linux/releases/download/v5.10.0/one-context-5.10.0-1.el7.noarch.rpm
yum install -y epel-release
yum install -y one-context-[0-9]*el7*rpm
rm -f one-context-5.10.0-1.el7.noarch.rpm
With this file ready, now we can run
virt-builder and pass this script as argument. This will create a CentOS VM images with the contextualization packages already installed inside:
sudo virt-builder centos-7.7 --format qcow2 --run script.sh
Now we have a generic CentOS VM image ready for OpenNebula! 😀
Setting up a gaming server
But what to do if we don’t want that VM image to be so generic? 😉 Let me introduce you to the wonders of Xonotic: based on a GPLv3 license, and first released in 2011, this well-known video game came to life after their creators joined forces to “create the best possible fast-paced open-source first-person shooter game”.
To prepare a VM image with a preinstalled Xonotic server, we just need to include a few additional lines into
script.sh, the file we’ve used in the previous section to add the OpenNebula context to our CentOS VM image:
# Download Xonotic
# Install unzip to decompress the downloaded file
yum install -y unzip
# Decompress the game
# Remove the downloaded file
rm -f xonotic-0.8.2.zip
With these changes in the script, we’ll get the game folder inside our VM image. Now all we need to do is get the Xonotic server properly configured. For this, we’ll follow the steps for a “Dedicated Server” described at the project’s documentation and—surprise, surprise—add some lines to our beloved
script.sh 🙂 The files needed to set up a Xonotic server come with the game, from the main game directory (in our case
# Copy game executable (for Linux operating systems)
cp Xonotic/server/server_linux.sh Xonotic/
# Copy server.cfg to user profile (root)
cp Xonotic/server/server.cfg /root/.xonotic/data/
# Move game directory to user directory (root)
mv Xonotic /root/
With this configuration, we’d always be able to login to our VM at any point and launch the server manually by executing
/root/Xonotic/server_linux.sh But what if we want the server to run automatically when the VM starts? A piece of cake! We just need to set up a service to make this happen. Let’s create a simple file called
xonotic.service with the following content:
Description=Xonotic Server Service
With the option
--copy-in file:destination, we can use
virt-builder to copy
xonotic.service into the
/etc/systemd/system/ directory when generating the VM image. But before that, we just need to add some extra lines—this is the last time, I promise!—to
# Give permissions
chmod 664 /etc/systemd/system/xonotic.service
# Reload systemctl to include this new service
# Enable service (we don't start it)
systemctl enable xonotic.service
After this very last changes to the script, the command to create a CentOS-based OpenNebula appliance with a ready-to-use Xonotic game server would look like this:
sudo virt-builder centos-7.7 --format qcow2 --copy-in xonotic.service:/etc/systemd/system/ --run script.sh
Voilà! Of course, we can add many more configuration options to the
virt-builder command, but this basic configuration will get the job done.
Now, time for you to give it a try and start creating you own customized OpenNebula VM images.
Enjoy and keep us posted!