As an alternative to Spotify, I recently started using using Navidrome. For recommendations, I also started scrobbling to Listenbrainz.

I thought it would be cool to embed a little widget onto my website to show what I was listening to, but I couldn’t find a Listenbrainz widget anywhere in the wild, so I built one myself.

How it works

The widget reaches out to the Listenbrainz API to see what I’m listening to (or what I last listened to) and displays it with a link that takes you to my Listenbrainz profile.

Here’s what it looks like (you can also see it on the homepage):

It’s Jekyll ready

Because I’m using Jekyll to build my site, I built it as an Include, but it should be fairly easy to adapt it for use elsewhere.

You can find the source for it on the Github repo that builds this site:

• HTML: now_playing.html
• JavaScript: now_playing.js

I’ve been keeping a portable hard drive (HDD) at someone else’s house as an off-site, emergency backup. I had an Orange Pi Zero 3 handy and wanted to see if I could rig something up to access the drive remotely.

With this set up, I have a drive that:

• lives off-site,
• can be accessed remotely,
• decrypts itself on boot,
• and can be accessed over Tailscale.

Important note: as a friend pointed out, this is really a “key hidden under the mat” kind of security. The goal is really just to make it so someone can’t just unplug the drive, plug it into another computer, and see everything on it.

If you want to make sure your files are completely protected against prying eyes, make sure to encrypt them before putting them on the drive.

Create the encrypted drive

In order to keep the content on the disk secure, the first thing you need is an HDD encrypted with LUKS. My favorite way to do that is to use the Gnome disks application to format the drive.

I used these settings for my drive:

• Volume Name: zero3backup
• Type: Internal disk for use with Linux systems only (Ext4)
  • Password protect volume (LUKS)

Install cryptsetup

On an Orange Pi Zero 3 running armbian (based on debian 12 at the time of writing), you can install cryptsetup with this command:

sudo apt install cryptsetup

cryptsetup is a command-line utility for managing disk encryption.

Create and use a keyfile

In order to unlock the drive without entering the passphrase whenever the computer reboots, you can create a keyfile to unlock the encrypted partition.

Here’s how to do that:

1. Create a keyfile

To create a keyfile, you can use dd to generate a random file. This file will serve as the key that automatically unlocks the encrypted volume.

sudo dd if=/dev/random of=/root/my_keyfile bs=1024 count=4 sudo chmod 0400 /root/my_keyfile

• /dev/random is used to generate random data.
• The bs=1024 count=4 parameters define the size of the keyfile (in this case, 4 KB).
• The chmod 0400 command ensures that only root can read the keyfile, making it more secure.

2. Add the keyfile to the LUKS partition

Next, you need to add the keyfile to the LUKS partition. Run the following command to add the keyfile to the LUKS header:

sudo cryptsetup luksAddKey /dev/sda1 /root/my_keyfile

You will be prompted to enter the current passphrase for the LUKS volume (the password you set during encryption). Once you enter it, the keyfile will be added to the partition, allowing it to be used for unlocking the drive.

3. Update /etc/crypttab to use the keyfile

Now that the keyfile is created and associated with your LUKS partition, you need to modify /etc/crypttab to use the keyfile to unlock the encrypted volume automatically during boot.

Edit /etc/crypttab:

sudo nano /etc/crypttab

Add the following entry:

zero3backup /dev/sda1 /root/my_keyfile luks # Replace "zero3backup" with your volume name

This tells the system to use the keyfile /root/my_keyfile to unlock /dev/sda1 during boot.

4. Update the initramfs

Once you’ve edited /etc/crypttab, update the initramfs to apply the changes:

sudo update-initramfs -u

5. Configure /etc/fstab

If you want the decrypted partition (/dev/mapper/zero3backup) to automatically mount at boot, you’ll need to add it to /etc/fstab. This step is necessary to define the mount point.

First, create the mount point:

sudo mkdir -p /mnt/zero3backup # Replace "/mnt/zero3backup" with whatever you want your mount point to be

Then, edit the /etc/fstab file:

sudo nano /etc/fstab

Add a line to mount the decrypted device:

/dev/mapper/zero3backup /mnt/zero3backup ext4 defaults 0 2

6. Reboot and test

Now, when you reboot, the system will automatically unlock the drive using the keyfile and mount it if you’ve configured it in /etc/fstab.

Home, sweet home

I’ve wanted to create a homepage for myself for a while now, especially after buying jasoncrevier.com – but I was never quite sure what it should be for.

Should it be a blog? Should it just link to other sites I use? Should it be a resume?

Where I really saw a need was when I noticed that I was constantly going back to find old videos or articles to remind myself of a linux command or a process. I noticed that often these would be links to people’s personal blog where they had written down the process to refer to themselves, which then became useful to other people.

I started doing the same in Obsidian (a really sleek, markdown-driven note-taking app). For example, having it open while I set up a new system, and writing down all the steps and commands I used.

I wanted to share some of these notes with the world, and it occurred to me that if I could find a way to write up my content in Obsidian, and then use a few commands to publish it to the web, then boom, there’s my personal homepage.

So I set out looking for a way to do it.

Static sites are alright

Markdown is designed to convert nicely into HTML. So it stood to reason that someone must have tackled this idea of drafting everything in markdown and then automagically converting it into a website.

The answer came in the form of static site generation. That is, a site driven by plain HTML, CSS, and some light JS. You create the content, publish it, and it stays as is until you publish it again. That means it’s simple, lightweight, and blazingly fast.

The most popular static site generators I could find were:

• Hugo
• Jekyll
• Pico CMS
• Gatsby

I played around with a few, and landed on Jekyll. I found a theme, added a little flavour, and here we are! I’m tempted to get a little more into the technical side here, but I think I’ll save it for a future post.

See you around

I’ll start populating this feed with mainly notes about my adventures in Linux and self-hosting, but also anything else that comes to mind. Come back later to see it all.