{"id":653,"date":"2021-07-10T20:31:29","date_gmt":"2021-07-10T18:31:29","guid":{"rendered":"https:\/\/macchina.io\/blog\/?p=653"},"modified":"2021-07-12T07:37:21","modified_gmt":"2021-07-12T05:37:21","slug":"building-an-iot-edge-application-with-macchina-io-and-docker-part-1","status":"publish","type":"post","link":"https:\/\/web-staging.macchina.io\/blog\/internet-of-things\/building-an-iot-edge-application-with-macchina-io-and-docker-part-1\/","title":{"rendered":"Building an IoT Edge Application with macchina.io and Docker (Part 1)"},"content":{"rendered":"

Following up my previous blog post<\/a> about edge computing, in this blog post I will show how to build an edge computing application by combining macchina.io EDGE<\/a> and macchina.io Remote Manager<\/a> with a number of other applications. These are Docker<\/a>, as everything will be deployed in containers, Portainer<\/a>, for providing a nice remotely-accessible web interface for managing Docker, as well as InfluxDB<\/a>, a well-known time-series database. The actual “computing” aspect of this demo will be a bit limited, as we’re mostly writing sensor data into a time-series database and then building a dashboard. However, the setup will allow to add some sensor data analytics later on.<\/p>\n

macchina.io EDGE will run a small JavaScript application that periodically acquires sensor data from an industrial-grade multi-sensor device (Bosch CISS<\/a>) connected via USB, and write the sensor data (temperature, humidity, acceleration) into an InfluxDB database. I will use InfluxDB’s dashboard capabilities to create a dashboard showing the data. It’s also possible to add Grafana to the setup, for even better dashboarding capabilities.<\/p>\n

macchina.io Remote Manager will provide remote access to all applications, via the macchina.io Remote Manager Gateway<\/a> application, also running in a Docker container<\/a>.<\/p>\n

On the hardware side I will use a Raspberry Pi 4 (running Raspberry Pi OS Lite, formerly known as Raspbian) as edge device, although the whole setup can be replicated on any platform that runs Docker. <\/p>\n

An interesting aspect of this demo is that it shows the macchina.io EDGE can be used in two ways. On the one hand, macchina.io EDGE provides quite comprehensive C++ and JavaScript APIs, giving you lots of flexibility for building fully custom IoT and edge device applications. On the other hand, macchina.io EDGE can also be used “out of the box” (in our case, using the available Docker image), as a “low-code” platform for writing edge applications in JavaScript, by just using the already available APIs and device integrations. In this demo I will focus on the latter.<\/p>\n

\"macchina.io

macchina.io Edge Computing Demo Setup<\/p><\/div><\/p>\n

This blog post is split into two parts. In this first part, I will describe how to set up the basic system. In the second part, I will show how to build the JavaScript program that reads the data from the sensor and writes it to InfluxDB.<\/p>\n

Prerequisites<\/h2>\n

In the following I assume you have some basic understanding of Docker<\/a> and Docker Compose<\/a>. Some experience working with a Raspberry Pi is nice to have as well, but not required. However, it’s also possible to run the containers on any machine where Docker is available. <\/p>\n

Preparing the Environment<\/h2>\n

I’m starting with a clean Raspberry Pi OS Lite<\/a>\u00a064-bit image on an SD card (32 GB or more). Note that a 64-bit image is required because of InfluxDB, which currently only supports 64-bit architectures. The Raspberry Pi OS Lite 64-bit image can be downloaded from the Raspberry Pi Downloads<\/a> server, using this link<\/a>. Use the latest image version available, at the time of writing this was dated 2021-05-28. Open the image in Raspberry Pi Imager<\/a> tool and write it to an SD-Card. Click the CHOOSE OS<\/strong> button, then select Use custom<\/strong>\u00a0(the last option) and select the 64-bit image (2021-05-07-raspios-buster-arm64-lite.img<\/code>). Then proceed as usual. The rest of the Raspberry Pi setup works just as with the “regular” 32-bit Raspberry Pi OS. Note that at the time of writing, the 64-bit version is still in beta, so some things may not work.<\/p>\n

\n

Note: it’s possible to run a variant of that setup on a 32-bit Raspberry Pi OS. For that you have to replace InfluxDB 2.0 with 1.8 and additional install Grafana for the graphing\/dashboard capabilities.<\/p>\n<\/blockquote>\n

First step, as usual, is expanding the file system to make all space on the SD card available, enabling SSH access<\/a> and, finally, upgrading all Linux packages to their latest versions:<\/p>\n

$ sudo apt-get update && sudo apt-get upgrade<\/pre>\n
You can verify that the Raspberry Pi is running a\u00a064-bit OS with:<\/p>\n
$ uname -m
aarch64<\/pre>\n
\n
Optional Step: In order to monitor the memory usage of containers with Docker (and Portainer), two additional arguments must be passed to the Linux kernel at boot time, to enable cgroup<\/em> memory accounting. This can be done by editing the \/boot\/cmdline.txt<\/code> file and adding cgroup_enable=memory cgroup_memory=1<\/code> to the end of the line.<\/p>\n<\/blockquote>\n
Next is installing Docker. The easiest way is by running the convenience installer script<\/a> from the Docker website. A quick word of warning: before running scripts downloaded from a website, always make sure to inspect the script first.\u00a0To download and run the script,\u00a0use the following commands:<\/p>\n
$ curl -fsSL https:\/\/get.docker.com -o get-docker.sh
$ sudo sh get-docker.sh<\/pre>\n
This\u00a0will download the script\u00a0from\u00a0the Docker website and execute it to\u00a0install\u00a0the latest Docker version.\u00a0After the script completes,\u00a0we can verify\u00a0that\u00a0Docker was\u00a0successfully installed by running:<\/p>\n
$ sudo docker version<\/pre>\n
At the time\u00a0of writing this post, the current version was 20.10.7.<\/p>\n
Note that docker<\/code> must be run with sudo<\/code>. For convenience, it’s possible to add the user account you’re using (pi<\/code>) to the docker<\/code> group to avoid having to use sudo<\/code> all the time:<\/p>\n
$\u00a0sudo usermod -aG docker pi<\/pre>\n
It’s also possible to run\u00a0the\u00a0hello-world container to make sure\u00a0everything is okay:<\/p>\n
$ sudo docker run hello-world<\/pre>\n
This should print out some information that everything’s properly running.<\/p>\n
Next, I’m also going to install\u00a0Docker Compose<\/a>, as it will make it\u00a0easier to get all containers up and running. On the Raspberry Pi,\u00a0Docker Compose must be installed via\u00a0Python 3’s\u00a0pip package manager (pip3<\/code>), which\u00a0requires\u00a0Python 3.x to be installed first:<\/p>\n
$ sudo apt-get -y install libffi-dev libssl-dev python3-dev python3 python3-pip
$ sudo pip3 -v install docker-compose<\/pre>\n
Successful installation\u00a0can be\u00a0verified\u00a0by running:<\/p>\n
$\u00a0docker-compose -v<\/pre>\n
which will\u00a0show the\u00a0version\u00a0number of\u00a0the installed docker-compose<\/code> script.<\/p>\n
This completes the basic infrastructure setup. Before\u00a0moving on, I’ll connect the\u00a0CISS\u00a0sensor to one of the Raspberry Pi’s\u00a0USB ports and\u00a0verify that it shows up\u00a0in the\u00a0\/dev<\/code> filesystem.\u00a0It should show up as a new device file\u00a0\/dev\/ttyACM0<\/code>.<\/p>\n
$ ls -l \/dev\/ttyACM0
crw-rw---- 1 root dialout 166, 0 Jul 9 07:17 \/dev\/ttyACM0<\/pre>\n
Note that accessing\u00a0this device\u00a0requires either root<\/code>\u00a0or membership\u00a0in the dialout<\/code> group. More on that later.<\/p>\n
\n
Note: Make sure that the Raspberry Pi is connected to a sufficiently powerful power adapter. A Raspberry Pi 4 with an additional device (CISS multi-sensor) connected via USB requires significant energy, which is more than standard USB-C ports can provide. If you experience sudden freezes, check the kernel log (dmesg<\/code>) for undervoltage detected<\/code> messages.<\/p>\n<\/blockquote>\n
macchina.io Remote Manager<\/h2>\n
I will use macchina.io Remote Manager to remotely access the Raspberry Pi (via SSH) and the applications it runs (macchina.io EDGE, Portainer, InfluxDB) once the device has been deployed to the final location (e.g., shop floor, etc.), where I no longer can directly access it in my local network. This requires setting up an account on our free Remote Manager server. After registering your new account<\/a> and confirming your email address, sign in to the Remote Manager at reflector.my-devices.net<\/a> and click the user icon or your email address on the top right.<\/p>\n
\"macchina.io<\/p>\n
You will then see your Account page, and on it you will find your Domain ID<\/strong>. Copy that to the clipboard (by clicking the Copy button next to the ID) and save it in a text document. You will need it later on when setting up the macchina.io Remote Manager Gateway<\/a> container.<\/p>\n
\"Remote<\/p>\n
Composing the Containers<\/h2>\n
Next I’m going to set up the containers. For that purpose, I’m going to use Docker Compose, and will write a docker-compose.yml<\/code> file that specifies all the containers I want in my demo.<\/p>\n
The following container images will be used:<\/p>\n