You created some great Shiny applications, following our advice of Shiny packaging for example, and you want to put them into production, self-hosting, so that others can enjoy them, without limitations, on the Internet or on an internal server of your company? ShinyProxy is for you!
ShinyProxy v2.0 has recently been released. What a great opportunity to talk about its implementation!
A major interest of ShinyProxy is its ability to create an independent Docker container for each user who connects to your Shiny application. This overrides the limitations on the number of users faced with ShinyServer. Are you interested? Follow the installation procedure….
Table of Contents
For our installation, we chose to use a Debian Jessie server. We let you make the necessary code adjustments for other Linux distributions. (For example, for Ubuntu, replace ‘debian’ with ‘ubuntu’ in the appropriate codes). In addition, there are two ways to deploy ShinyProxy, either using JAVA or using a Docker container. You will be able to choose either one or the other after this article but in both cases you will have to install Docker on your server!
ShinyProxy and Java
First step: install Java
ShinyProxy is a software that works with Java. You need to check if Java is installed and if so, which version. In your terminal, enter the command: `
sh Java -version
If you receive a message like this:
openjdk version "1.8.0_xxx"
Then Java 8 is already installed on your server. Otherwise, you can install either (1) the free version:
sudo apt install default-jre default-jdk
or (2) the Java8 version of Oracle with webupd8team’s PPA:
echo "deb http://ppa.launchpad.net/webupd8team/java/ubuntu xenial main" | \ sudo tee /etc/apt/sources.list.d/webupd8team-java.list echo "deb-src http://ppa.launchpad.net/webupd8team/java/ubuntu xenial main" | \ sudo tee -a /etc/apt/sources.list.d/webupd8team-java.list sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys EEA14886 sudo apt-get install oracle-java8-installer
We check if the installation worked well:
openjdk version "1.8.0_xxx"
Perfect, then we can continue our installation.
Second step: Install Docker
As explained above, ShinyProxy allows you to launch a Docker container from our Shiny application. So we will install Docker CE on our server.
There is a need for some dependencies. It is also better to install the latest version of Docker CE using Docker servers as a third-party repository.
In your terminal:
sudo apt-get install \ apt-transport-https \ ca-certificates \ curl \ gnupg2 \ software-properties-common curl -fsSL https://download.docker.com/linux/debian/gpg | sudo apt-key add - sudo add-apt-repository \ "deb [arch=amd64] https://download.docker.com/linux/debian \ $(lsb_release -cs) \ stable"
sudo apt-get install docker-ce
To find out if everything went well, you can run a little test to ask Docker to say hello:
docker run hello-world
If you get a message like this:
Then Docker is installed.
One last small modification….
For ShinyProxy to work, you need to modify the Docker file
/lib/systemd/systemd/system/docker.service and restart Docker (use your favorite text editor):
sudo nano /lib/systemd/system/docker.service
Modify the line with ‘ExecStart’.
ExecStart=/usr/bin/dockerd -H fd:// -D -H tcp://127.0.0.1:2375
Then restart Docker
sudo systemctl daemon-reload sudo systemctl restart docker
Third step: Install ShinyProxy
It’s time to go back to what really interests us, the installation of ShinyProxy to deploy our Shiny applications!
First, you need to clone the GitHub repository of the ShinyProxy software (you can also download the .zip from github):
git clone https://github.com/openanalytics/ShinyProxy.git
We should find a “ShinyProxy” folder. We get into the folder and install ShinyProxy. You may first need to install “maven”:
cd ShinyProxy/ sudo apt install maven mvn -U clean install
Then, we can test if the examples can be run. To do this, you need the ShinyProxy template and the Docker images of the Shiny applications proposed in the demo.
mkdir app-shiny cd app-shiny/ git clone https://github.com/openanalytics/ShinyProxy-template.git cd ShinyProxy-template/ docker build -t openanalytics/ShinyProxy-template .
Then, you launch ShinyProxy: You have to go up in the tree structure to find the folder “ShinyProxy/target”.
Change this command with the version of ShinyProxy you have.
cd ShinyProxy/target/ java -jar ShinyProxy-2.0.2.jar
https://localhost:8080. You should see this page:
To be able to customize your ShinyProxy (deploy your applications, change the ShinyProxy home page), you have to modify the
application.yml file and the different
.html contained in the different sub-folders of
shinproxy/. For example, we can modify the configuration file
application.yml (this file allows us to define the applications to be deployed and other ShinyProxy configurations):
cd ../src/main/ressources/ nano application.yml
Let’s remove a demo application for example. For that you just have to delete the following lines:
- id: 06_tabsets container-cmd: ["R", "-e", "ShinyProxy::run_06_tabsets()"] container-image: openanalytics/ShinyProxy-demo container-network: sp-example-net
cd ../../../ mvn -U clean install
Then, restart with the
cd target/ Java -jar ShinyProxy-2.0.2.jar
But all these steps take a long time. Following each change, it is necessary to recompile, restart,… The round trips are therefore frequent and a waste of our time. Besides, here it doesn’t run in the background, the terminal needs to be up (although you can use
nohup). This leads us to use the “ShinyProxy in container” version.
ShinyProxy in Docker container
Do not forget to install docker too to follow this part (cf. Second step: Install Docker)!
To make our lives easier, there are ShinyProxy templates that can be easily deployed with Docker. You will find an example here!
First, it is necessary to clone the GitHub repository:
mkdir ShinyProxy-docker cd ShinyProxy-docker/ git clone https://github.com/openanalytics/ShinyProxy-config-examples.git
We get four files. For this example, we will use the folder starting with
02. It contains two important files: (1) the
application.yml file that allows the configuration of our ShinyProxy and (2) the
dockerfile, which allows the ShinyProxy image to be mounted.
We will detail the important code lines of this file. We will also be able to discuss the differences between versions 1.1 and 2.0 of ShinyProxy because the writing of the `.yml’ has changed.
Changes between versions are in the part dedicated to Shiny applications.
docker is replaced by
In ShinyProxy version 1.1, we had:
apps: - name: 01_hello display-name: Hello Application description: Application which demonstrates the basics of a Shiny app docker-cmd: ["R", "-e", "ShinyProxy::run_01_hello()"] docker-image: openanalytics/ShinyProxy-demo groups: [scientists, mathematicians]
And in version 2.0, we have:
specs: - id: 01_hello display-name: Hello Application description: Application which demonstrates the basics of a Shiny app container-cmd: ["R", "-e", "ShinyProxy::run_01_hello()"] container-image: openanalytics/ShinyProxy-demo container-network: sp-example-net
Here is the example of the
.yml proposed in the
02 folder that we downloaded earlier:
proxy: port: 8080 authentication: simple admin-groups: admins users: - name: jack password: password groups: admins - name: jeff password: password docker: internal-networking: true specs: - id: 01_hello display-name: Hello Application description: Application which demonstrates the basics of a Shiny app container-cmd: ["R", "-e", "ShinyProxy::run_01_hello()"] container-image: openanalytics/ShinyProxy-demo container-network: sp-example-net - id: 06_tabsets container-cmd: ["R", "-e", "ShinyProxy::run_06_tabsets()"] container-image: openanalytics/ShinyProxy-demo container-network: sp-example-net logging: file: ShinyProxy.log
In this file,
port indicates that the container will launch on port
authentication gives us the type of identification chosen, in our case it is “simple”. In other words, we create
users which can be long (there are many others). Then we find the
specs part for the different Shiny applications.
A brief focus on interesting options:
heartbeat-timeout: 60000allows you to configure how long (in milliseconds) the container remains active if it is not used. After that, he is stopped.
hide-navbar : truehides the navigation bar.
There are many more options that you can find here.
The Dockerfile allows us to build our Docker image according to what we are interested in. In the
02 folder, it allows you to directly change the
.yml but you might also want to change the home page for example (
04 folder for the most curious).
The installation of ShinyProxy
It is now time to practice.
First, we need to create a network so that ShinyProxy can communicate with the containers of the Shiny apps. Let’s name this network
sudo docker network create sp-example-net
Then, we have to create our ShinyProxy image: You need to make sure you’re inside the right folder (in 02-containerized-docker-engine)!
cd 02-containerized-docker-engine docker build -t mon_shinyproxy .
Finally, let’s run our container:
sudo docker run -d -v /var/run/docker.sock:/var/run/docker.sock --net sp-example-net -p 8080:8080 mon_shinyproxy
We save a lot of time compared to the off-Docker version. In two command lines, you can restart your ShinyProxy if you made changes to the
And there are many other possibilities with ShinyProxy and Docker.
That’s it ! You have all the information you need to put your Shiny application into production! Don’t forget to turn your application into a package! If this is not the case, you can read our article on designing a shiny template in an R package. And if you don’t make it, you can always ask us !