Ramroot is a lightweight solution for live-booting Ubuntu or Debian over HTTP, similar to how NFS roots are supported. It is implemented as a plugin to the standard Ubuntu initrd images.

Possible use cases include, but are not limited to:

• Rescue images
• Automated maintenance tasks (firmware upgrades, etc)
• Souped-up bootloader using kexec

The main advantage of using Ramroot over NFS-based live booting is that you don't need an NFS server. NFS can be tricky to make reliable at scale, but if scale is an issue you probably already have scalable infrastructure for serving HTTP.

Ramroot has the following dependencies:

• Ubuntu or Debian for creating the initrd and root image (a Docker image will do)
• pixz for compressing/uncompressing the image

To install Ramroot, simply copy the initramfs-tools folder into /etc/initramfs-tools in an Ubuntu or Debian system. Whenever you install a new kernel, Ramroot will be included in the initrd image. To regenerate the initrd of an already installed kernel in order to include Ramroot, use update-initramfs.

The Ramroot image itself can be generated using whatever tools you prefer, as long as the output is an xzipped tarball of the root filesystem stored in a file ending with .tar.xz. We have included instructions on how to create both the kernel/initrd images and the ramroot filesystem using Docker.

When configuring your PXE boot, configure it as you normally would, except you skip creating the nfs share and replace

boot=casper netboot=nfs nfsroot=server:/path

with

boot=ramdisk ramroot=https://your.server/ramroot.tar.xz

in the kernel parameters.

We recommend using a PXE solution capable of transferring the kernel and initrd over HTTP, such as iPXE or lpxelinux. Using HTTP instead of TFTP for transferring the initrd is significantly faster.

You may also want to configure your PXE solution to provide the mac address of the NIC you booted from in the BOOTIF kernel parameter. This will allow the gen_network_interfaces script to configure the linux system to use the same NIC you booted from. This allows networking to work smootly both during and after booting.

See Dockerfile.kernel-example for an example Dockerfile for generating an initrd image.

To generate the initrd and extract it from the docker image, you can use or adapt the following commands:

# Build the Docker image
docker build -f Dockerfile.kernel-example -t ramroot-kernel .
# Extract the kernel and initrd
docker run --rm -v $PWD:/host ramroot-kernel bash -c 'cp -v /boot/initrd.img-* /boot/vmlinuz-* /host'

You will now find a kernel image (vmlinuz-*) and an initrd image (initrd.img-*) in the current working directory.

You can customize the Dockerfile if you need more included in your initrd.

To create a Ramroot image using Docker, simply create a docker image and convert it using docker-to-ramroot in the tools folder. See Dockerfile.ramroot-example for a bare-bones image based on the official ubuntu:16.04 image:

# Build the Docker image
docker build -f Dockerfile.ramroot-example -t ramroot .
# Convert the Docker image to a ramroot
tools/docker-to-ramroot ramroot ramroot.tar.xz

Notice how this image does not need to include the kernel and modules. This allows you to upgrade the ramroot and the kernel independently, and also makes the image smaller.

Ramroot supports the same hooks a standard Ubuntu initrd does. To run custom scripts in the end of the initrd execution, add them to /etc/initramfs-tools/scripts/ramdisk-bottom. A few scripts for kernel and network configuration are already provided.

Ramroot is released under the MIT licence.