A short while back at IoT World, we introduced a neat little bundle of kit to demonstrate Ubuntu Snappy. This kit consisted of a Raspberry Pi 2 (the updated Pi that Ubuntu can run on), a PiGlow and really sharp Pibow case, both provided by Pimoroni. Needless to say, it was a real hit.
An offer came up to get my hands on one of these great, specially made Ubuntu branded versions of the kit and I had to jump on that, because it just looks so darned cool. Happy coincidence, I was already planning on obtaining a Pi 2 to replace my older RPi that I had toyed with off and on over the last couple years.
Today, my new Ubuntu Snappy Core Raspberry Pi Fun Pack arrived and I had to just stop working and start playing a bit, because, “Hey, new toys!”
So this first post will be an introduction and first steps.
First, the hardware. I won’t go into detail on the Raspberry Pi 2 hardware itself. By now, it’s well known, and it’s well discussed and documented elsewhere to the point where I have nothing Earth shattering to add to that discussion. You can see some basic information at RaspberryPi.org or search the Goog.
I will point out the two add-on’s though. First the Pibow case is a plastic case specially made for the Pi 2 and B+ systems. It consists of two clear panels with several layers of custom designed frames in between. They sell different configs that range from skeleton cases to full box. For us, they created one in Ubuntu Orange and laser engraved the Ubuntu logo and Circle of Friends on the top cover. It looks pretty sharp.
The PiGlow is another neat addition. It plugs into the pin array on the Pi2 and provides a programmable LED light show. There are ample instructions for making them flash and I’ll get to a brief demo in another post, perhaps. The PiGlow is easily programmable with python, and they provide instructions for installing the necessary libraries to interface with the PiGlow via a Python script. This means it should be quite easy to add a colorful, animated status marker to any python script by adding a few lines of code. There is video of the PiGlow as well on the Pimoroni site, so enjoy!
Now let’s talk about the OS. Because of the upgraded ARM Cortex-V7 chip, the Pi 2 can finally run Ubuntu. Previous incarnations of the RPi used an older ARM v6 chip that Ubuntu was not ported for (though you could get various Debian versions to run on that chip). In April 2015, we launched Ubuntu 15.04 (Vivid Vervet) and with it came Ubuntu Snappy. Snappy is a new transactional version of the OS formerly known as Ubuntu Core, thus, Ubuntu Snappy Core. The key difference is that with Snappy, we no longer use apt to manage package installations. Instead, packages come in Snaps, which are transactional packages that we first developed for the Ubuntu Phone. If you’ve never heard of Transactional packages, that’s ok, because you’ve more than likely used them any time you install or update an application on your smartphone.
In a brief nutshell, Transactional Packages are an All-or-Nothing installation that consists of bits of unmodifiable code as well as user-modifiable code. The unmodifiable parts are the core elements of the application, the UI, the libraries, the binary executables, and so forth. The user-modifiable parts are things like custom user configurations, downloaded or added data like documents, photos, icons, and other similar things. When you upgrade an app, you essentially completely replace the unmodifiable bits with the newer version of those bits, unlike traditional package updates that may only update a single library file or binary executable. One of the two biggest benefits to this are that you never have to worry about update creep, where update after update after update could, possibly, cause things to break as they leave behind old, conflicting or unneeded files. The other is that if an update breaks, you can very easily roll back to the last working version. So, for example, if you have Candy Crush version 1.2.3 installed and install 1.2.5 and discover that 1.2.5 is actually broken and you can no longer play Candy Crush, you could simply roll right back to version 1.2.3 and continue on crushing those candies. And neither the update nor the rollback has touched your user-modifiable data (your records, progress and such in this case).
So the first thing I wanted to do was get this sucker on my network. My network, however, is very tightly controlled at home. All IP addresses are handed out by DHCP, on an assigned basis, so if your device’s MAC address isn’t specifically listed in dhcp.conf on my server, you won’t get an address. And for wireless devices, even connecting to the access point is MAC controlled, so if your phone, tablet or laptop is not on the ACL on the WiFi access point, you can’t even join the network to ask for an IP address. Sure, it’s not 100% secure, but nothing ever is, and this is “Secure Enough” for my needs and location.
Now, for my first idea, I wanted to replace my home DNS/DHCP server with a small IoT type device like a Raspberry Pi. I currently use a hacked together Shuttle PC for this purpose, with a giant external 400W power supply that was made necessary because the small Shuttle PSUs are notoriously flaky, and mine didn’t last three months before it started shutting itself off randomly trying to keep up with the power needs of the CPU on the machine. So that’s a lot of energy being used for a system that essentially does nothing but hand out DHCP requests and answer DNS queries. Transit also serves as a bastion point so I can access my LAN remotely so I will try to set this up to do likewise.
First, however, I need the Snappy Pi to have a static IP address. By default, it comes configured for dynamic addressing for it’s onboard ethernet device. So I needed to modify /etc/network/interfaces.d/eth0
To change the file, a couple things had to happen. First, I needed to be the root user. Sudo may have worked, but it’s just as easy to become root to do a lot of things. So sudo -i to become root.
Now, we just need to edit the file. There is a problem though. The root filesystem is mounted read-only by default. This is great for security, but when you need to edit core files, it makes things a bit difficult. So, you need to remount the root filesystem read-write so you can edit the core files that are not already designed to be user-writable (learn about the Snappy Core filesystem). This is simply accomplished like so:
root@localhost:/etc/network/interfaces.d# mount -o remount,rw /
after this, you should be able to edit the eth0 file to use a static addressI edited the file to add the address, netmask, broadcast and gateway lines and saved the eth0 file. Then, I shut the interface down and brought it back up and I was in business. I also took a moment to verify that it all worked by rebooting the RPi. This highlights a couple things:
- On reboot, the root filesystem is again mounted read-only, so if you need to modify more core files, you will need to remount the filesystem once more.
- allow-hotplug is an interesting thing. It’s intention is to only bring the device up on hotplug events. However, because the ethernet device is always plugged in, on reboot, the kernel detects a hotplug event and brings the device up at boot time, regardless. That means, if you don’t have it plugged in to a switch and turn it on, you could wait a bit while it tries to obtain a dhcp address. I noted that after rebooting the RPi with the ethernet cable removed, the eth0 device was still shown as up with the prescribed IP address.
One thing I forgot to mention was that because I’m not using DHCP, I also need to list some nameservers. Eventually, this file will list itself as it will be running Bind9, but for now, I’m going to give it Google’s public DNS addresses by creating a file called “tail” in /etc/resolvconf/resolv.conf.d that looks simply like this:
ubuntu@localhost:~$ cat /etc/resolvconf/resolv.conf.d/tail nameserver 126.96.36.199 nameserver 188.8.131.52
Now that I’m rebooted and have an IP address, lets take a brief whirlwind tour of Snappy before I end this prologue to my Snappy Adventure.
As I mentioned before, Snappy doesn’t use apt to manage packages, it uses a new tool called, not surprisingly, “snappy”. So first, lets get just a bit of information about my system
ubuntu@localhost:~$ snappy info release: ubuntu-core/devel frameworks: webdm apps:
So there you have it… there is much more available at https://developer.ubuntu.com/en/snappy/tutorials/ about snappy and its use.