Alpine Linux - User contributions [en]

Setting up disks manually

2023-11-30T11:38:52Z

Andrew71: Fix typo

The menu choices that are provided by <code>setup-alpine</code> might not cover all needs, however, it's possible to:

* Call [[Alpine_setup_scripts#setup-disk|setup-disk]] directly, instead of through <code>setup-alpine</code>, and pass some specific partitioning parameters to it.
* Set up the partitions and filesystems manually (to the desired details) and [[Alpine_setup_scripts#Partitioning|tell setup-disk]] to install to the prepared target mountpoint.

(Beta reference: [https://docs.alpinelinux.org/user-handbook/0.1a/Installing/manual.html#_finalizing docs.alpinelinux.org] )

== Using setup-alpine (setup-disk) features ==

=== For "diskless" and "data" disk mode installs ===

This requires some manual steps, as long as the setup-scripts auto-detect usable partitions only on '''removable''' devices (not internal harddisks). They do not support creating new, writable partitions to be used by Alpine.

How to prepare writable storage space is explained in the section [[Setting_up_disks_manually#Manual_partitioning| manual partitioning]], below.

=== For "sys" disk mode installs ===

{{Draft|Some information on this page may be incomplete or outdate.}}

==== Disk layouts ====

It is possible to have one or more of RAID, encrypted, and/or Logical Volume on your {{Path|/}} (root) volume. However, the Alpine init script only knows how to handle them when they're layered in that order, and your initram and extlinux.conf files in the {{Path|/boot}} partition are configured properly.

Your {{Path|/boot}} directory cannot reside on an encrypted or LVM volume, at least not with Alpine's default bootloader (extlinux). (Grub2 can deal with {{Path|/boot}} being on an LVM volume.) The usual practice is to create a small partition for {{Path|/boot}}, then devote the rest of your disk to a separate partition on which you layer one or more of RAID, encryption, and/or Logical Volumes.

Sometimes {{Path|/boot}} is also set up as a mirrored (RAID1) volume. However, this is just for post-init access. That way, when you write a new kernel or bootloader config file to {{Path|/boot}}, it gets written to multiple physical partitions. During the pre-init, bootloader phase, only one of those partitions will be read from.

A typical setup might look like this:

<pre>
One-disk system
---------------
+------------------------------------------------+
| small partition (32--100M), holding |
| only /boot, filesystem needn't be journaled |
+------------------------------------------------+
| rest of disk in second partition |
| +------------------------------------------+ |
| | cryptsetup volume | |
| | +-------------------------------------+ | |
| | | LVM PV, containing single VG, | | |
| | | containing multiple LVs, holding | | |
| | | /, /home, swap, etc | | |
| | +-------------------------------------+ | |
| +------------------------------------------+ |
+------------------------------------------------+

Two-disk system
---------------
+------------------------------------------------+ +------------------------------------------------+
| small partition (32--100M), holding | | small partition (32--100M), holding | These 2 partitions might
| only /boot, filesystem needn't be journaled | | only /boot, filesystem needn't be journaled | form a mirrored (RAID1)
+------------------------------------------------+ +------------------------------------------------+ volume
| rest of disk in second partition | | rest of disk in second partition |
| T================================================================================================T | These 2 partitions form
| T +--------------------------------------------------------------------------------------------+ T | a second mirrored
| T | cryptsetup volume | T | (RAID1) volume
| T | +---------------------------------------------------------------------------------------+ | T |
| T | | LVM PV, containing single VG, | | T |
| T | | containing multiple LVs, holding | | T |
| T | | /, /home, swap, etc | | T |
| T | +---------------------------------------------------------------------------------------+ | T |
| T +--------------------------------------------------------------------------------------------+ T |
| T================================================================================================T |
| | | |
+------------------------------------------------+ +------------------------------------------------+

</pre>

In a three-disk system, the {{Path|/boot}} would still be RAID1, but the larger partition might, in that case, be RAID5.

==== RAID ====

<code>setup-disk</code> will automatically build a RAID array if you supply the '''-r''' switch, or if you specify more than one device.

If you want to build your RAID array manually, see [[Setting up a software RAID array]]. Then you can add additional layers of encryption and/or Logical Volumes, or just assemble the RAID array, and supply the {{Path|/dev/mdi}} device directly to [[setup-disk]]. When you're finished, be sure to disassemble the RAID array before rebooting.

If <code>setup-disk</code> sees that you're using RAID, either because you gave it the <code>-r</code> switch, or multiple devices, or a {{Path|/dev/mdi}} device, then it will set up your initramfs and extlinux.conf file properly. However, in other cases, such as when you're also using encryption, or you invoke <code>setup-disk</code> with a mounted directory argument, these might not be properly set up for RAID. In that case, you may need to manually edit/rebuild them. The following assumes that <code>$MNT</code> holds the root directory you're installing into:

{{Cmd|1=echo "/sbin/mdadm" > $MNT/etc/mkinitfs/files.d/raid
echo "/etc/mdadm.conf" >> $MNT/etc/mkinitfs/files.d/raid
# edit $MNT/etc/mkinitfs/mkinitfs.conf to make sure features="..."
# includes raid (this field is space-separated and quoted)
mkinitfs -c $MNT/etc/mkinitfs/mkinitfs.conf -b $MNT
# edit $MNT/etc/update-extlinux.conf to make sure modules=... contains
# raid1 or raid456 (whichever your / is on; this field is comma-separated)
# also check the root= setting
extlinux --raid --install $MNT/boot --update
}}

{{Todo|Does adding the <code>--update</code> option to <code>extlinux ...</code> suffice to make {{Path|/boot/extlinux.conf}} be regenerated? Or do we need to manually tweak that file, or run <code>update-extlinux</code>, as well?}}

You might also need to manually tweak {{Path|$MNT/etc/fstab}}. And you might need to copy {{Path|/usr/share/syslinux/mbr.bin}} to your disk's MBR.

==== Encryption ====

See [[Setting up encrypted volumes with LUKS]]. You can add an additional Logical Volume layer, or just unlock the volume you've created (using <code>cryptsetup luksOpen ...</code>), and supply the {{Path|/dev/mapper/something}} device directly to [[setup-disk]]. When you're finished, be sure to relock the volume (using <code>cryptsetup luksClose ...</code>) before rebooting.

If you install your {{Path|/}} (root) on an encrypted volume, you'll need to manually edit/rebuild your initram and your extlinux.conf file. The following assumes that <code>$MNT</code> holds the root directory you're installing into, that you've created the cryptvolume on the device {{Path|/dev/md2}}, and that you want to unlock the encrypted volume into a virtual volume named "crypt":

{{Cmd|1=# edit $MNT/etc/mkinitfs/mkinitfs.conf to make sure features="..."
# includes cryptsetup (this field is space-separated and quoted)
mkinitfs -c $MNT/etc/mkinitfs/mkinitfs.conf -b $MNT
# edit $MNT/etc/update-extlinux.conf to make sure default_kernel_opts="..."
# contains cryptroot=/dev/md1 and cryptdm=crypt (this field is also space-separated and quoted)
# also check the root= setting
extlinux --install $MNT/boot --update
}}

{{Todo|Does adding the <code>--update</code> option to <code>extlinux ...</code> suffice to make {{Path|/boot/extlinux.conf}} be regenerated? Or do we need to manually tweak that file, or run <code>update-extlinux</code>, as well?}}

You might also need to manually tweak {{Path|$MNT/etc/fstab}}.

==== LVM ====

<code>setup-disk</code> will automatically build and use volumes in a LVM group if you supply the '''-L''' switch.

If you instead want to build your LVM system manually, see [[Setting up Logical Volumes with LVM]]. Then <code>vgchange -ay</code>, format and mount your volumes, and supply the root mountpoint to [[setup-disk]]. When you're finished, be sure to
{{Cmd|umount ...
vgchange -an}}
before rebooting.

If <code>setup-disk</code> sees that you're using LVM, perhaps because you gave it the <code>-L</code> switch, then it will set up your initram and extlinux.conf file properly. However, in other cases, these might not be properly set up. In that case, you may need to manually edit/rebuild them. The following assumes that <code>$MNT</code> holds the root directory you're installing into:

{{Cmd|1=# edit $MNT/etc/mkinitfs/mkinitfs.conf to make sure features="..."
# includes lvm (this field is space-separated and quoted)
mkinitfs -c $MNT/etc/mkinitfs/mkinitfs.conf -b $MNT
# edit $MNT/etc/update-extlinux.conf to make sure root= is set correctly
extlinux --install $MNT/boot --update
}}

{{Todo|Does adding the <code>--update</code> option to <code>extlinux ...</code> suffice to make {{Path|/boot/extlinux.conf}} be regenerated? Or do we need to manually tweak that file, or run <code>update-extlinux</code>, as well?}}

You might also need to manually tweak {{Path|$MNT/etc/fstab}}.

== Manual partitioning ==

=== For "diskless" and "data" disk mode installs ===

The installation image enviroment may have only the very basic busybox built-in <code>fdisk</code> command available. However, alpine allows you to install more complete partitioning tool packages like <code>sfdisk</code> (scriptable fdisk), <code>gptfdisk</code>, <code>parted</code> (CLI), <code>cfdisk</code> (text menus), or even <code>gparted</code> (after [[Installation#Post-Install|setting up a graphical environment]]).

The following example installs <code>cfdisk</code>, looks for existing partitions, and runs cfdisk against <code>/dev/sdX</code>:
# apk add cfdisk
# blkid
/dev/sdX1: LABEL="some" UUID="..." TYPE="vfat"
/dev/sdX2: LABEL="other" UUID="..." TYPE="ext4"
# cfdisk /dev/sdX

* Be aware of this Bug: {{Issue|11589|The APKOVL loading of diskless setups doesn't work on btrfs and xfs filesystems, or nvme-based devices}} => So, for the moment, use only ext4 filesystem partitions on classic drives to store diskless mode states.

The following creates an ext4 partition with disabled journaling, to reduce write operations and allow the disk to spin down after the .apkovl and the packages have been read from the partition during the boot.
# apk add e2fsprogs
# mkfs.ext4 -O ^has_journal /dev/sdXY # the "-O ^has_journal" DISABLES journaling ("^" means "not")

{{Note|IMPORTANT! There may be additional steps necessary to make proper use of the partition, see
[[Alpine_local_backup#Saving_and_loading_ISO_image_customizations|Saving_and_loading_ISO_image_customizations]].
}}

{{Note| mkfs.ext4 creates ext4 fs with 64bit feature enabled by default, but extlinux may not be able to boot with that, see Issue {{Issue|14895}}. You may need to add "-O ^has_journal,^64bit" to mkfs.ext4 to circumvent this.
}}

=== For "sys" disk mode installs ===

<code>setup-disk</code> will by default set up a root partition, a separate /boot partition and a swap partition. If you want a different layout, you can manually create the partitions, filesystems and mount them on {{Path|/mnt}} (or any other mount point) then run:

{{Cmd|setup-disk /mnt}}

<code>setup-disk</code> will install your running system on the mounted root, detect your file system layout and generate an fstab.

If you're using the MBR, you are responsible for making the proper partition bootable and make sure the MBR is OK for extlinux. If you're going to use EFI, make sure you mount <code>esp</code> partition on <code>/boot/efi</code> and set <code>BOOTLOADER=grub</code> and <code>USE_EFI=1</code>, and that {{Pkg|grub-efi}} and {{Pkg|efibootmgr}} are installed before running <code>setup-disk</code>. If your system still does not boot, you can try to manually create a boot entry with {{Pkg|efibootmgr}}, for which instructions can be found at [https://wiki.alpinelinux.org/wiki/Bootloaders#efibootmgr EFI Boot Stub].

See also [https://github.com/itoffshore/alpine-linux-scripts setup-partitions]

==== Dual-booting ====
See [[Installing Alpine on HDD dualbooting|Install to HDD with dual-boot]]

==== Other needs ====
* [[Installing Alpine Linux in a chroot]]
* [[Replacing non-Alpine Linux with Alpine remotely]]





=== Setting up swap ===

# create a partition with the type set to "linux swap" (82) (If you're going to use a logical volume for swap, skip this step and <code>lvcreate</code> that instead.)
# <code>mkswap /dev/sda2</code>
# <code>echo -e "/dev/sda2 none swap sw 0 0" >> /mnt/etc/fstab</code>
# <code>swapon /dev/sda2</code> (or <code>rc-service swap start</code>)

{{Cmd|free -m}} will show how much swap space is available (in MB).

If you prefer maximum speed, you don't need configure any raid devices for swap. Just add 2 swap partitions on different disks and linux will stripe them automatically. The downside is that the moment one disk fails, the system will go down. For better reliability, put swap on RAID1.

{{Todo|Instructions for cryptswap?}}

=== Custom boot partition size ===

The default boot partition size is under 40MB. This can cause errors if package updates require additional space on /boot.
Executing <code>export BOOT_SIZE=512</code> before running <code>setup-disk</code> will result in a 512MB boot partition.

[[Category:Installation]]
[[Category:Storage]]

Gitea

2023-11-29T20:49:21Z

Andrew71: Update links

[https://gitea.com Gitea] is a community managed lightweight code hosting solution written in Go. It is a fork of Gogs.

{{Note|This guide is not for installing Gitea in Docker. If you want to install Gitea in a Docker container, follow [https://docs.gitea.com/installation/install-with-docker the official documentation]}}

== Installation ==

First, [[Repositories#Managing_repositories| Enable the Community Repository]]

Then install the {{pkg|gitea}} package:
{{cmd|apk add gitea}}

== Setting up the Database ==

{{Note|These instructions are for MariaDB. If you would like to set up another database, follow [https://docs.gitea.com/installation/database-prep the official documentation]}}

Install the MariaDB and {{pkg|mariadb-client}} packages:
{{cmd|apk add mariadb mariadb-client}}

Set up the MariaDB installation and secure it:
{{cmd|<nowiki>mysql_install_db --user=mysql --datadir=/var/lib/mysql</nowiki>
service mariadb start
rc-update add mariadb
mysql_secure_installation}}

Create the <code>gitea</code> database and a user with access to it:
{{Note|Everything after the <code>mysql -u root -p</code> should be typed in the MariaDB prompt (looks like <code>MariaDB [(none)]></code>)}}
{{Note|Replace the above username 'giteauser' and password 'giteapassword' with something secure. Remember these settings. You will need them later when setting up Gitea.}}
{{cmd|mysql -u root -p

CREATE DATABASE gitea DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
GRANT ALL ON gitea.* TO 'giteauser'@'localhost' IDENTIFIED BY 'giteapassword';
FLUSH PRIVILEGES;
EXIT}}

If you want, you can uninstall the <code>mariadb-client</code> now as it's not needed anymore:
{{cmd|apk del mariadb-client}}

In {{path|/etc/gitea/app.ini}}, replace the contents of the <code>[database]</code> section with the following:
<pre>
DB_TYPE = mysql
HOST = /var/run/mysqld/mysqld.sock
NAME = gitea ; The database name set with 'CREATE DATABASE'
USER = giteauser ; The database user
PASSWD = giteapassword ; The password for the database user
</pre>

== Configurations ==

The Gitea service can be configured using {{path|/etc/conf.d/gitea}}:

{| class="wikitable"
|-
! Description !! Configuration Variable !! Default Value
|-
| User to run Gitea under || GITEA_USER || gitea
|-
| Gitea working directory || GITEA_WORK_DIR || /var/lib/gitea/
|-
| Gitea configuration file || GITEA_CONF || /etc/gitea/app.ini
|}

Some additional settings in {{path|/etc/gitea/app.ini}}:

{| class="wikitable"
|-
! Description !! Configuration Variable !! Default Value
|-
| Gitea customization directory || <code>Cannot be configured</code> || /var/lib/gitea/custom/
|-
| Web files || STATIC_ROOT_PATH || /usr/share/webapps/gitea/
|-
| Data files || APP_DATA_PATH || /var/lib/gitea/data/
|-
| Git repository storage directory || ROOT || /var/lib/gitea/git/
|-
| Log directory || ROOT_PATH || /var/log/gitea/
|}

{{Note|Gitea has a built-in web server, so there is no need to configure one. However, you can [https://docs.gitea.com/administration/reverse-proxies set up a reverse proxy].}}

{{Note|To customize the look and feel of Gitea, find the correct path in {{path|/usr/share/webapps/gitea/}} and make the same path in {{path|/var/lib/gitea/custom/}}. For example, to add a new Gitea theme, create the {{path|/var/lib/gitea/custom/public/css/}} directory, then add the css for the theme there.}}

== Controlling and starting gitea ==

You should not start Gitea without setting certain environment variables and passing some options, since it won't know where to store data and logs, so it is recommended to start gitea using the init script:
{{cmd|service gitea start}}

To add Gitea to the default runlevel (such that it runs automatically on every boot):
{{cmd|rc-update add gitea}}

To stop the Gitea service:
{{cmd|service gitea stop}}

=== Running Gitea without the init script ===

If (for whatever reason), you would like to start Gitea without using the initscript, you should first stop the Gitea service:
{{cmd|service gitea stop}}

Then, run Gitea with this command (as the <code>gitea</code> user):
{{cmd|<nowiki>GITEA_WORK_DIR=/var/lib/gitea gitea web --config /etc/gitea/app.ini</nowiki>}}

This will use the correct configuration file and write to the correct directories.

== Post installation ==

{{Expand}}

After installing Gitea, go to <nowiki>http://localhost:3000</nowiki> and start the post-installation process.

== Setting up SSH Git access ==

'''Do not''' try to be clever and use <code>ssh-copy-id</code>, as it will not have the correct command set.

As an example, if this is the public key:
<pre>
ssh-ed25519 ******************************************************************** **********@gmail.com
</pre>

The line in {{path|.ssh/authorized_keys}} needs to be:
<pre>
command="/usr/bin/gitea --config=/etc/gitea/app.ini serv key-2",no-port-forwarding,no-X11-forwarding,no-agent-forwarding,no-pty ssh-ed25519 ******************************************************************** **********@gmail.com
</pre>

In order to do this, [https://docs.github.com/en/authentication/connecting-to-github-with-ssh/generating-a-new-ssh-key-and-adding-it-to-the-ssh-agent generate a SSH key], then go to the Gitea settings panel and click the <code>Add Key</code> button, then paste in your public key.

Now, once you've added your private key to the SSH agent, you can use SSH with Gitea like you normally would with GitHub, GitLab, etc.

[[Category:Server]]
[[Category:Git]]

Raspberry Pi

2023-11-29T18:58:39Z

Andrew71: Fix broken code tags

{{warning | 11 Feb 2021 - There is currently a known bug upstream [https://github.com/raspberrypi/firmware/issues/1529 kernel/initramfs cannot be loaded from subdirectory with same name as volume label]. Since the kernel is installed to <code>boot/</code>, you must not use a label named <code>boot</code> for the fat32 partition. }}

{{TOC right}}

This tutorial explains how to install Alpine Linux on a Raspberry Pi. Alpine Linux will be installed in [[Installation#Diskless_Mode|diskless mode]], hence, [[Alpine local backup|Alpine Local Backup (lbu)]] is required to save modifications between reboots.

For scenarios where there is not expected to be significant changes to disk after setup (like running a static HTTP server), this is likely preferable, as running the entire system from memory will improve performance (by avoiding the slow SD card) and improve the SD card life (by reducing the writes to the card, as all logging will happen in RAM). Diskless installations still allow you to install packages, save local files, and tune the system to your needs.

If any of the following apply, then installation in [[Classic install or sys mode on Raspberry Pi|sys-mode installation]] is likely more appropriate.

* There will be constant changes to the disk after initial setup (for example, if you expect people to login and save files to their home directories)
* Logs should persists across reboots
* Plan to install packages which consume more space than can be loaded into RAM
* Plan to install kernel modules (such as ZFS)

== Preparation ==

# [https://alpinelinux.org/downloads/ Download] the Alpine for Raspberry Pi tarball. You should be safe using the '''armhf''' build on all versions of Raspberry Pi (including Pi Zero and Compute Modules); but it may perform less optimally on recent versions of Raspberry Pi. The '''armv7''' build is compatible with Raspberry Pi 2 Model B. The '''aarch64''' build should be compatible with Raspberry Pi 2 Model v1.2, Raspberry Pi 3 and Compute Module 3, and Raspberry Pi 4 model B.
# [[Create_a_Bootable_Device#Manually_copying_Alpine_files|Create a bootable FAT32 partition on your SD card.]] The partitioning and formatting part of the instructions on the linked page could be done using a graphical partitioning tool such as [https://en.wikipedia.org/wiki/GNOME_Disks gnome-disks], just make sure the partition type is <code>W95 FAT32 (LBA)</code>. (The current type can be found in the "Type" column in the output of <code>fdisk -l</code>.)
# Extract the tarball to the root of the bootable FAT32 partition.

To setup a headless system, a bootstrapping configuration overlay file [https://github.com/macmpi/alpine-linux-headless-bootstrap headless.apkovl.tar.gz] may be added to enable basic networking, so that following configuration steps can be performed under <code>ssh</code>. Pi Zero may be configured with simple USB ethernet-gadget networking with another computer sharing its internet connection.

Optionally create a '''usercfg.txt''' file on the partition to configure low-level system settings. Specifications can be found [https://www.raspberrypi.org/documentation/configuration/config-txt here]. However, note some settings can only be set directly in '''config.txt''', which may be overwritten after updates. In particular, <code>gpu_mem</code> will have no effect when specified in '''usercfg.txt''' ([https://github.com/raspberrypi/firmware/issues/1332 source]). Some interesting values include:
* To enable the UART console: <code>enable_uart=1</code>
* To enable audio: <code>dtparam=audio=on</code>
* If you see black edges around your screen after booting the Pi, you can add <code>disable_overscan=1</code>
* If you plan to install on a Pi Compute Module 4 with I/O board, you may need to add: <code>otg_mode=1</code>

Recent versions include Broadcom firmware files. If you're using an older Alpine version, see [[#Wireless_support_with_older_Alpine_images|section below]].

== Installation ==

Follow these steps to install Alpine Linux in Diskless Mode:

# Insert the SD card into the Raspberry Pi and power it on
# Login into the Alpine system as root. Leave the password empty.
# Type <code>setup-alpine</code>
# Once the installation is complete, commit the changes by typing <code>lbu commit -d</code>

Type <code>reboot</code> to verify that the installation was indeed successful.

== Post Installation ==

=== Update the System ===

After installation, make sure your system is up-to-date:

{{cmd|apk update
apk upgrade}}

Don't forget to save the changes:

{{cmd|lbu commit -d}}

Note: this does not upgrade the kernel. In order to upgrade the kernel, a full upgrade of the Alpine Linux version must be performed as described in [[Upgrading Alpine#Upgrading Alpine Linux on other removable media (such as CF/USB)|upgrading Alpine Linux for removable media]].

=== Clock-related error messages ===

During the booting time, you might notice errors related to the hardware clock. The Raspberry Pi does not have
a hardware clock, thus you need to disable the hwclock daemon and enable swclock:

{{cmd|rc-update add swclock boot # enable the software clock
rc-update del hwclock boot # disable the hardware clock}}

Since the Raspberry Pi does not have a clock, Alpine Linux needs to know what the time is by using a
[https://en.wikipedia.org/wiki/Network_Time_Protocol Network Time Protocol (NTP)] daemon. Make sure you have a
NTP daemon installed and running. If you are not sure, you can install an NTP client by running the following
command:

{{cmd|setup-ntp}}

The Busybox NTP client might be the most lightweight solution. Save the changes and reboot, once the NTP software is
installed and running:

{{cmd|lbu commit -d
reboot}}

After reboot, make sure the <code>date</code> command outputs the correct date and time.

=== WiFi on boot ===
If you have already [[Connecting_to_a_wireless_access_point|configured WiFi]] during the setup, the connection will not return on reboot.
You will need to start up a service to automatically connect to the wireless access point.
# Run <code>rc-update add wpa_supplicant boot</code> to connect to the wireless access point during bootup.
# Run it manually with <code>rc-service wpa_supplicant start</code>.

=== Enable Graphics ===
Remount the boot partition writeable (i.e. <code>/media/mmcblk0p1</code>):

{{cmd|mount /media/mmcblk0p1 -o rw,remount}}

Add the following lines to <code>/media/mmcblk0p1/config.txt</code>:

dtoverlay=vc4-kms-v3d

If you are experiencing graphical issues, you can also try:

dtoverlay=vc4-fkms-v3d

And perhaps also raising the default <code>gpu_mem</code>:

gpu_mem=128

Note that raising the gpu memory is not likely to [https://www.raspberrypi.com/documentation/computers/config_txt.html#gpu_mem actually improve performance on the Pi4]

Install the Mesa drivers:

{{cmd|<nowiki>apk add mesa-dri-gallium</nowiki>}}

Then reboot:

{{cmd|lbu_commit -d; reboot}}

=== WiFi drivers ===
As of Alpine 3.14, the WiFi drivers for the Raspberry Pi were moved from <code>linux-firmware-brcm</code> to the <code>linux-firmware-cypress</code> package (source?). Since the images seem to be an outdated version of the former, Wi-Fi will work during installation, but after the first update it will break.
Use the ethernet interface to download the required packages:

{{cmd|apk add linux-firmware-cypress}}

And reboot.

== Persistent storage ==
=== Loopback image with overlayfs ===

When you install Alpine in diskless mode, the entire system is loaded into memory at boot. If you want additional storage (for example, if you need more space than offered by your RAM) we need to create loop-back storage onto the SD card mounted with overlayfs.

First, make the SD card writable again and change fstab to always do so:
{{cmd|mount /media/mmcblk0p1 -o rw,remount
sed -i 's/vfat\ ro,/vfat\ rw,/' /etc/fstab}}

Create the loop-back file, this example is 1 GB:

{{cmd|dd if=/dev/zero of=/media/mmcblk0p1/persist.img bs=1024 count=0 seek=1048576}}

Install the ext utilities:

{{cmd|apk add e2fsprogs}}

Format the loop-back file:

{{cmd|mkfs.ext4 /media/mmcblk0p1/persist.img}}

Mount the storage:

{{cmd|echo "/media/mmcblk0p1/persist.img /media/persist ext4 rw,relatime,errors=remount-ro 0 0" >> /etc/fstab
mkdir /media/persist
mount -a}}

Make the overlay folders, we are using the /usr directory here, but you can use /home or anything else.
{{Warning|Overlay workdir needs to be an empty directory on the same filesystem mount as the upper directory. So each overlay must use its own workdir.}}

{{cmd|mkdir /media/persist/usr
mkdir /media/persist/.work_usr
echo "overlay /usr overlay lowerdir=/usr,upperdir=/media/persist/usr,workdir=/media/persist/.work_usr 0 0" >> /etc/fstab
mount -a}}

Your /etc/fstab should look something like this:
{{Cmd|/dev/cdrom /media/cdrom iso9660 noauto,ro 0 0
/dev/usbdisk /media/usb vfat noauto,ro 0 0
/dev/mmcblk0p1 /media/mmcblk0p1 vfat rw,relatime,fmask=0022,dmask=0022,errors=remount-ro 0 0
/media/mmcblk0p1/persist.img /media/persist ext4 rw,relatime,errors=remount-ro 0 0
overlay /usr overlay lowerdir=/usr,upperdir=/media/persist/usr,workdir=/media/persist/.work_usr 0 0}}

Now commit the changes: (optionally remove the e2fsprogs, but it does contain repair tools)
{{cmd|lbu_commit -d}}

Remember, with this setup if you install things and you have done this overlay for /usr, you must not commit the 'apk add', otherwise, while it boots it will try and install it to memory, not to the persistent storage.

If you do want to install something small at boot, you can use <code>apk add</code> and <code>lbu commit -d</code>.

If it is something a bit bigger, then you can use <code>apk add</code> but then not commit it. It will be persistent (in <code>/user</code>), but be sure to check everything you need is in that directory and not in folders you have not made persistent.

=== Traditional disk-based (sys) installation ===
{{Merge|Classic install or sys mode on Raspberry Pi|There's an existing page for sys-installations on RasPi.}}

It is also possible to switch to a fully disk-based installation. This is not yet formally supported, but can be done somewhat manually. This frees all the memory otherwise needed for the root filesystem, allowing more installed packages.

Split your SD card into two partitions: the FAT32 boot partition described above (in this example it'll be <code>mmcblk0p1</code>) , and a second partition to hold the root filesystem (here it'll be <code>mmcblk0p2</code>). Boot and configure your diskless system as above, then create a root filesystem:

{{cmd|apk add e2fsprogs
mkfs.ext4 /dev/mmcblk0p2}}

Now do a disk install via a mountpoint. The <code>setup-disk</code> script will give some errors about syslinux/extlinux, but you can ignore them.
The Raspberry Pi doesn't need them to boot.

{{cmd|<nowiki>mkdir /stage
mount /dev/mmcblk0p2 /stage
setup-disk -o /media/mmcblk0p1/MYHOSTNAME.apkovl.tar.gz /stage
# (ignore errors about syslinux/extlinux)</nowiki>}}

Add a line to <code>/stage/etc/fstab</code> to mount the Pi's boot partition again:

{{cmd|/dev/mmcblk0p1 /media/mmcblk0p1 vfat defaults 0 0}}

Now add a <code>root=/dev/mmcblk0p2</code> parameter to the Pi's boot command line, either <code>cmdline-rpi2.txt</code> or <code>cmdline-rpi.txt</code> depending on model:

{{cmd|<nowiki>mount -o remount,rw /media/mmcblk0p1
sed -i '$ s/$/ root=\/dev\/mmcblk0p2/' /media/mmcblk0p1/cmdline-rpi2.txt</nowiki>}}

You might also consider <code>overlaytmpfs=yes</code> here, which will cause the underlying SD card root filesystem to be mounted read-only, with an overlayed tmpfs for modifications which will be discarded at shutdown.

N.B. the contents of /boot will be ignored when the Pi boots. It will use the kernel, initramfs, and modloop images from the FAT32 boot partition. To update the kernel, initfs or modules, you will need to manually (generate and) copy these to the boot partition or you could use bind mount, in which case,
copying the files to boot partition manually, is not needed.

{{cmd|<nowiki>echo /media/mmcblk0p1/boot /boot none defaults,bind 0 0 >> /etc/fstab</nowiki>}}

=== Persistent Installation on Raspberry Pi 3 ===
See [[Classic install or sys mode on Raspberry Pi]] and https://web.archive.org/web/20171125115835/https://forum.alpinelinux.org/comment/1084#comment-1084

=== Persistent Installation on Raspberry Pi 4 ===
As of 3.14, setup-alpine should ask you if you want to create a sys mode partition on your Raspberry Pi 4.

== Netboot ==

=== Netbooting Raspberry Pi 4 ===

The Raspberry Pi 4 bootloader can be configured to boot from the network [https://www.raspberrypi.com/documentation/computers/raspberry-pi.html#raspberry-pi-4-bootloader-configuration]. Configure the bootloader with at least

{{cmd|<nowiki>BOOT_ORDER=0xf142
TFTP_PREFIX=1</nowiki>}}

and optionally also {{cmd|<nowiki>TFTP_IP=x.x.x.x</nowiki>}} where <code>x.x.x.x</code> is the IP address of your TFTP server.

If not configuring <code>TFTP_IP</code> in the bootloader, you'll need to configure your DHCP server to advertise the TFTP server IP address. This varies depending on your DHCP server; use the following details if applicable:

# Vendor class: <code>PXEClient:Arch:00000:UNDI:002001</code>
# Filename: <code>/</code>

The minimal set of files that your TFTP server needs to host are:

# <code>bcm2711-rpi-4-b.dtb</code> (from [https://raw.githubusercontent.com/raspberrypi/firmware/master/boot/bcm2711-rpi-4-b.dtb raspberrypi/firmware/master/boot/bcm2711-rpi-4-b.dtb])
# <code>cmdline.txt</code> (see below)
# <code>config.txt</code> (see below)
# <code>fixup4.dat</code> (from [https://raw.githubusercontent.com/raspberrypi/firmware/master/boot/fixup4.dat raspberrypi/firmware/master/boot/fixup4.dat], alternatively <code>fixup4cd.dat</code> for the cut down version)
# <code>initramfs-rpi4</code> (from [https://dl-cdn.alpinelinux.org/alpine/edge/releases/aarch64/netboot/initramfs-rpi4 alpine/edge/releases/aarch64/netboot/initramfs-rpi4])
# <code>start4.elf</code> (from [https://raw.githubusercontent.com/raspberrypi/firmware/master/boot/start4.elf raspberrypi/firmware/master/boot/start4.elf], alternatively <code>start4cd.elf</code> for the cut down version)
# <code>vmlinuz-rpi4</code> (from [https://dl-cdn.alpinelinux.org/alpine/edge/releases/aarch64/netboot/vmlinuz-rpi4 alpine/edge/releases/aarch64/netboot/vmlinuz-rpi4])

<code>config.txt</code>:
{{cmd|<nowiki>[pi4]
kernel=vmlinuz-rpi4
initramfs initramfs-rpi4
arm_64bit=1
</nowiki>}}

<code>cmdline.txt</code>:
{{cmd|<nowiki>modules=loop,squashfs console=ttyAMA0,115200 ip=dhcp alpine_repo=http://dl-cdn.alpinelinux.org/alpine/edge/main modloop=http://dl-cdn.alpinelinux.org/alpine/edge/releases/aarch64/netboot/modloop-rpi4</nowiki>}}

Instead of using the <nowiki>http://dl-cdn.alpinelinux.org/alpine/edge/releases/aarch64/netboot/</nowiki> base URL above, pinning to a specific point in time is preferred. Raspberry Pi 4 netboot files are available from https://dl-cdn.alpinelinux.org/alpine/edge/releases/aarch64/netboot-20230329/ onward.

With the above configured the Raspberry Pi 4 should be able to boot from the network without an SD card.

== Troubleshooting ==

=== Long boot time when running headless ===

If no peripherals are connected, the system might hang for an exceptionally long period of time while it attempts to accumulate entropy.

If this is the case, simply plugging in any USB device should work around this issue, since it increases the amount of entropy available to the kernel via interrupts.

=== apk indicating 'No space left on device' ===

Note some models of the Raspberry Pi such as the 3A+ only have 512M of RAM, which on fresh Alpine deployment will only leave around 200M for tmpfs root. It's important to keep this limitation in mind when using these boards.

=== Wireless support with older Alpine images ===

If you need Wi-Fi, you'll need to [https://github.com/RPi-Distro/firmware-nonfree/tree/master/brcm download] the latest Broadcom drivers to your SD card.
(Replace /mnt/sdcard with the correct mount point.)

git clone --depth 1 https://github.com/RPi-Distro/firmware-nonfree.git
cp firmware-nonfree/brcm/* /mnt/sdcard/firmware/brcm

== See Also ==

* [[Classic install or sys mode on Raspberry Pi]] - a variant.
* [[Raspberry Pi 3 - Setting Up Bluetooth]]
* [[Raspberry Pi 3 - Configuring it as wireless access point -AP Mode]]
* [[Raspberry Pi 3 - Browser Client]]
* [[Linux Router with VPN on a Raspberry Pi]]
* [[Create a bootable SDHC from a Mac]]
* Build custom Raspberry Pi images based on Alpine via [https://github.com/tolstoyevsky/pieman Pieman]
* [[Tutorials and Howtos#Raspberry Pi]]

[[Category:Installation]]
[[Category: Raspberry]]

Docker

2023-11-29T16:27:31Z

Andrew71: Improve formatting consistency

== Installation ==

The {{Pkg|docker}} package is in the ''community'' repository. See [[Repositories]] how to add a repository.

apk add docker

Connecting to the Docker daemon through its socket requires you to add yourself to the <code>docker</code> group.

addgroup username docker

To start the Docker daemon at boot, see [[OpenRC]].

rc-update add docker default
service docker start

=== Docker rootless ===

Docker rootless allows unprivileged users to run the docker daemon and docker containers in user namespaces. This is not the same as dockremap explained in the section below. With dockremap the daemon still runs as root.

This requires the {{Pkg|docker-rootless-extras}} package (available in ''community'') and enabling <code>cgroups v2</code>:
edit <code>/etc/rc.conf</code> and set <code>rc_cgroup_mode="unified"</code>. Then start the service on boot:

rc-update add cgroups

Additionally, the <code>/etc/subuid</code> and <code>/etc/subgid</code> files need to be set up as explained in [https://docs.docker.com/engine/security/rootless/ the official documentation].

=== Docker Compose ===

{{Pkg|docker-cli-compose}} is in the ''community'' repository starting with Alpine Linux 3.15.

apk add docker-cli-compose

== Isolate containers with a user namespace ==
<pre>
adduser -SDHs /sbin/nologin dockremap
addgroup -S dockremap
echo dockremap:$(cat /etc/passwd|grep dockremap|cut -d: -f3):65536 >> /etc/subuid
echo dockremap:$(cat /etc/passwd|grep dockremap|cut -d: -f4):65536 >> /etc/subgid
</pre>

add to <code>/etc/docker/daemon.json</code>

<pre>
{
"userns-remap": "dockremap"
}
</pre>

''You may also consider these options : ''
"experimental": false,
"live-restore": true,
"ipv6": false,
"icc": false,
"no-new-privileges": false'''''

You'll find all possible configurations [https://docs.docker.com/engine/reference/commandline/dockerd/#daemon-configuration-file here].

== Example: How to install docker from Arch ==

https://wiki.archlinux.org/index.php/Docker

== "WARNING: No {swap,memory} limit support" ==

You might encounter this message when executing <code>docker info</code>.
To correct this situation, we have to enable the <code>cgroup_enable=memory swapaccount=1</code>

==== Alpine 3.8 ====
It may not have been the case before, but with Alpine 3.8, you must configure cgroups properly

{{Warning|This seems ''not'' to work with Alpine 3.9 and Docker 18.06. Follow the instructions for grub or extlinux below instead.}}

<pre>echo "cgroup /sys/fs/cgroup cgroup defaults 0 0" >> /etc/fstab</pre>
<pre>
cat >> /etc/cgconfig.conf <<EOF
mount {
cpuacct = /cgroup/cpuacct;
memory = /cgroup/memory;
devices = /cgroup/devices;
freezer = /cgroup/freezer;
net_cls = /cgroup/net_cls;
blkio = /cgroup/blkio;
cpuset = /cgroup/cpuset;
cpu = /cgroup/cpu;
}
EOF
</pre>

=== Grub ===
If you use Grub, add the cgroup condition into <code>/etc/default/grub</code>, then upgrade your grub

<pre>GRUB_CMDLINE_LINUX_DEFAULT="... cgroup_enable=memory swapaccount=1"</pre>

=== Extlinux ===
With Extlinux, you add the cgroup condition, but inside of <code>/etc/update-extlinux.conf</code>

<pre>default_kernel_opts="... cgroup_enable=memory swapaccount=1"</pre>

then update the config and reboot

<code>update-extlinux</code>

== How to use docker ==

The best documentation on using Docker and creating containers is on the [https://docs.docker.com/ official docker site]. Adding anything to it here would be redundant.

You can browse through user images on [https://hub.docker.com/ Docker Hub] and learn from the syntax in contributed dockerfiles.

Official Docker image files are denoted on the website by a special badge.

== See also ==
* [https://www.erianna.com/creating-a-alpine-linux-repository/ Creating and Hosting an Alpine Linux Package Repository for Docker Packages]
* [[Running Alpine in a Docker Container]]

[[Category:Virtualization]]

Docker

2023-11-29T15:55:31Z

Andrew71: Improve formatting a bit

== Installation ==

The {{Pkg|docker}} package is in the 'community' repository. See [[Repositories]] how to add a repository.

apk add docker

Connecting to the Docker daemon through its socket requires you to add yourself to the `docker` group.

addgroup username docker

To start the Docker daemon at boot, see [[OpenRC]].

rc-update add docker default
service docker start

=== Docker rootless ===

Docker rootless allows unprivileged users to run the docker daemon and docker containers in user namespaces. This is not the same as dockremap explained in the section below. With dockremap the daemon still runs as root.

This requires the {{Pkg|docker-rootless-extras}} package (available in <code>community</code>) and enabling <code>cgroups v2</code>:
edit /etc/rc.conf and set rc_cgroup_mode to unified. Then start the service on boot:

rc-update add cgroups

Additionally, the <code>/etc/subuid</code> and <code>/etc/subgid</code> files need to be set up as explained in [https://docs.docker.com/engine/security/rootless/ the official documentation].

=== Docker Compose ===

{{Pkg|docker-cli-compose}} is in the 'community' repository starting with Alpine Linux 3.15.

apk add docker-cli-compose

== Isolate containers with a user namespace ==
<pre>
adduser -SDHs /sbin/nologin dockremap
addgroup -S dockremap
echo dockremap:$(cat /etc/passwd|grep dockremap|cut -d: -f3):65536 >> /etc/subuid
echo dockremap:$(cat /etc/passwd|grep dockremap|cut -d: -f4):65536 >> /etc/subgid
</pre>

add to '''/etc/docker/daemon.json'''

<pre>
{
"userns-remap": "dockremap"
}
</pre>

''You may also consider these options : ''
"experimental": false,
"live-restore": true,
"ipv6": false,
"icc": false,
"no-new-privileges": false'''''

You'll find all possible configurations here[https://docs.docker.com/engine/reference/commandline/dockerd/#daemon-configuration-file].

== Example: How to install docker from Arch ==

https://wiki.archlinux.org/index.php/Docker

== "WARNING: No {swap,memory} limit support" ==

You might encounter this message when executing <code>docker info</code>.
To correct this situation, we have to enable the <code>cgroup_enable=memory swapaccount=1</code>

==== Alpine 3.8 ====
It may not have been the case before, but with Alpine 3.8, you must configure cgroups properly

{{Warning|This seems ''not'' to work with Alpine 3.9 and Docker 18.06. Follow the instructions for grub or extlinux below instead.}}

<pre>echo "cgroup /sys/fs/cgroup cgroup defaults 0 0" >> /etc/fstab</pre>
<pre>
cat >> /etc/cgconfig.conf <<EOF
mount {
cpuacct = /cgroup/cpuacct;
memory = /cgroup/memory;
devices = /cgroup/devices;
freezer = /cgroup/freezer;
net_cls = /cgroup/net_cls;
blkio = /cgroup/blkio;
cpuset = /cgroup/cpuset;
cpu = /cgroup/cpu;
}
EOF
</pre>

=== Grub ===
If you use Grub, add the cgroup condition into <code>/etc/default/grub</code>, then upgrade your grub

<pre>GRUB_CMDLINE_LINUX_DEFAULT="... cgroup_enable=memory swapaccount=1"</pre>

=== Extlinux ===
With Extlinux, you add the cgroup condition, but inside of <code>/etc/update-extlinux.conf</code>

<pre>default_kernel_opts="... cgroup_enable=memory swapaccount=1"</pre>

then update the config and reboot

<code>update-extlinux</code>

== How to use docker ==

The best documentation on using Docker and creating containers is at the [https://docs.docker.com/ official docker site]. Adding anything to it here would be redundant.

If you create an account at docker.com, you can browse through user images and learn from the syntax in contributed dockerfiles.

Official Docker image files are denoted on the website by a blue ribbon.

== See also ==
* [https://www.erianna.com/creating-a-alpine-linux-repository/ Creating and Hosting an Alpine Linux Package Repository for Docker Packages]
* [[Running Alpine in a Docker Container]]

[[Category:Virtualization]]

Create a Bootable Device

2023-11-28T18:38:09Z

Andrew71: Add note for potential issue with device file and tip for syslinux install

{{Note|These instructions are exclusively for x86_64 and x86. For ARM boards, see [[Alpine_on_ARM#Preparing_installation_media]].}}

This page is about creating directly customizable boot devices. If you are looking for instructions on creating (flashing) read-only (iso9660 "CD" filesystem) images onto installation media, see the [[Installation#Flashing_.28direct_data_writing.29_the_installation_image-file_onto_a_device_or_media|Installation]] page instead.

A directly customizable Alpine Linux boot medium is basically an Alpine system in '''[[Installation#Diskless_Mode|diskless]]''' or '''[[Installation#Data_Disk_Mode|data]]''' disk-mode installed to (and booting from) a device with a writable filesystem. It allows to also upgrade the kernel with its modules and firmware that is used to boot the system with the <code>[[Alpine_Linux_package_management#Upgrading_.22diskless.22_and_.22data.22_disk_mode_installs|update-kernel]]</code> script.

The more general local customizations, the configs (.apkovl) and the package cache, may of course also be stored on the same device, as long as the hardware is not being set to be write-locked by a hardware switch.

= Requirements =

* An Alpine Linux CD-ROM or an .iso file containing the desired Alpine release ([https://alpinelinux.org/downloads/ Download]).
* A device like an USB drive (flash, external HD, card reader, etc.) or a CF "CompactFlash", or SDcard.

= Using setup-bootable =

This is now the preferable method to create a directly customizable bootable device.

It consists an [[Installation]] of a '''diskless''' or '''data''' mode system with configs and package cache on the target device, and using the <code>[[Alpine_setup_scripts#setup-bootable|setup-bootable]]</code> script to make the device bootable.

= Manually copying Alpine files =

If you can't/won't use '''setup-bootable''', you can manually create a customizable (writable) USB boot device instead.

=== Copying ISO/tarball contents to a USB stick ===

This method is written for copying files from an Alpine ISO file but also works for Alpine tarballs (.tar.gz files) with a one line tweak (see below).

# Install some prerequisites. (If you're not currently using Alpine Linux then you probably have these installed already, otherwise you'll have to figure out how to install them.)
#: {{Cmd|apk add dosfstools apk add syslinux}}
# Set the environment variable 'mydev' to the [https://en.wikipedia.org/wiki/Device_file device file] name of the USB stick that Alpine Linux is to be installed to:
#: {{Warning | BE SURE TO GET THIS RIGHT OR ELSE YOU COULD OVERWRITE THE WRONG DISK! }}
#: {{Note|If USB stick's device name ends in a digit, you might have to replace all instances of <code>${mydev}1</code> with <code>${mydev}p1</code> below.}}
#: {{Cmd|<nowiki>mydev=/dev/sdU</nowiki>}}
# Make sure that the target drive's existing partitions, if any, are not mounted:
#: {{Cmd|umount -q $mydev?}}
# Copy and paste the following as a single command to wipe the target drive, create an MBR partition table, and create a single FAT32 partition (you can ignore any "Partition #1 contains a vfat signature." warning message):
#: {{Cmd|<nowiki>fdisk -w always $mydev <<EOF
o
n
p
1
2048
-0
t
0c
a
w
EOF</nowiki>}}
# Format the new FAT32 partition with a FAT32 filesystem:
#: {{Cmd|<nowiki>mkdosfs -F32 ${mydev}1</nowiki>}}
# Copy the [https://wiki.syslinux.org/wiki/index.php?title=Mbr syslinix executable boot code] into the bootstrap code area of the MBR boot sector (if you're not currently using Alpine Linux you may need to adjust the path to syslinux's mbr.bin file):
#: {{Cmd|<nowiki>dd bs=440 count=1 conv=notrunc if=/usr/share/syslinux/mbr.bin of=$mydev</nowiki>}}
# Install the syslinux bootloader files onto the FAT32 filesystem. (Ignore the "Hidden (2048) does not match sectors (62)" messages - modern systems use the partition table. If you are getting "no previous syslinux boot sector found" error, try adding <code>--install</code> flag):
#: {{Cmd|syslinux ${mydev}1}}
# Copy the Alpine files to the FAT32 filesystem (to copy the contents of an Alpine {{Path|.tar.gz}} tarball instead of copying {{Path|/media/cdrom}}, set <code>$alpinetarball</code> to the path to the tarball and replace the 'cp' line with: <code>tar -p -s --atime-preserve --same-owner --one-top-level=/media/$mydevname -zxvf "$alpinetarball"</code>):
#: {{Cmd|<nowiki>mydevname=$(basename $mydev)1
mkdir -p /media/$mydevname
mount -t vfat ${mydev}1 /media/$mydevname
cp -aT /media/cdrom /media/$mydevname # -T to copy hidden files
umount /media/$mydevname</nowiki>}}
# (''Optional'') Remove any .apkovl overlay files that were transferred as part of the copy process. Do this if you want an unmodified, vanilla install.
#: {{Cmd|<nowiki>mount -t vfat ${mydev}1 /media/$mydevname
rm /media/$mydevname/*.apkovl.tar.gz
umount /media/$mydevname</nowiki>}}

=== Troubleshooting ===

==== Wrong Device Name ====

If you cannot boot from the boot device and you see something like:
Mounting boot media failed.
initramfs emergency recovery shell launched. Type 'exit' to continue boot
then it is likely that the device name in {{Path|syslinux.cfg}} is wrong. You should replace the device name in this line:
append initrd=/boot/grsec.gz alpine_dev='''usbdisk''':vfat modules=loop,cramfs,sd-mod,usb-storage quiet
with the proper device name.
* For boot from USB, the device name should be 'usbdisk' (as shown above)
* For other options, you can run <code>cat /proc/partitions</code> to see the available disks (i.e. 'sda' or 'sdb')

==== Non-FAT32 Filesystems ====

===== Diskless and data mode booting =====

When the boot device is formatted with a filesystem other than those supported by default, the necessary initfs features need to be added to the modloop using <code>update-kernel</code>. See: [[Alpine_Linux_package_management#Upgrading_.22diskless.22_and_.22data.22_disk_mode_installs]]

===== Sys mode booting =====

Mount the boot device and edit the {{Path|syslinux.cfg}} file.

Then locate the "append" line, and change the <code>alpine_dev=</code> setting to match the used filesystem and add the filesystem's kernel module to the <code>modules=</code> list.

For example, change
append [...] alpine_dev=usbdisk:vfat modules=loop,cramfs,sd-mod,usb-storage quiet
to
append [...] alpine_dev=usbdisk:'''ext4''' modules=loop,cramfs,sd-mod,usb-storage''',ext4''' quiet
in the case of an ext4 formatted partition. (Or correspondingly for other filesystems, if they are supported by syslinux and the Alpine Linux kernel.)

== Finishing installation ==

After one has booted the previously created Alpine Linux bootable USB medium, one has to prepare USB stick to hold local customizations and run ''setup-alpine'' to finish the installation.

First let's find out where is our just booted USB media mounted, the location could vary.

# mount | grep /media
/dev/sdU1 on /media/sdU1 type vfat (rw,relatime,fmask=0022,dmask=0022,codepage=437,iocharset=utf8,shortname=mixed,errors=remount-ro)

Create local directory on USB media to hold local APK cache (see [[Alpine_Linux_package_management#Local_Cache|APK Local Cache]] for details).

# mount -o remount,rw /media/sdU1
# mkdir /media/sdU1/cache
# setup-apkcache /media/sdU1/cache
# ls -l /etc/apk/cache
lrwxrwxrwx 1 root root 17 Oct 19 13:16 /etc/apk/cache -> /media/sdU1/cache

Now run ''setup-alpine'' and proceed until a question about local disk selection - in ''diskless'' mode we won't use any disk (ie. our bootable media files is basically untouched) and we are going to use ''sdU1'' to hold our system customization.

# setup-alpine
...
Which disk(s) would you like to use? (or '?' for help or 'none') [none]
Enter where to store configs ('floppy', 'sdU1', 'usb' or 'none') [sdU1]:
Enter apk cache directory (or '?' or 'none') [/media/sdU1/cache]:

After the installer finished you can see how many created/modified files are detected and will be added to the backup:
# lbu status
# lbu status | wc -l
59
# lbu commit
# ls -l /media/sdU1/*apkovl.tar.gz
-rwxr-xr-x 1 root root 9591 Oct 19 15:23 /media/sdU1/foo.apkovl.tar.gz

Now all the customization are saved into the ''foo.apkovl.tar.gz'' compressed tarball on the USB stick itself.

= Troubleshooting =

=== Slow USB Devices ===
Specifying the 'waitusb=X' option at the end of the syslinux.cfg line might help with certain USB devices that take a bit longer to register. X stands for the amount of seconds kernel will wait before looking for the installation media.
append initrd=/boot/grsec.gz alpine_dev=usbdisk:vfat modules=loop,cramfs,sd-mod,usb-storage quiet '''waitusb=3'''

=== CF card readers ===

Some CF card readers have problems with the faster CF cards on the market. If you experience problems booting the CF card even after checking BIOS settings, you may need to use an older card.

Also, many CF card readers don't support DMA correctly, so you may need to add ''nodma'' to the ''append'' line of the syslinux.cfg file.

[[Category:Installation]]