ivanpollak.com

alpine linux on a hackberry pi

Thu, 14 May 2026 00:00:00 +0000

Why Alpine

I recently got into Alpine, mostly because of CI and then because of my home-labbing server. I really enjoy working and using this distribution because everything is so lightweight, even the init system.

Because it is so lightweight, it is a perfect fit for the Hackberry Pi Zero 2 W.

Configuring the SD-Card

First, an SD-Card, a Computer with an SD-Card reader and a Raspberry Pi Zero 2 W is needed. To flash Alpine on the SD-Card, I used the Raspberry Pi Imager. In there, I’ve chose Raspberry Pi Zero 2 W>Other general-purpose OS>Alpine Linux>Alpine Linux (64 Bit). Afterwards, I chose my SD-Card and flashed the OS.

If the SD-Card is now inserted, no video output will be displayed. This is because the device tree’s need to be loaded via the usercfg.txt file. This is a bit different from normal Raspberry Pi OS, because the config doesn’t happen in config.txt.

So create a file, located at Path/To/Your/SD-Card/ (NOT /boot/usercfg.txt), called usercfg.txt. Add the following contents:

# Enable DRM VC4 V3D driver
dtoverlay=vc4-kms-v3d
max_framebuffers=2

# Don't have the firmware create an initial video= setting in cmdline.txt.
# Use the kernel's default instead.
disable_fw_kms_setup=1

# Hackberry Pi
dtoverlay=vc4-kms-dpi-hyperpixel4sq

Now, insert the SD-Card into the Hackberry Pi, and boot it up. Wait until the LED on top is not blinking anymore, shut it down again and boot it up again.

Afterwards, the display should show the OpenRC boot process.

Setup

Login as root. Runt the normal setup-alpine script until the Disk & Install section. Here it displays, that No disks available and if it should try the boot media. Enter y for yes. Next, select your disk. In my case it is mmcblk0. This may vary in your setup. On the next step, I’ve chose sys. You might want to change this. The ? option is very useful for selecting the best option. Afterwards, confirm that you want to erase the disk. Enter y for yes. Afterwards reboot using reboot now. Now the Hackberry has Alpine installed, however, we again need to use another computer to configure the video output. This is documented in the Configuring the SD-Card section.

Sources

alpine linux as a server

Mon, 04 May 2026 00:00:00 +0000

This is a direct follow-up of the previous blog post. Because the whole setup (installing and configuring the server) would result in a really long blog post, I decided to split those two “chapters” into two different blog posts.

The services, that will be installed on my server are:

netbird: an european alternative to tailscale
miniflux: a minimalistic rss reader

Updating the repositories

To use all the packages, that alpine linux provides, the user needs to enable them. This can be done via manually editing /etc/apk/repositories. In here, the community repository is commented out by default. However many packages are in this community repository. To change this, just remove the # in front of the url. A adjusted config could look like this:

#/media/sda/apks
http://dl-cdn.alpinelinux.org/alpine/v3.23/main
http://dl-cdn.alpinelinux.org/alpine/v3.23/community
http://alpine.ethz.ch/alpine/v3.23/main
http://alpine.ethz.ch/alpine/v3.23/community

If everything worked correctly, btop for example, now should be installable.

Installing NetBird

NetBird is an european alternative to tailscale. Because I like sovereignty, I prefer local companies, thus NetBird will be used on my server.

Because NetBird doesn’t have a package (or rather doesnt have one that works), I had to install curl and then paste some command that they provide on their website. Please note, that this command might be outdated at the time of reading. Take this command (and every other curl | sh command) with a grain of salt.

# Install curl
doas apk add curl

# Install NetBird
curl -fsSL https://pkgs.netbird.io/install.sh | sh

After the installation was complete, to setup NetBird, just run:

netbird up

This will prompt the user to go to a website and confirm that the device should be added to the account. When this is confirmed, the device is now available in the mesh.

Installing miniflux

There is an official guide on the miniflux website, on how to setup the miniflux service on alpine. The following section will largely be similar to the instructions over there.

Install all the needed packages using:

doas apk add miniflux miniflux-openrc miniflux-doc postgresql postgresql-contrib

Start the database service:

# Launch database on startup
doas rc-update add postgresql

# Launch the database now
doas rc-service postgresql start

Setup the database:

# Switch to the postgres user
doas -su postgres

# Create the database for miniflux
createdb miniflux2

# Exit out of postgres user shell
exit

To now configure miniflux, open the /etc/miniflux.conf file. In here, we need to define the environment variables, because the miniflux service is superviced by supervise-daemon by OpenRC (instead of systemd).

To achieve the required configuration, insert the configuration below into /etc/miniflux.conf:

LOG_DATE_TIME=yes
LISTEN_ADDR=127.0.0.1:8080
DATABASE_URL=user=postgres password=secret dbname=miniflux2 sslmode=disable

# Run SQL migrations automatically:
RUN_MIGRATIONS=1

To now finalize the configuration, run:

# Create database tables, etc
doas miniflux -c /etc/miniflux.conf -migrate

# Create admin user
doas miniflux -c /etc/miniflux.conf -create-admin

Lastly, start the miniflux service using:

doas service miniflux start

installing alpine linux

Sun, 03 May 2026 00:00:00 +0000

This blog post contains information on my journey to install Alpine Linux on my homelabbing server. This “server” actually is just an old laptop, that I do not actively use anymore. Since it is powerful enough to run as a server and quite efficient while doing so, I’ve decided to repurpose it as my server.

Setting up the boot drive

The first step of all new OS installations is to obtain an image for the given operating system. For alpine, they have a downloads page with various options to choose from. Due to the fact, that I will use a laptop, I’ve decided to go with the extended option. This should include “AMD and Intel microcode updates.”

After flashing the device with dd:

sudo dd if=alpine-extended-3.23.4-x86_64.iso of=/dev/disk4

I’ve proceeded to the installing section of alpine’s User Handbook. There I found out, that the setup-alpine script, which is used for easily installing alpine linux on a system, does not setup WiFi connections by itself.

Since I will use WiFi as the main way to communicate with my server, this ment that I would need to configure networking manually.

Issues with WiFI

Sadly, setting up WiFi wasn’t as easy as I thought. Because alpine is a pretty minimalistic distribution, the driver for my network device (Intel(R) Wi-Fi 6E AX211 160MHz) was missing. This was probably due to the fact that apk info (alpine’s way to list all installed packages) did not show any linux-firmware-intel.

So after searching an ethernet cable and doing the same for a free ethernet port, I was finally able to run setup-alpine -q to start using alpine. This allowed me to ping an external website for the first time. After running the -q (quick) version of the setup-alpine command, and testing the connection, the real installation began.

Installing alpine

Alpine linux has a pretty handy script, called setup-alpine this will guide the user through the installation process, asking him various questions on how the system should be installed. This includes; setting the keyboard layout, changing the hostname, setup the primary (wired) interface, use dhcp or not and various other things. All of those are described in the user handbook.

Most values, I’ve left to their defaults. If I did not understand the options, entering the ? instead of any option, outputted a very detailed and easy to understand description of what option does what. What I think is notable, is that you even can select between different implementations (for example you can choose between openssh and other ssh servers, if you want). Also, the help menu will describe when to use what. For example; if the user is not sure, how to use the disk, the help menu describes what option is better for what purpose. sys is best for development boxes, desktops and virtual servers, crypt is the same as sys but with encription, etc.

Because only I have physical access to this system, it was save for me, to choose the sys option.

After the installation was finished, I was prompted to reboot the system. I’ve done what the computer told me and look at that, alpine is now installed.

Setting up WiFi

After the installation worked as it should, it was now time to make it possible to use the computer without an ethernet connection. I’ve apk add-ed the previously mentioned linux-firmware-intel and finally ip addr showed my wlan0.

Actually, I think, that the setup-alpine script already installed the linux-firmware-intel package alongside with some other common linux-firmware-* packages.

Alpine supports both wpa_supplicant and iwd, however the wiki entry for wifi uses wpa_supplicant, thus I proceeded to use this tool instead of iwd.

To add my network, I used the following command:

# Enter root shell
doas su

# Generate the config and put it into the correct file
wpa_passphrase 'ExampleWifiSSID' 'ExampleWifiPassword' > /etc/wpa_supplicant/wpa_supplicant.conf

After this, I was able to test my wifi connection using:

wpa_supplicant -i wlan0 -c /etc/wpa_supplicant/wpa_supplicant.conf

-i, I assume, is for interface and -c for config file.

After testing, wpa_supplicant was put into the background (daemon) using -B. Also I setup dhcp, using udhcpc:

# Daemonize the command above
wpa_supplicant -B -i wlan0 -c /etc/wpa_supplicant/wpa_supplicant.conf

# Obtain a dhcp lease
udhcpc -i wlan0

To check, if the dchp stuff worked correctly:

ip addr show wlan0

This should now output an ip address next to the inet field.

Configuring the gateway for my wlan0 interface was pretty straight-forward. Since I will use a dhcp, I did not need to set and gateway, static ip or a subnet mask. I could just open /etc/network/interfaces and basically copy the eth0 configuration. My final file looks like this:

auto lo
iface lo inet loopback

auto eth0
iface eth0 inet dhcp

auto wlan0
iface wlan0 inet dhcp

To now apply the configuration, first bring the interface down and then restart the networking service. Lastly bring the interface back up again:

# Bring interface down
ip link set wlan0 down

# Restart networking
rc-service networking --quiet restart &

# Bring interface up again
ip link set wlan0 up

After all of this, I finally was able to ping ivanpollak.com. This ment, that my laptop was finally ready for server usage.

Setting up an SSH server

SSH changed my life

Because this is a server, it should probably have SSH. Also, I do not want to sit in front of this computer, each time I need to administrate something.

For the implementation, I chose OpenSSH, mainly because i already knew it. Also the wiki entry used it.

Installing OpenSSH was pretty straight-forward:

doas apk add openssh

This installed the sshd service, as well as a default configuratoin in /etc/ssh/sshd_config. In the latter file, I adjusted the settings to my prefered ones (mainly setting PermitRootMode no to disable root login).

Also, because I want to disable password login altogether, I quickly needed to start the sshd-service with allowing passwords (to then copy over my ssh public key to the server).

rc-service sshd start

On my client, I now ran:

ssh-copy-id user@hostname

I quickly verified, that my passwordless login worked via ssh user@hostname. This worked and this ment, that I could throw my server into a corner in my room.

Next, I edited the /etc/ssh/sshd_config again, to not allow any logins by just using the password. This was done via the PasswordAuthentication no option.

All that was left, was to restart the service and add the service to rc-update (launch the service at boot):

doas rc-service sshd restart
rc-update add sshd

Lid-close behaviour

A standard alpine linux installation uses a basic acpid implementation. By default, there is nothing configured and thus, nothing will happen when the lid of the laptop is closed. If this is wanted, /etc/acpi.map can be created and edited. This however is out of the scope of this blog entry.

Reflecting

The process of installing alpine linux on a laptop to use as a server, might not be as easy as other operating systems. It requires a background in linux technologies and a basic understanding of errors in linux. With that said, the alpine linux wiki is very extensive and easy to read. It covers almost every question that an user might have during setup. This makes it, if you have some linux knowledge, pretty okay to install, especially if you’re used to read through wiki entries.

foochr

Sat, 02 May 2026 00:00:00 +0000

What is foochr?

From the project’s README:

foochr is a text-based user interface (TUI) program to help keep track of commands with flags, other TUI’s and even allows for a bit of scripting.

It is basically just a fancier way for bash aliases. Instead of having an alias for cha -MV or for bluetui, the user can just write those down, giving the commands a name and then launch foochr to get a list of all those commands

My initial idea for this project came a while back, when I started using cli’s and tui’s more and more. My issue back then was, that i kept forgetting the names of especially those programs, that i did not use that often. For examle impala and bluetui.

Also I wanted to learn ncurses, as well as c. This is because i had another project that i wanted to code, that was larger and much more complicated than this. I thought, that this could be an easy introduction to those two components.

Getting started

My first version was quickly written, thanks to the very useful guide for ncurses over at the tldp website. However, one might notice, that all of the applications were hard-coded inside of the binary, thus making adjustments to this “configuration” very painfully.

Because I did not have much knowledge about how to parse a config file, I asked my chatbot of choice, that he should create me such a feature. This has worked pretty well, however I wasnt really happy that I needed help from an ai for such a simple task.

I generally think that AI is not sustainable and that this technology should not be used. Thus, my decision was made, to rewrite this piece of software.

Writing my first config parser

About a week ago, I started coding this new version, fully free of AI-slop. Because parsing the config would be one of the first things that will be done in the application, I also started with this step. It is actually not quite as difficult as I thought. Reading the first line can be done pretty easily, as well as getting an absolute path to the .config directory via getenv().

I noticed my lacking knowledge of the c standard library very quickly. I didn’t know that there was a function to “tokenize” a given input, etc. This however did not prevent me from implementing the parser. (acutally even without the strtok() function)

Okay now to the technicalities. A config file for foochr can look like this:

chawan=cha -MV
system monitor=btop
wifi=impala

For parsing the config, I mostly used the fgetch() function, which reads the next character in a given stream and returns it. With this, it is possible to just loop over the file and based on the character that gets returned, do something differently. In my case, this looks something like this:

First there is a struct, where the config entries get stored.

// This struct stores the key and the value for a given entry.
struct KeyValue
{
  char key[127];    // This stores the value that will be shown in the tui
  char value[127];  // This stores the command that will be run
}

Next, some values that later will be used get initialized. config_values[] is an array of the struct above. In this example, the maximum amount that a configuration can have, is 15 lines. In the actual program, this memory will be allocated and has not a fixed value. config_index is the current position in the config_values[] array. This will be useful to determine, where the next character should be inserted into. is_value stores if the next characters should be inserted into the key[] array or the value[] array.

struct KeyValue config_values[15];
config_index = 0;
bool is_value = false;

And lastly, there is a while block, that does multiple things. It checks if the current character is a \n. If so, the config_index should be incremented. This is because in the config file, each new-line indicates a new command that should be displayed in the ui/executed using foochr.

If the current character is a =, the boolean is_value is switched, thus allowing the next characters to flow into the value instead of the key.

while (true)
{
  character = fgetch(fp);
  if (character == '\n')
  {
    is_value = != is_value;
    config_index++;
    continue;
  }
  if (character == '=')
  {
    is_value != is_value;
  }
  if (is_value == true)
  {
    strcat(
      config_values[config_index].value,
      (char*)&character
    )
  }
  else
  {
    strcat(
      config_values[config_index].key,
      (char*)&character
    )
  }
}

All of this above is just a very simple example. This is not how the code actually looks like. To see, what the code looks like; you can find it here.

Whats left?

The config-file parsing was the main part, that I did not know how to implement. With that out of the way, all that was left, were the ncurses things, which I already knew from the first version of foochr and some Makefile shenanigans for allowing the program to be packaged.

Reflecting

To be honest, not using AI in the whole process, from start to end, made me realize, how useless AI actually is. If you know the general concepts of programming and know how to search if you have an issue, you’re probably better off without any LLM’s.

Also some people say, that with LLM’s you actually write the same code but faster. I do not think that this is true. Almost everybody I know, that uses AI either spends half the time waiting for the prompt to be processed or to be mad at the chatbot because it did not write the code that they wanted. This is especially true with low-level programming, but applies to general programming as well.

So; don’t forget that just because some huge tech companies tell everybody how their product will replace you, that this statement is actually true. They most likey (as with almost all other companies) just want you to spend money.

Have a great day!