Holoseat

Just a couple of new developments on this thread. First, Docker is officially supported on CHIP/CHIP Pro. Second, Bryan has some concerns about using Docker with the available storage on CHIP Pro, which bears research and testing.

Third, not only is Docker supported, there are Next Thing demos of using Docker on Chip Pro. They call this approach CHIP-tainer. Here are three examples from their github repo.

• VU Meter
• Python IO
• Alpine

I think the next step is to get a CHIP Pro set up with Docker, run one or two of these demos, and then look at metrics (e.g. available disk space, processor load, memory). After that, it will be time to start trying to make our own Docker images.

This work is now part of 2017 Sprint 2 (DEV-23: Test Nodejs then Johnny-Five in chiptainer enviroment to determine if we want to use chiptainer approach). Based on notes above, I am planning to test out VU Meter demo provided by Next Thing. A couple of quick notes before I start my work. This demo requires the CHIP Pro Dev Kit. The current OS install on my CHIP Pro Dev Kit is the Blinkenlights image (this is an example build-root image that blinks all of the LEDs). I have checked, and it does not have Docker pre-installed and the standard Docker install commands do not work in this environment. Contrast this with this message from Bryan that Docker is included when we make our own copy of build-root. A little more digging by Bryan shows us that his CHIP Pro is running Docker 1.12.2.

My plan is to install the Debian image on my CHIP Pro and then try to follow these instructions to install Docker on CHIP. I am hoping this test will provide an answer to the forum post Is Chip Pro Docker ready?.

One final note. I noticed problems flashing my CHIP Pro from Windows 7, but on the other hand serial access from OS X is painful. So, my plan is to flash the OS from my Mac and then switch to my Win 7 box to login over serial to set up wifi.

CHIPtainer Example: VU Meter Test

1. Initial setup
   1. Flash Chip Pro Dev Kit with "Pro" image (Debian install) from Mac per dev kit instructions
   2. Install wifi antenna that came with dev kit per wifi antenna instructions
   3. Connect to the CHIP Pro from Win 7 per serial connection (Windows) instructions
      You may see boot messages stream by
   4. Login with default user/password: chip/chip
   5. Enable the attached wifi antenna
      Neither the set_antenna script nor obvious access to a text editor are included with this image. So, the following steps show how to manually configure the CHIP Pro to use the connected wifi antenna. The following text should be run exactly as shown. For the sudo command, remember the default password is chip
      1. sudo bash
      2. echo 49 > /sys/class/gpio/export
      3. echo out > /sys/class/gpio/gpio49/direction
      4. echo 1 > /sys/class/gpio/gpio49/value
      5. echo 49 > /sys/class/gpio/unexport
      6. exit
   6. Enable wifi per the Debian wifi instructions
2. Install Docker
   Based on Docker is supported on the $9 C.H.I.P. computer
   1. The first three steps are covered by the work above
   2. For this test we will skip Step 4 (Configure SSH to access the C.H.I.P.)
   3. Step 5 is to check the kernel version (we need a build more recent than 4.4.13 dated Dec 6, 2016). Below is the output I get from Step 5.
      chip@chip:~$ uname -a
Linux chip 4.4.30-pro #1 SMP Wed Dec 21 01:50:18 UTC 2016 armv7l GNU/Linux
      It looks like we can safely move onto Step 6
   4. Remember to run the install command under sudo: sudo curl -sSL https://get.docker.com | sh
      Running under sudo might not have been necessary, there are calls to sudo in the install script. This is interesting, the docker install script reported missing features and then started updating apt-get and installing those missing features.
   5. Per comment at the end of the Docker install script, add chip to the docker group
      sudo usermod -aG docker chip
   6. Log out and then login back into the CHIP Pro to get the group membership to take effect
   7. Check the Docker version by running docker --version
   8. Clean up space by running sudo apt-get clean
      My results show Docker version 17.04.0-ce, build 4845c56 which differs from the version Bryan is running (1.12.2).
3. Testing the VU Meter CHIPtainer
   1. In theory, this is just a matter of following the instructions
      Except, apparently you will need a login for https://ntc-registry.githost.io (just head to that page and sign up for an account). Well that did not work. It looks like registration is restricted (I got the following error: "Email domain is not authorized for sign-up")

New plan for basic testing. I am going to run the test from the Docker is supported on the $9 C.H.I.P. computer instructions (Step 8).

1. docker run -d -p 80:80 hypriot/rpi-busybox-httpd
2. Get the CHIP Pro's ip address: ip addr
3. Open the CHIP Pro's ip address in a web browser

Success!!!

After reviewing the Docker files and re-reading Packt's Docker Cookbook, I think I can get the CHIPtainer example working. I say example (and not examples) because the three links above together build up to a single example, the VU Meter. You see, the VU Meter image is built upon the Python IO image. And the Python IO image is built upon the Alpine image.

If I am starting to get the hang of the things I have been reading, I think the basic set of steps to get things running are:

1. Build Alpine image from its Docker file
2. Publish the Alpine image in a public registry
3. Update the Python IO Docker file to reference the publicly hosted Alpine image
4. Build the Python IO image from the updated Docker file
5. Publish the Python IO image to a public registry
6. Update the VU Meter Docker file to reference the publicly hosted Python IO image
7. Build the VU Meter image from the updated Docker file
8. Publish the VU Meter image to a public registry (this is not strictly required, but it is nice)
9. Test out the VU Meter CHIPtainer

Tonight I will be setting a few things up and just testing out the general theory. See next post for engineering log.

Prep Work

So, first things first, I am going to need a local text editor and git, so time to install a couple of packages (followed by cleaning up disk space).

1. sudo apt-get install nano - I am not too proud to use nano for quick and dirty work
2. sudo apt-get install git
3. sudo apt-get clean

Testing

Now to run our test. I am going to try to build the Alpine image in a temporary testing directory.

1. mkdir ~/docker-test
2. cd ~/docker-test
3. git clone https://github.com/NextThingCo/chiptainer_alpine.git
4. cd ./chiptainer_alpine
5. ./build.sh
6. rm ./qemu-arm-static.tar.gz - cleaning up files we downloaded for the image
7. rm ./rootfs.tar.gz

So far, so good. Docker reported that it successfully built the image. And running docker images shows the nextthingco/chiptainer_alpine image is there. Well that worked so well, let's try the next level (without publishing things to a registry).

First, after a little bit of digging I found someone posted a pull request for the Python IO Docker file. So, I forked this version of Python IO and then forked the NGC versions of Alpine and VU Meter. I then cloned my Python IO into my docker-test directory and edited the Docker file for Python IO to change the FROM line from FROM ntc-registry.githost.io/nextthingco/chiptainer_alpine to FROM nextthingco/chiptainer_alpine. And I ran the build.sh for Python IO. The build.sh reported the build was successful.

I think that is enough for tonight. Tomorrow I will run some tests on the Python IO image by starting a container. And if that works, I will use a similar process to build the VU Meter image. And if all that works I will start publishing the images and updating the Docker files and READMEs to make things just work out of the box.

Leaving myself a note - https://blog.risingstack.com/minimal-docker-containers-for-node-js/

Next step is to test the Python IO image. The following are updated instructions from the the NTC instructions.

1. docker run -v /sys:/sys --cap-add SYS_RAWIO --device /dev/mem -it nextthingco/chiptainer_python_io
   The following commands are from within the Python IO container
   1. python
      The following commands are from within Python environment
      1. import CHIP_IO.GPIO as GPIO
      2. GPIO.setup("CSID3", GPIO.OUT)
      3. GPIO.output("CSID3", GPIO.HIGH) # LED D3 should light up
      4. GPIO.output("CSID3", GPIO.LOW) # LED D3 should go out
      5. exit()
         Exits Python
   2. exit
      Exits container

This test was a complete success (thought it did involve some additional changes to the demo instructions from NTC).

So, now it is time to get VU Meter running. So, back to the docker-test directory and now time to build the VU Meter code from my fork.

1. cd ~/docker-test
2. git clone https://github.com/modelb-jrs/chiptainer_vu_meter.git
3. cd chiptainer_vu_meter
4. Edit Dockerfile and update FROM line to FROM nextthingco/chiptainer_python_io
5. ./build.sh
6. docker run --name vu-meter --privileged --cap-add SYS_RAWIO --device /dev/mem -v /sys:/sys -ti nextthingco/chiptainer_vu_meter

Success, for a moment or two, then I received a "Program Closed" message and returned to the host OS prompt. The same thing happened when I restarted the VU Meter container. A little digging in the source code for the VU Meter shows it only runs 10 iterations and then displays "Program Closed". So, there you have it, total success!!!

Next steps are to clean up the files in my forks on github and publish the images to a public repo so people outside of NTC can just run the VU Meter example.

This afternoon I set out to take all that I had learned from my previous experiments and wrap it all up in a published version of the NTC CHIPtainer examples. I am very happy to report I was completely successful. You can try things out for yourself by following the instructions over at the public repo for the VU Meter example. Just scroll down and follow the instructions in the README section.

I plan to post a few notes about tricky places and some helpful commands I found tomorrow.

Some useful Docker commands (and sources)

• Login to Docker.io from Docker CLI tool
  docker login # no need to specify the service provider, it defaults to Docker.io
• Remove all exited containers (from https://www.digitalocean.com/community/tutorials/how-to-remove-docker-images-containers-and-volumes#removing-containers)
  docker rm $(docker ps -a -f status=exited -q)
• Remove all images (from http://docs.oracle.com/cd/E64747_01/E64749/html/osusg-troubleshoot-registry.html)
  docker rmi -f $(docker images -q)

While trying to build a Node.js CHIPtainer I quickly ran out of room on my CHIP Pro. This is not really surprising, but I was hoping the issue would come up later. So, for short term development, I have added a USB drive to my Dev Board, set it to automount, and switched Docker's root dir to be the USB drive. Below are my config changes.

format flash drive
sudo mkfs.ext4 /dev/sda

file system
sudo mkdir /mnt/usb

/etc/fstab
/dev/sda /mnt/usb ext4 defaults 0 0

more file system work

sudo mount -a
chmod 777 /mnt/usb

/etc/docker/daemon.json # new file
per https://docs.docker.com/engine/admin/systemd/#runtime-directory-and-storage-driver

{
    "graph": "/mnt/usb",
    "storage-driver": "overlay" 
}

And one more problem needed to be overcome... I received the following error when trying to build the Node.js CHIPtainer:

virtual memory exhausted: Cannot allocate memory

After some googling, I realized that the CHIP has 0 swap (just check out the results of running free -m). So, then I found the following instructions which fit very nicely with the work I had already done to set up a larger build environment on my CHIP Pro.

sudo dd if=/dev/zero of=/mnt/usb/swap.file bs=1M count=512
sudo chmod 600 /mnt/usb/swap.file
sudo mkswap /mnt/usb/swap.file
sudo swapon /mnt/usb/swap.file

The results of the build this time (after running for several hours - I really need to get a cross compile environment set up) were successful. Next up, some testing.

So, lots of news. I only have time for the TL;DR tonight.

• Using the swap file allowed the build to complete
• The new image did not include npm
• During missing npm troubleshooting, discovered the build of alpine we are using has nodejs
• Started testing the alpine node-js packages -> nodejs 7.2 can be installed with apk add nodejs-current
• Then started working on getting johnny-five to install
  • Eventual success (more details later)
  • Discovered that chip-io for node is not current for CHIP Pro (yay! another CHIP vs CHIP Pro issue)
  • Fixing chip-io for CHIP Pro is more work than I have time for right now (mostly because I don't know enough about the low level stuff)

The good news is the CHIPtainer stuff really does work, and if we mostly stay with apk packages and small builds, I think I can revert my changes to use the USB drive even on CHIP Pro. The bad news is we are not at a place where for v0.4 we have to decide between using nodejs and the CHIP Pro. If we go with nodejs we need to revert to CHIP. If we use CHIP Pro, we are probably looking at Python 2.7 as that is the only supported version on Alpine apparently.

I have just completed the CHIP Pro/Python testing and it was a huge success. Not only that, but it was all conducted inside a CHIPtainer, meaning we have successfully demonstrated that CHIPtainers will work for us. And with that, we can call "DEV-23: Test Nodejs then Johnny-Five in chiptainer enviroment to determine if we want to use chiptainer approach" done (with the caveat that we will be using Python instead of nodejs).