The Dockerfiles in this repository are used to build the RStudio Server and Desktop Debian packages for running on the Raspberry Pi Raspbian distribution. The work is split into several phases, each of which builds a separate docker image:
- Creating a build environment that contains all necessary tools to compile
RStudio Server and Desktop and build the respective Debian packages.
- Dockerhub: arturklauser/raspberrypi-rstudio-build-env
- Creating the RStudio Server Debian package within the build environment
from 1.
- Dockerhub: arturklauser/raspberrypi-rstudio-server-deb
- Creating the RStudio Desktop Debian package within the build environment
from 1.
- Dockerhub: arturklauser/raspberrypi-rstudio-desktop-deb
- Creating an RStudio Server runtime environment from 2.
- Dockerhub: arturklauser/raspberrypi-rstudio-server
The docker images can be either created natively on a sufficiently potent Raspberry Pi (e.g. Raspberry Pi 3 with 1 GB of memory) or they can be created by cross-building on an x86 host. Due to the fabulous work of the folks at Balena, cross-builds can be achieved with only a couple of lines added to the Dockerfiles. The build phase commands are partially taken from Takahashi Makoto's excellent write-up of RStudio installation on Raspberry Pi.
Make sure that you have a working docker environment set up on the host machine that you are going to use for creating or using these docker images. Please refer to Docker's Getting Started documentation for setting up docker.
For docker newbies, note that docker stores the built and pulled images in its own image cache directories by their sha256 name. Don't expect to find them in the file system, e.g. your build directory, by image name. To list which images you have after the build use the docker command:
docker images
Please refer to the docker documentation for basic usage of docker.
Use Dockerfile.build-env to create the build environment in which the code for RStudio Server and Desktop is going to be compiled. The build procedure has been adapted to the Raspbian environment using the native version of the Boost library and the native QT libraries. It has been tested on Debian 9 (Stretch) and Debian 10 (Buster). An experimental Debian 11 (Bullseye) version is also available. Once the build environment is created, it is used by Dockerfile.server-deb and Dockerfile.desktop-deb to build the RStudio Server and Desktop Debian packages respectively.
The build process is fairly lengthy. Expect several hours (5-10ish) both natively and in cross-build. You'll also need at least 1 GB of RAM on the build machine, but more is better, which precludes native build on smaller Raspberry Pis with less memory. In addition make sure to configure at least 1 GB of swap space. Under Raspbian you can configure swap space like this:
- in
/etc/dphys-swapfileset CONF_SWAPSIZE=1024 (default is 100) - run
sudo service dphys-swapfile restart - once the build is done and you're happy with the result you can set
the swap space back to the default 100 MB:
- in
/etc/dphys-swapfileset CONF_SWAPSIZE=100 sudo service dphys-swapfile restart
- in
An attempt was made to have the build run on dockerhub autobuild, but its VMs take about 3 times longer than a native build on a Raspberry Pi 3 B+ and run into the 4 hour time limit imposed for autobuilds. Overcoming this would have required to split the Dockerfile.*-deb build files into 3 sequential builds each, which was not considered worthwhile. So the infrastructure to hook into dockerhub autobuilds has been removed again from this repository.
The Dockerfiles are set up for cross-build by default. To build natively, first comment out the cross-build commands:
perl -i -pe 's/(.*cross-build-(start|end).*)/# $1/' docker/Dockerfile.*
Since the Dockerfiles depend on a number of ARGs that must be passed in on the
command line, the preferred way of building the images is to use the wrapper
shell script build.sh.
To build, run:
for stage in build-env server-deb desktop-deb; do
./build.sh buster "${stage}"
done
To reduce the memory pressure, the build uses only a parallelism of 2 by
default. If you are running out of memory you can try reducing that to 1 by
changing it in the build.sh script. On the other hand, if you are cross-building
on a host with sufficient memory you can increase this, e.g. on a host with >= 8
GB of RAM you can use BUILD_PARALLELISM=4.
Once the build of each Debian package is done, the build environment is jettisoned and the packages is copied into an empty container's root directory.
Use Dockerfile.server to create the docker image that has the RStudio Server
and it's runtime environment installed. This Dockerfile makes use of
multi-stage
build to
extract the Debian Server package from the build image and transplant it into a
new lean runtime image. You can choose to build a minimal runtime that can run
basic R programs in RStudio Server but doesn't have any extras installed. For
this you would add the --target install-minimal to the docker build command.
The default is to build a more fully featured runtime with:
./build.sh buster server
The full runtime also has the necessary system and R packages installed to support working with .Rmd files including latex for generating PDF, as well as source code version control. It also contains compile environments for C, C++ and Fortran which are often used when you install additional R source packages from CRAN in your R user environment, as well as R packages for data cleaning, manipulation, and plotting.
Once you have the raspberrypi-rstudio-server created you can start an RStudio server on your Raspberry Pi simply with:
docker run --rm --name rserver -v $PWD/work:/home/rstudio -p 8787:8787 -d arturklauser/raspberrypi-rstudio-server
The rstudio-server will start in the docker container named rserver and
starts to listen on its default port 8787. You now simply point your web
browser to http://<your_raspberry_pi>:8787 where you will be greeted by a
login screen. The image is set up with a default user name of rstudio and
password of raspberry. You can override those at image build time by adding
--build-arg USER=foo --build-arg PASSWORD=bar to the command line. After
entering those credentials you will see the RStudio development environment in
your web browser.
Most likely you will want to keep the results of your work around across
container restarts. For this, the server image is expected to be used with a
working directory from your host ($PWD/work above) mounted into the home
directory /home/rstudio of the user in the rserver container. Make sure that
the directory on the host exists before you pass it into the docker container,
otherwise container engine will probably create is as root which will give you
permission problems when trying to create files in it from within the container.
If you have specified a different USER at build time, you have to adjust the
/home directory accordingly.
If you want to install and run RStudio natively on your Raspberry Pi you can do that too. You can extract the RStudio Server Debian package from that docker build image with:
docker image save arturklauser/raspberrypi-rstudio-server-deb | tar xO --wildcards '*/layer.tar' | tar x
This copies the rstudio-server*.deb package into your current directory.
Extraction of the RStudio Desktop package rstudio-desktop*.deb works
similarly with:
docker image save arturklauser/raspberrypi-rstudio-desktop-deb | tar xO --wildcards '*/layer.tar' | tar x
Check the releases if you just want to download some pre-built Debian packages.
At this time, the Raspbian Buster package archives that are configured by default on a fresh Raspbian install are missing a few QT5 libraries which are required to run RStudio Desktop. To get access to those, add the Debian package archive to your archive list first.
sudo cat > /etc/apt/sources.list.d/debian.list << EOF deb http://deb.debian.org/debian/ buster main EOF curl -fsSL https://ftp-master.debian.org/keys/release-10.asc | sudo apt-key add -
Once you have extracted the .deb images from the build containers in the steps
above, you're ready to install them natively on your Raspberry Pi. To make sure
the dependencies are also properly installed we'll use apt instead of dpkg
and we also update the package list first:
sudo apt-get update
sudo apt install ./rstudio-server-1.1.463-1~r2r_armhf.deb # installs rstudio-server
sudo apt install ./rstudio--1.1.463-1~r2r_armhf.deb # installs rstudio-desktop
That's all. The Debian installation scripts have already installed the scripts
that make sure rstudio-server is started and keeps running whenever your
Raspberry Pi boots up. If you point your web browser to
http://<your_raspberry_pi>:8787 you're in the game. Note, however, that you
can't run RStudio Server both natively and in a docker container on the same
machine at the same time and have them both use the same port 8787. If you
already have a native RStudio running and using port 8787 you can map the
container version to a different port, e.g. 8788, by using -p 8788:8787 on
the docker command line instead.
As for RStudio Desktop, you can find it on your desktop in the applications menu under Programming -> RStudio.
Happy developing!