This is a tool for converting a physical computer into a ganeti instance. It consists of two parts, a ganeti instance OS template that allows the instance to be booted to receive the files, and a script that is run on the source machine to make the transfer.
A design document is available in doc/design.rst that describes the functioning of the system. This document will focus on getting the system up and running, and the process for actually performing physical-to-virtual transfers.
The following external programs are used by this package:
- paramiko is needed on the transfer OS (live image booted on the source machine) for making SSH connections
- pymox is required to run the unit tests (make check)
- rst2html, from docutils is needed to build the html documentation (make doc)
The bootstrap OS is a somewhat modified version of the
instance-debootstrap OS definition, whose documentation is located in
doc/README.debootstrap.rst. The first step will be to install this
OS definition onto the nodes of the cluster so that instances can be
created.
In order to install this package from source, you need to determine what
options ganeti itself has been configured with. If ganeti was built
directly from source, then the only place it looks for OS definitions is
/srv/ganeti/os, and you need to install the OS under it. Distribute
and install the package:
gnt-cluster copyfile /root/ganeti-p2v-transfer-0.1.tar.gz
gnt-cluster command "tar xf ganeti-p2v-transfer-0.1.tar.gz &&
cd ganeti-p2v-transfer-0.1 &&
./configure --prefix=/usr --localstatedir=/var \
--sysconfdir=/etc \
--with-os-dir=/srv/ganeti/os &&
make install-target"
If ganeti was installed from a package, its default OS path should
already include /usr/share/ganeti/os, so you can omit
--with-os-dir:
gnt-cluster copyfile /root/ganeti-p2v-transfer-0.1.tar.gz
gnt-cluster command "tar xf ganeti-p2v-transfer-0.1.tar.gz &&
cd ganeti-p2v-transfer-0.1 &&
./configure --prefix=/usr --localstatedir=/var \
--sysconfdir=/etc &&
make install-target"
The actual path that ganeti will search for operating system definitions
can be determined easily in ganeti 2.4.3 by running gnt-cluster info
and looking for the OS search path. In earlier versions, it can be found
by looking for a file named _autoconf.py under a ganeti directory in the
python modules tree (e.g.
/usr/lib/python2.4/site-packages/ganeti/_autoconf.py). In this file,
a variable named OS_SEARCH_PATH will list all the directories in which
ganeti will look for OS definitions. On of these should be passed to
./configure as the value of --with-os-dir.
Once the package is installed, edit the file
/etc/ganeti/instance-p2v-target/p2v-target.conf to uncomment the
EXTRA_PKGS value that is appropriate to the hypervisor you are using
on this cluster. Then distribute the updated file
Edit /etc/ganeti/instance-p2v-target/p2v-target.conf to uncomment
the appropriate value of EXTRA_PKGS. Depending on your setup, you may
need to change other values as well. Then, copy the edited file to all
nodes:
gnt-cluster copyfile /etc/ganeti/instance-p2v-target/p2v-target.conf
As the bootstrap OS is completely overwritten by the files transferred
from the source, it probably doesn't require much configuration.
However, all the information in doc/README.debootstrap.rst about
configuring the OS is still valid if you need it.
The bootstrap OS must be started with a specialized initrd that moves all files into RAM before finishing the boot. Create this initrd by running:
sudo make_ramboot_initrd.py -V $DEB_KERNEL
on the master node, where $DEB_KERNEL is the name of a kernel that can
be used to boot a debootstrap instance. That is, if the filename of the
kernel is /boot/vmlinuz-2.6.32-generic, DEB_KERNEL would be
"2.6.32-generic". This command should create the file
/boot/initrd.img-$DEB_KERNEL-ramboot. Copy this file to the other
nodes with:
gnt-cluster copyfile /boot/initrd.img-$DEB_KERNEL-ramboot
The generated initrd depends heavily on the version of initramfs-tools
installed on the machine that generates it. As a result, it may not be
compatible with the kernel that is to be used for booting the bootstrap
OS. In this case, the bootstrap OS may not boot, or may not be able to
find the root device. If this happens, a good way to improve
compatibility is to use a machine that is already running the instance
kernel, perhaps a "normal" (non-p2v) instance on the same cluster.
Install and run make_ramboot_initrd.py on this machine to generate
the desired initrd.
Users will authenticate to their instances using an SSH keypair
generated in advance by the administrator. The public key will be
installed into root's .ssh/authorized_keys file on the instance, and
the private key will be provided to the user so that they can make the
transfer. Generate the keys, with no passphrase, using the commands:
ssh-keygen -t dsa -N "" -f /etc/ganeti/instance-p2v-target/id_dsa gnt-cluster copyfile /etc/ganeti/instance-p2v-target/id_dsa.pub
Keep the private key (/etc/ganeti/instance-p2v-target/id_dsa)
somewhere safe, and give it to users who wish to use the P2V system.
Now that the nodes are set up to install instances with the bootstrap
OS, we can go ahead and perform a P2V transfer. The first step is to
create the instance that will receive the transfer. Create it with
the p2v-target+default OS and whatever parameters you need. The
default kernel and initrd of the instance should be ones that are both
compatible with and installed on the source OS. Also pass the
--no-start flag, because we want to use the specially generated
initrd for the boot rather than the default one. The command line will
look something like the following:
gnt-instance add -t<template> -s<size> -o p2v-target+default \ -n<nodes> --no-start <hostname>
Now boot the instance using the kernel and initrd that work on the initrd:
gnt-instance start -H kernel_path=/boot/vmlinuz-$DEB_KERNEL,\ initrd_path=/boot/initrd.img-$DEB_KERNEL-ramboot <hostname>
Before you begin, you will need the private key corresponding to the public key installed on the instance. Your administrator will provide this to you.
Boot the source machine from a LiveCD or PXE image. Extract the ganeti-p2v-transfer tarball and run:
./configure --prefix=/usr --localstatedir=/var \ --sysconfdir=/etc sudo make install-source
This will install the p2v_transfer.py script. The script requires
the following arguments:
- $root_dev
- the device file for the disk on which the root filesystem of the source machine is stored
- $target_host
- the hostname or IP address of the instance to receive the transfer
- $private_key
- the private key obtained from the administrator
Run the script, and your data will be transferred:
sudo p2v_transfer.py $root_dev $target_host $private_key
When the transfer finishes, the script will shut down the instance. When the ganeti watcher restarts it, log in and make sure that everything works.
These instructions suggest building the initrd on a node, for convenience. However, it is possible that there are incompatibilities between the initramfs-tools installed on the node and the kernel that will be used for the bootstrap OS. In this case, the bootstrap OS may not boot, or may not be able to find the root device. If this happens, a good way to improve compatibility is to use a machine that is already running the instance kernel, perhaps a "normal" (non-p2v) instance on the same cluster. Install and run make_ramboot_initrd.py on this machine to generate the desired initrd.
Another possibility is that the bootstrap OS does not have enough RAM to complete its boot. Since the bootstrap OS must be copied entirely into RAM, instances with small memory sizes are not supported. I have had good luck using 768MB of instance memory.
The version of debootstrap installed on the nodes may not be recent
enough to support installing squeeze. Try changing the SUITE variable in
/etc/ganeti/instance-p2v-target/p2v-target.conf to something older:
SUITE="lenny"