Installing Alpine in a virtual machine

From Alpine Linux
Revision as of 17:15, 21 January 2024 by Zcrayfish (talk | contribs) (→‎KVM / QEMU: Partially transclude QEMU)

This page will walk you through how to setup a virtual machine for AlpineLinux installation


VirtualBox

This guide describes a standard install of Alpine within a Virtual Box VM. (virtual machine)

Oracle VM VirtualBox runs one or more virtual x86 or x64 guests on a host computer.
This enables you to install and test Alpine on your main computer almost as you would any other program.

Preparation

Install Virtual Box on host

First you'll need to download and install Virtual Box on your host computer. Either from the official homepage (for Windows, OS X or Solaris) or from your distribution’s repository (for Linux).

Virtual Box consists of two components:

  • VirtualBox platform package
  • Oracle VM VirtualBox Extension Pack

Install both and start VirtualBox to check for proper operation. If you have problems, consult the VirtualBox user manual or one of the support sites for Virtual Box.

Download Alpine

Download the Virtual Alpine ISO, which is optimized for virtual systems, from the Alpine Download section. Save it in a location where you can find it easily.

Setting up virtual PC

Start Virtual Box. You will see a mostly empty window with a couple symbols in the upper left corner. The leftmost icon is a multi pointed star. If you hover your mouse over it, the tooltip will say “New”.

Click on the multi pointed star to create a new machine. A window will pop up, asking you some questions about the virtual (guest) computer you want to create.

  1. Name: Choose anything you like. e.g. “Alpine”.
  2. Type: Linux
  3. Version: Other Linux, either 64 bit or 32 bit. Choose 64 bit if you downloaded the x86_64 Alpine-ISO, or 32 bit if you downloaded the x86 Alpine-ISO.
  4. Use the default values for the other questions, simply click “next” or “create” until the dialogue finishes.

You will see a new entry in Virtual Box, called Alpine (or the name you chose during step 1 in the dialogue above). Click on it for more information about your guest.

One of the entries should read Mass storage, and offer an IDE controller with a primary master (the virtual hard disc) and a secondary master (the virtual optical drive).

Click on the secondary master. A context menu will pop up. Select the entry “choose image” and open the Alpine ISO you downloaded earlier.

Once that is done, click on the green start arrow on the menu bar.

Install Alpine on the virtual computer

Follow the steps described in the Installation Handbook, just as if you were installing Alpine on a real PC.

Tip: Do not reboot your virtual box after the installation. Instead, shut down the virtual machine, remove the Alpine ISO from the virtual optical drive, then restart the virtual machine.

Install drivers for Virtual Box

Once you successfully reboot into the Alpine VM, there are two steps left:

  1. Enable the Community Respository
  2. Enable VirtualBox shared folders

These two steps install all drivers that other programs might request, and activate several comfort functions.

Note: The Virtualbox webcam driver is not present in the kernel provided with the Virtual Alpine ISO. To use the webcam whilst keeping the installation footprint small, install the linux-firmware-none package using apk, then install the linux-lts package to download a kernel with the appropriate drivers without pulling in hundreds of MB of uneeded firmware files. Uninstall the linux-virt package and reboot to use the new kernel.


KVM / QEMU

Main article: QEMU#Install Alpine Linux in QEMU

QEMU is a very flexible open source virtual machine and emulator. QEMU is able to virtualize or emulate x86, x86_64, PowerPC, ARM, and S390 guests.

Install Alpine Linux in QEMU

Before You Start

  • Download the latest Alpine image.
  • Install QEMU on your system (e.g. sudo apt install qemu on Ubuntu, yum -y install qemu on Fedora)

If you are using Alpine Linux, you can install:

# apk add qemu qemu-img qemu-system-x86_64 qemu-ui-gtk

Create the Virtual Machine

Create a disk image if you want to install Alpine Linux.

qemu-img create -f qcow2 alpine.qcow2 8G

The following command starts QEMU with the Alpine ISO image as CDROM, the default network configuration, 512MB RAM, the disk image that was created in the previous step, and CDROM as the boot device.

qemu-system-x86_64 -m 512 -nic user -boot d -cdrom alpine-standard-3.20.3-x86_64.iso -hda alpine.qcow2 -display gtk -enable-kvm

Tip: Remove option -enable-kvm if your hardware does not support this.

Log in as root (no password) and run:

setup-alpine

Follow the setup-alpine installation steps.

Run poweroff to shut down the machine.

Booting the Virtual Machine

After the installation, QEMU can be started from disk image (-boot c) without CDROM.

qemu-system-x86_64 -m 512 -nic user -hda alpine.qcow2

Live mode

To just give Alpine Linux a try in diskless mode, qemu can be used to boot the .iso file without any need for a virtual HDD image or further configuration.

qemu-system-x86_64 -m 512 -nic user -boot d -cdrom alpine-3.20.3-x86_64.iso --accel kvm

Letting the .iso image load an apkovl

This works by mounting a persistent filesystem under /media and selecting it to store the apkovl and the apkcache.

Preparing a KVM with a virtual drive:

mkdir -p /media/usb/images qemu-img create -f raw /media/usb/images/mykvm.config 32M qemu-system-x86_64 -enable-kvm -m 384 \ -name mykvm \ -cdrom /media/usb/images/alpine-3.20.3-x86_64.iso \ -drive file=/media/usb/images/mykvm.config,if=virtio \ -net lan \ -boot d &

And inside the KVM (running Alpine Linux): 

fdisk /dev/vda  #creating a partition
mkdosfs /dev/vda1
mkdir -p /media/vda1
echo "/dev/vda1 /media/vda1 vfat rw 0 0" >> /etc/fstab
mount -a
setup-alpine  # (select vda1 for saving configs)
lbu commit

The next reboot then loads the generated apkovl and apkcache found on /dev/vda1 -- completely running-from-ram based on the latest official ISO.

Advanced network configuration

To get networking running correctly, you can use the tun/tap interface, which then becomes a real interface. The key is to define the virtual network interface on the correct virtual vlan, and the correct ifup script.

You need 2 net commands on the command line interface, one for the host: 

-net tap,vlan=[somenumber],ifname=[host if],script=[some script]

one for the guest 

-net nic,vlan=[samenumber]

So to have a single NIC on the qemu virtual system that is connected to tap0 on the physical host: 

qemu -net tap,vlan=0,ifname=tap0,script=./qemu-ifup -net nic,vlan0 \
    -boot d -cdrom alpine*.iso}}


To create a qemu guest with more than one nic, just repeat the -net commands 

qemu -net tap,vlan=0,ifname=tap0,script=./qemu-ifup -net nic,vlan0 \
      -net tap,vlan=0,ifname=tap1,script=./qemu-ifup -net nic,vlan0 \
      -net tap,vlan=0,ifname=tap2,script=./qemu-ifup -net nic,vlan0 \
      -boot d -cdrom alpine*.iso}}

Now your alpine guest will have 3 NICs, mapped to tap0, tap1, and tap2 respectively.

What's actually happening is you are effectively creating a point-to-point tunnel, with the phys tap0 device being one endpoint, and the virtual box's eth0 being on the other point of the tunnel.

So you need to assign ip addresses to BOTH sides of the tunnel. The qemu-ifup script is what does that for the host. Here's an example: 

#!/bin/sh
case $1 in
      tun0 | tap0 )
              sudo /sbin/ip addr add 192.168.1.100/24 dev $1
              sudo /sbin/ip link set $1 up
              ;;
      tap1 | tun1 )
              sudo /sbin/ip addr add 192.168.2.100/24 dev $1
              sudo /sbin/ip link set $1 up
              ;;
      tap2 | tun2 )
              sudo /sbin/ip addr add 192.168.3.100/24 dev $1
              sudo /sbin/ip link set $1 up
              ;;
      esac

In your alpinebox, create an interfaces file like this: 

iface eth0 inet static
      address 192.168.1.1
      netmask 255.255.255.0
      gateway 192.168.1.100

iface eth1 inet static
      address 192.168.2.1
      netmask 255.255.255.0

iface eth0 inet static
      address 192.168.3.1
      netmask 255.255.255.0

If on your host you now add a MASQUERADE rule for tap0 to your host's default nic, and you turn on ip_forward on your host, you can now do svn updates, surf, run tranmission, etc right from your qemu guest.

Using Xorg inside QEMU

The video driver needed for Xorg inside QEMU for Alpine 3.17 and older is xf86-video-modesetting. In newer releases of alpine, the driver is automatically pulled in as part of setup-xorg-base.

Tip: Probably for KVM/Qemu guests you want to use qxl Video and Display Spice. For this purpose install xf86-video-qxl on guest and run a Spice client on the host

If you decided to use a qxl Video on KVM/Qemu guest, add this configuration to /etc/X11/xorg.conf

Contents of /etc/X11/xorg.conf

Section "Device" Identifier "qxl" Driver "qxl" Option "ENABLE_SURFACES" "False" EndSection

Run a guest OS on Alpine Linux using KVM/QEMU

Install:

# apk add qemu-system-x86_64 qemu-modules libvirt libvirt-qemu

Note: also install virt-manager for a KVM/QEMU gui


Add tun to /etc/modules:

# echo tun >> /etc/modules


Starting tun now:

# modprobe tun


Add your user to the kvm and qemu groups

# addgroup <username> kvm

# adduser <username> qemu

Logout for the group changes to take effect


Adding services:

# rc-update add libvirtd

# rc-update add libvirt-guests

Starting the services now:

# rc-service libvirtd start

# rc-service libvirt-guests start


If you are interested in using a bridged network (so that the guest machine can be reached easily from the outside), see Bridge.

VMware

See instructions for installing Alpine on VMware and VMware ESXi.

See Also

Retrieved from "https://wiki.alpinelinux.org/w/index.php?title=Installing_Alpine_in_a_virtual_machine&oldid=26327"