Creating a Bootable USB Drive with Arch Linux Live Image

Every Linux enthusiast has a favorite operating system. Some even have several, each tailored for specific tasks. One such special case is a portable system that you can boot on someone else’s machine or on your own if your main OS suddenly stops functioning properly.

There are many ready-made solutions designed for these tasks. However, we want to create a fully customized environment—one that’s familiar and equipped with the necessary programs!

There are two options here: create a bootable ISO image or simply install everything on a flash drive. The first option will result in a much more compact system, while the second option provides the important capability to install and remove programs and change settings while the system is running.

Yes, USB drives will wear out over time, but they are inexpensive these days, and being able to run a full-fledged operating system, in my opinion, is far more important.

Preparation

I will conduct all operations on Arch Linux for x86-64 and will use the original archiso, which is used to create official ISO images.

Therefore, the system must have the following packages installed: archiso, arch-install-scripts, and gptfdisk.

You can either install directly onto a USB drive or create a disk image that can later be written to a flash drive. I’ll now describe the process of creating a disk image.

Creating an Empty File Sized for the USB Drive

Navigate to the directory where we will create our image.

The following actions will be performed with superuser privileges.

To help you navigate more easily, I’ll display the output of certain commands.

You can find out the exact size of the device using the command

It will display all devices, and you’ll need to identify your USB drive among them.

Once you have the device number, you can create a command and specify the desired file size. Divide the size by 4096 to get the required number of blocks.

Examples:

4096 is the standard sector size for a file system.

The command to create a file named usb.img with a size of 4 GB is:

Let’s check:

If the file turns out to be larger than needed, you can trim it to the desired length using truncate. For example, to reduce it to 16 GB:

Creating Disk Partitioning Layout

To allow our system to boot on computers using both BIOS and EFI, we need to partition the disk into three sections:

1. 10 MB without a filesystem, required for installing the GRUB bootloader in BIOS mode.
2. 256 MB, will be formatted to FAT32, here we will create the boot partition and install GRUB in EFI mode.
3. The remaining space will be allocated to the root filesystem, which will be formatted as Ext4.

Creating a GPT Layout and Partitioning the Disk into Three Parts:

Mounting the Created Image into the System

We establish a connection between the image file usb.img and a loopback device. This allows us to interact with the image file as if it were a physical device, like a USB drive.

The command will display the name of the created device, which in this case is /dev/loop0.

Checking.

Our image should have three partitions: loop0p1, loop0p2, loop0p3.

Formatting Partitions

According to the standard, the EFI partition should be formatted in FAT32.

The third section will be the main one, and you can choose any file system for it that is supported by both the bootloader and the kernel.

Formatting to Ext4:

Mount Partitions on /mnt/usb

First, we’ll mount the partition /dev/loop0p3, which will serve as our main partition for installing the system. Then, within this partition, we’ll create a directory /boot, where we’ll mount the partition /dev/loop0p2.

Copying airootfs

A few words about Archiso. This is the tool used to create official Arch Linux images. It consists of two parts: the mkarchiso script, which assembles the image, and a directory with the configuration settings for the upcoming image. We will need the configuration directory, which contains:

• A list of packages that need to be installed, stored in the packages.x86_64 file.
• The airootfs directory. Its structure is identical to that of Arch Linux and contains the system configuration files.

We will need to specify the path to the directory with Archiso settings three times. To make this easier, let’s assign the path to a variable.

We replicate the settings from the official image before installing packages. If a configuration file for a package already exists during its installation, the file is not overwritten; instead, a new file with the extension .pacnew is created. You will see warnings about this during the package installation process.

Translating Certain Files into Russian (Optional)

You can customize the system’s greeting message to whatever you like. The greeting file is located at /etc/motd. I’ve (okay, Yandex did) provided a simple translation of the original file, and below is the command to replace it.

In the installation image, there’s a command called Installation_guide that opens the system installation wiki page in a text-based console browser.

Replace the link so that it points to a Russian-language equivalent of the page.

Installing Packages

The list of packages is taken from the official image settings.

Installation Command:

To parse the list of packages, you can use the following command:

If the process concludes with these lines, you can proceed to the next step. If not, double-check to ensure you completed each action correctly.

Fine-Tuning the Setup

The main part of the installation aligns with what is written in the official wiki.

For convenience, I’ll repeat some of the steps from the official guide in this article.

We are generating the /etc/fstab file for our image, which is a list of file systems that are mounted during system startup.

We’ll switch to a chroot environment. This will isolate the process from the rest of the system, creating a virtual environment where the process can operate as if it were on a separate system.

After executing this command, the current process and all its child processes will operate in an isolated environment with /mnt/usb as the root directory.

We need to edit the /etc/fstab file.

If the system you’re creating an image from uses a swap partition, then the entry for mounting this partition will be added to the /etc/fstab file when it’s generated.

You need to disable the swap partition in the fstab file if it exists. Remove or comment out the line that corresponds to it.

I also recommend changing the mount options from realtime to noatime. This reduces the number of write operations to the disk.

Below is an example of a file with modifications; the UUID values in your file will be different.

Set your time zone.

The file /etc/locale.gen includes a list of available system localizations. It is recommended to keep these two:

Generate localization files.

Set a system-wide value for the LANG variable.

Set the font and layout switch parameters.

In the file /etc/vconsole.conf, enter:

Setting up Bootloaders

Start by creating an initial system boot disk.

Edit the configuration file located at /etc/mkinitcpio.d/linux.preset.

We will use the standard mkinitcpio configuration file, so make sure to modify the line that points to the config.

Edit the mkinitcpio configuration file. In the HOOKS parameter, you need to remove autodetect.

Regenerate the initcpio image.

Install the bootloader for systems with BIOS. It is placed at the beginning of the disk, which is why we created the first partition.

Note: The command specifies the disk, not the disk partition!

Installing the bootloader for EFI systems.

Create a configuration file for the bootloader.

As you might have understood, we have installed two bootloaders, and both of them refer to a single configuration file.

The official ISO image of Arch Linux uses the Syslinux bootloader. You could use it too; it’s a matter of preference. I opted for a simpler configuration option.

Configuring Logging

To reduce the number of disk accesses, configure logging to use RAM instead of the disk.

Creating a Directory:

Record the following settings in the file /etc/systemd/journald.conf.d/10-volatile.conf:

Additional Setup Steps

When creating an ISO disk image using mkarchiso, some configurations are handled using “hooks” (command-line scripts) in the pacman package manager. These hooks are removed during the ISO creation process.

Since we are building the image ourselves, we need to manually remove certain hooks.

Setting the Root Password (Optional)

By default, there is no password set for the root user, allowing you to establish your own. During startup, the system automatically logs in as root.

SSH access for the root user is also enabled by default.

You can also create a regular user.

Image Ready: Unmount Devices

Exiting chroot.

Unmount the partitions in reverse order.

We will deactivate the loop device mapping to the usb.img file.

Writing the Image to a USB Drive

Attention! If you haven’t broken your system yet, this might be a great opportunity to do so. So be extremely cautious.

Connect the USB drive to the system and enter the command:

Find the USB drive in the list and note down its number.

And write the image to it. In the command below, replace the of=/dev/sdX parameter (substitute the letter of your drive for X).

Exit the root environment:

Testing the Image with QEMU (Optional)

To test how our image operates, we can run it in an emulator.

This section assumes that you have these packages installed:

You can launch a virtual machine from the created image using the following command:

You can connect to the virtual machine using any VNC client.

For TigerVNC, the command to connect would be as follows:

To connect to the virtual machine’s management console, you can use tools like nc (netcat).

Summary

We have a system installation image file that can be written to any media. The key feature is that once you boot from it, you can install additional packages and configure the system to meet your specific needs.

I used a 4 GB flash drive, and after performing all the necessary actions, 1.2 GB of free space remained on it.

Bonus Tips

This disk imaging method is versatile and can be used with various Archiso configurations. For example, it can be applied with Ctlos, one of the locally developed Arch Linux distributions.

The author, Сtlos, uses a custom repository for certain packages. You can find the instructions for connecting it on the project page.

Alternatively, you can edit the pacman.conf file (located in the configuration directory) by adding an additional repository and disabling package signature verification.

Here is an example of a modified pacman.conf file:

Important point: It’s better to clone a remote repository as root because all files in the configuration directory should belong to the root user.