How to run R using Docker on Raspberry Pi
When I began learning about how to use Docker I stumbled on an excellent project called Rocker. For anyone with an x86 machine these Rocker images allow them to run R and most of its dependencies in a containerised environment. Plumber APIs, anyone? What about your own Shiny server? Finally, data scientists using R can have the same level of control on dependencies and package versions as Python users have become accustomed to through
Things are a little more complicated for ARM users, especially 32-bit ARM architectures such as the Raspberry Pi. No Rocker images offer such compatibility so we’re on our own. This was the major reason I’ve started a project, called, ARMR, to build a series of Docker images that do offer compatibility with the lovable credit card sized computer.
Whilst not much has happened with the project so far, at least I have a version of “Hello woRld”: a container with r-base installed. But first we must install Docker.
From the terminal on a Raspberry Pi, run the following.
# Downloads installation shell script and pipes it into the sh command curl -sSL https://get.docker.com | sh # Adds pi to the docker group so the user can run sudo usermod -aG docker pi
From here we can either reboot or run
systemctl start docker.service to start up Docker. To test it is working, try
docker info, then
Once you know that Docker is running, let’s try a few things in order of sophistication.
docker run hello-world will run a container based on an image called hello-world.
docker run -it ubuntu bash takes it up a notch: now we have an ubuntu bash container running in interactive mode in the terminal.
To make it even more useful, we ought to have access to persistent storage. Let’s modify the command to include a mount volume.
docker run -it -v /home:/home ubuntu bash
-v flag tells Docker to attach a volume; the following argument contains the information on what locations should be used, of the form from_volume:to_volume. The location on your machine is the from_volume and the location on your container is the to_volume. In our example, anything you create in the home folder within the container will persist in the home folder of your Raspberry Pi after you close the container. The easiest way to test this is to type
touch myfile in the interactive terminal in the container, and watch the same file appear in your home folder.
Build an R container
Building a base R container is as simple as writing the code below to a file called
Dockerfile. We use an arm32 ubuntu image as a base, from which we set an environment variable to force the terminal to be non-interactive. This is because when r-base is installed it waits for user input when setting parameters, hanging the container build. By setting the installation to be non-interactive we accept all the defaults, including timezone. Be mindful of this when handling datetimes!
FROM arm32v7/ubuntu ENV DEBIAN_FRONTEND=noninteractive RUN apt update && apt install r-base -y
Once the Dockerfile is created you run it by typing
docker build -t armr in the same folder in the terminal. Docker then builds an image with the tag armr. It builds by starting with the base image, setting the environment variable and adding a layer that comprises the result from the
In fact, you can see all the layers that are built into any image by running
docker history <image_name> in the terminal.
Base R is fine but to be useful we need to add a lot more packages and supporting software. Future development is likely to encompass the following:
- Shiny server (I’d like to host one on this site)
- Plumber API server
- Rstudio server (so I can do analysis from anywhere on anything, even a tablet)
- Images for commonly used packages (Tidyverse, data.table, caret, etc.)