Alpine Linux - User contributions [en]

UniFi Controller

2020-11-01T16:22:16Z

Crusa: missing option for adduser command

{{TOC right}}

= Introduction =

This guide explains how to install the generic Unix UniFi Controller, as available from [http://www.ubnt.com/ Ubiquity Networks]. At the time of writing this, a native Alpine Linux package is not available.

Furthermore, this guide uses the incredibly reliable and efficient [http://www.skarnet.org/software/s6/ s6] supervision suite to start and control the UniFi Controller.

A summarised schematic of what will be installed on the filesystem.

The choice of <code>/srv</code> for the UniFi Controller's root directory is based on the fact that it contains both run-time and configuration data, so installing to <code>/usr/local</code>, <code>/opt</code> or <code>/home</code> didn't seem apt. Feel free to adjust the steps below, replacing <code>/srv/unifi</code> with wherever you would prefer to install the UniFi Controller software.

<pre>
/
`--etc
|-- unifi
| `-- log
|-- srv
| `-- unifi
| |-- bin
| |-- conf
| |-- data
| |-- dl
| |-- lib
| |-- logs
| |-- run
| `-- webapps
|-- run
| `-- openrc
| `-- s6-scan
| `-- unifi --> /etc/unifi
`-- var
`-- log
`-- unifi
</pre>

= Prerequisite Packages =

== OpenJDK 8 JRE ==

Install <code>openjdk8-jre</code> from the community repository.

Edit <code>/etc/apk/respositories</code> and uncomment the appropriate community repository for your Alpine version:

<code>http://host.name/alpine_version/community</code>

Update the package cache.

<code>apk update</code>

Install the package.

<code>apk add openjdk8-jre</code>

== MongoDB ==

Install MongoDB

<code>apk add mongodb</code>

== s6 ==

Install [http://www.skarnet.org/software/s6/ s6]

<code>apk add s6</code> which is a service supervision suite, for reliably and efficiently starting, stopping and keeping services running.

The below shows a schematic process tree of how the UniFi Controller will be started and supervised by s6. The controller is written in Java, hence the Java process and it in turn, launches a dedicated instance of MongoDB to store its configuration and run-time data.

<pre>
init
`-- s6-svscan
`-- s6-supervise
|-- s6-log
`-- java
`-- mongod
</pre>

= Install UniFi Controller =

Create the <code>unifi</code> user and group.

<code>adduser -D -H -h /srv/unifi unifi</code>

Change to the parent folder within which you wish to install the UniFi Controller.

<code>cd /srv</code>

Download the generic unix archive of the <code>VERSION</code> you wish to install.

<code>wget http://www.ubnt.com/downloads/unifi/VERSION/UniFi.unix.zip</code>

Unpack the archive.

<code>unzip UniFi.unix.zip</code>

Rename the unpacked directory.

<code>mv UniFi unifi</code>

Change ownership.

<code>chown -R unifi:unifi unifi</code>

Lock down permissions.

<code>chmod o-rwx unifi</code>

Change into the UniFi bin directory.

<code>cd /srv/unifi/bin</code>

Remove the existing file.

<code>rm mongod</code>

Create a symlink to <code>/usr/bin/mongod</code>

<code>ln -s /usr/bin/mongod</code>

= Configure Service Management =

== Create UniFi Service Directory and Files ==

Create an s6 service directory for UniFi.

<code>mkdir -p /etc/unifi/log</code>

Add the <code>run</code> script, using your favourite editor.

<code>vim /etc/unifi/run</code>

Copy and paste the following into it.

<pre>
#!/bin/ash

user='unifi'
group='unifi'

exec 2>&1

base='/srv/unifi'

if [ -d $base ]; then
cd $base
chown -R $user:$group .
version=`head -1 webapps/ROOT/app-unifi/.version`
echo "Starting UniFi Controller $version"
exec s6-setuidgid $user java -jar lib/ace.jar start
else
echo "Missing $base ... aborting"
touch down
fi
</pre>

Ensure that the <code>run</code> script is executable:

<code>chmod 755 /etc/unifi/run</code>

Add the <code>log/run</code> script, using your favourite editor.

<code>vim /etc/unifi/log/run</code>

Copy and paste the following into it.

<pre>
#!/bin/ash

log_user='log'

exec s6-setuidgid $log_user s6-log -b n20 s1000000 t /var/log/unifi
</pre>

Ensure that the log/run script is executable:

<code>chmod 755 /etc/unifi/run</code>

== Create log User and Directory ==

Create the <code>log</code> user and group.

<code>adduser -D -H -h /var/log log</code>

Create the <code>/var/log/unifi</code> directory

<code>mkdir -p /var/log/unifi</code>

Update the directory ownership.

<code>chown log:log /var/log/unifi</code>

Lock down the permissions.

<code>chmod 750 /var/log/unifi</code>

== Create the OpenRC Service Script ==

Open the script file using your favourite editor.

<code>vim /etc/init.d/unifi</code>

Paste the following into it.

<pre>
#!/sbin/openrc-run

name="unifi"
supervisor=s6
s6_service_path="${RC_SVCDIR}/s6-scan/${name}"

depend() {
need net s6-svscan
after firewall
}

start_pre() {
if [ ! -L "${RC_SVCDIR}/s6-scan/${name}" ]; then
ln -s "/etc/${name}" "${RC_SVCDIR}/s6-scan/${name}"
fi
}
</pre>

Ensure that the script is executable.

<code>chmod 755 /etc/init.d/unifi</code>

== Start the UniFi Controller Service ==

<code>rc-service unifi start</code>

== Configure the UniFi Controller Service to start on boot ==

<code>rc-update add unifi boot</code>

= Simple Backup Script =

Create <code>/usr/local/bin/unifi-backup</code> using your favourite editor.

'''Note:''' This script assumes the use of s6-svc to control unifi. I will modify it in time, to use rc-service instead.

Paste the following into the file.

<pre>
#!/bin/ash

conf_dir='/etc/unifi'
backup_dir='/srv/backup/unifi'
service_dir='/run/openrc/s6-scan/unifi'

start_state='down'

if s6-svok $service_dir; then
if s6-svstat -o up,ready $service_dir | grep -q true; then
echo 'Stopping the UniFi Controller'
start_state='up'
s6-svc -d $service_dir
sleep 3
fi
else
echo 'Warning: The UniFi Controller is not supervised'
exit 1
fi

if s6-svstat -o up $service_dir | grep -q false; then
echo 'Success: The UniFi Controller was stopped'
else
echo 'Error: The UniFi Controller is still running'
exit 1
fi

stamp=`date +%Y-%m-%d_%H%M%S`

mkdir -p $backup_dir
cd $backup_dir
mkdir "data-$stamp"

echo "Backing up to /srv/backup/unifi/data-$stamp.tar.gz"

if rsync -az /srv/unifi/data/ "data-$stamp"; then
echo '* rsync succeeded'
if tar czf "data-$stamp.tar.gz" "data-$stamp"; then
echo '* tar succeeded'
rm -rf "data-$stamp"
echo 'Backup succeeded'
else
echo 'Backup failed: tar failed'
exit 1
fi
fi

if [ "$start_state" == 'up' ]; then
echo 'Starting the UniFi Controller'
s6-svc -u $service_dir
sleep 5
s6-svstat $service_dir
fi
</pre>

[[category:Networking]]

Raspberry Pi

2019-09-25T09:48:27Z

Crusa:

{{TOC right}}

This tutorial will help you install Alpine Linux on your Raspberry Pi.

== Preparation ==

This section will help you format and partition your SD card:

# [http://alpinelinux.org/downloads/ Download] Alpine for Raspberry Pi tarball for the '''armhf architecture''' which is named as <code>alpine-rpi-<version>-armhf.tar.gz</code>. You will need version 3.2.0 or greater if you have a Raspberry Pi 2.
# Mount your SD card to your workstation
# Use [https://en.wikipedia.org/wiki/GNOME_Disks gnome-disks] or [http://linux.die.net/man/8/fdisk fdisk] to create a FAT32 partition. If you are using fdisk, the FAT32 partition type is called ''W95 FAT32 (LBA)'' and its ID is 0x0C.
# Mark the newly created partition as bootable and save
# If you used fdisk to create the partition you need to create a filesystem on it with mkdosfs -F 32 /dev/sdX1
# Mount the previously created partition
# Extract the tarball contents to your FAT32 partition
# Unmount the SD Card.

Note: 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, and is compatible with Raspberry Pi 3 and Compute Module 3.

=== Wifi support ===
If you need wifi to work, perform the following before unmounting the SD card:
# [https://github.com/RPi-Distro/firmware-nonfree/tree/master/brcm Download] the latest broadcom drivers for the Raspberry Pi to your machine and
# Copy them to [SD card]/firmware/brcm/.
<code>
git clone --depth 1 https://github.com/RPi-Distro/firmware-nonfree.git
</code>

<code>
cp firmware-nonfree/brcm/* [SD card]/firmware/brcm
</code>

== Installation ==

Optionally create a "usercfg.txt" file on your SD card to configure low-level system settings. Specifications can be found [https://www.raspberrypi.org/documentation/configuration/config-txt here]. Some interesting values include:
* Enable audio: dtparam=audio=on
* If you see black edges around your screen: disable_overscan=1

Alpine Linux will be installed as [[Installation#Installation_Handbook|diskless mode]], hence you need to use [[Alpine local backup|Alpine Local Backup (lbu)]] to save your modifications between reboots. Follow these steps to install Alpine Linux:

# Insert the SD Card into the Raspberry Pi and turn 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 ===

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

{{cmd|apk update
apk upgrade}}

Don't forget to save the changes:

{{cmd|lbu commit -d}}

=== 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 and therefore 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 Raspberry Pi does not have a clock, the 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 that you a
NTP daemon installed and running. If you are not sure, then you can install NTP client by running the following
command:

{{cmd|setup-ntp}}

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 that 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 on boot.
# Run it manually with <code>/etc/init.d/wpa_supplicant start</code>.

=== X11 Setup ===
Here are what you need if you want to try and run a single X11 application like a browser kiosk or maybe even a desktop: {{cmd|setup-xorg-base
apk add xf86-video-fbdev xf86-video-vesa xf86-input-mouse xf86-input-keyboard dbus setxkbmap kbd
rc-update add dbus}}

Install XFCE:
{{cmd|apk add xfce4}}

Commit your changes:
{{cmd|lbu_commit -d}}

{{cmd|startx}}

=== Enable OpenGL (RPi 3) ===

Remount the boot partition writeable (ie. /media/mmcblk0p1):

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

Add the following lines to /media/mmcblk0p1/config.txt

dtoverlay=vc4-kms-v3d
gpu_mem=128

256MB gpu_mem is also possible

Install mesa-dri-vc4:
{{cmd|apk add mesa-dri-vc4}}

Reboot:

{{cmd|lbu_commit -d; reboot}}

== Persistent storage ==

=== Loopback image with overlayfs ===

The install is in disk-less mode and forces everything into memory, if you want additional storage we need to create loop-back storage onto the SD 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 doing /usr here, but you can do /home or anything else:

{{cmd|mkdir /media/persist/usr
mkdir /media/persist/.work
echo "overlay /usr overlay lowerdir=/usr,upperdir=/media/persist/usr,workdir=/media/persist/.work 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 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 and not to the persist storage.

If you do want to install something small at boot you can use `apk add` and `lbu commit -d`.

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

=== Traditional disk-based (sys) installation ===

{{Warning|This isn't yet supported by the Alpine setup scripts for Raspberry Pi. It requires manual intervention, and might break.}}

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 these: the Raspberry Pi doesn't need this to boot anyway.

{{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 on shutdown.

Beware, though, that <b>the contents of /boot will be ignored when the Pi boots</b>: 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 so that manually copy the files to boot partition is not needed.

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

=== Persistent Installation on RPi3 ===

See this page : https://wiki.alpinelinux.org/wiki/Classic_install_or_sys_mode_on_Raspberry_Pi

See https://web.archive.org/web/20171125115835/https://forum.alpinelinux.org/comment/1084#comment-1084

== 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]]
* [[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]

[[Category:Installation]]
[[category:ARM]]