Skip to content

Catalogue Shiny

Contexte

Le Catalogue Shiny du Mésocentre propose un accès en ligne à des applications interactives développées avec le framework R/Shiny.
Ces applications sont destinées à la visualisation, à l’analyse de données ou à la diffusion de résultats scientifiques, dans un format accessible depuis un simple navigateur web.

Les applications sont hébergées et exécutées à l’aide de ShinyProxy, une solution open source permettant de déployer des applications Shiny dans des conteneurs Docker.

Fonctionnement

ShinyProxy permet d’exposer des applications R/Shiny sous forme de conteneurs isolés.
À chaque connexion d’un utilisateur, une instance indépendante de l'application est lancée, garantissant ainsi des exécutions isolées, reproductibles et sans interférence entre utilisateurs.

Deux instances de ShinyProxy sont actuellement déployées sur le cluster Kubernetes du Mésocentre :

  • Catalogue public : accessible librement, il regroupe des applications prêtes à être diffusées.
  • Catalogue privé : réservé à des applications sous embargo (par exemple, en attente de publication).
    L'accès nécessite un mot de passe fourni par l’équipe déposante ou le Mésocentre.

Cas d’usage

Le catalogue Shiny peut être utilisé pour :

  • Diffuser des résultats de recherche de manière interactive
  • Partager des visualisations avancées avec des collaborateurs ou partenaires
  • Fournir un accès simplifié à des jeux de données ou des modèles
  • Conserver des applications confidentielles dans un environnement sécurisé en attendant leur diffusion.

Déploiement d’une application

Pour déployer une application dans le Catalogue Shiny du Mésocentre, il est nécessaire de fournir un projet R/Shiny structuré et conteneurisé.
L'infrastructure repose sur ShinyProxy et Kubernetes, ce qui implique l'utilisation de Docker pour packager chaque application.

Pour proposer une application à héberger sur le catalogue, il faut dans un premier temps contacter l’équipe support du Mésocentre pour discuter de la faisabilité et des besoins spécifiques.

Informations à fournir lors d’une demande d’hébergement

Pour faciliter la prise en charge de votre demande, merci de bien vouloir fournir les informations suivantes (liste non exhaustive) :

  • Nom et prénom du référent de l’application
  • Laboratoire, unité ou équipe d’appartenance du référent
  • Liste des personnes autorisées à accéder au code source de l’application
  • Statut du code source : public ou privé
  • Choix du catalogue : intégration au catalogue public ou privé
  • Type d’application R/Shiny (visualisation, calcul, simulation, etc.)
  • Description succincte de l’application et de ses fonctionnalités
  • Nom souhaité pour l’application (qui sera utilisé dans l’URL d’accès)
    • Veuillez éviter les caractères spéciaux
    • Les espaces seront automatiquement remplacés par des tirets (« - »)
  • Toute autre information pertinente à votre projet ...

Remarque importante pour les applications publiques

Le code source des applications publiques sera déposé dans le repository GitLab suivant :
https://git.mesocentre.uca.fr/mesocentre-public/k8s

Il sera organisé dans un sous-projet spécifique correspondant au laboratoire, unité ou équipe que vous aurez indiqué lors de la demande d’hébergement.

Projet Shiny attendu

Un projet minimal doit inclure :

  • README.md : description courte de l'application (titre + résumé), utilisée par ShinyProxy pour la présentation
  • .gitlab-ci.yml : pipeline GitLab CI/CD définissant les étapes de build et de publication
  • Dockerfile : fichier de construction de l'image Docker de l'application
  • app/ : répertoire contenant les fichiers R de l'application (app.R, ou ui.R + server.R)

Structure :

my-shiny-app/
├── README.md
├── .gitlab-ci.yml
├── Dockerfile
└── app/
    └── app.R

Ce type de projet est compatible avec les pipelines CI/CD utilisés au Mésocentre avec intégration continue :

  1. étape build: construction de l'image de conteneur à chaque commit (avec kaniko)
  2. etape production: ajout du tag latest pour publication dans ShinyProxy (avec crane)

Bonnes pratiques de développement Shiny

Pour améliorer la qualité, la maintenabilité et l’expérience utilisateur de vos applications R/Shiny vous pouvez suivre les recommendations de la documentation du service d'hébergement du projet SK8.

Vous pouvez déjà retenir qu'il faut :

  • Documenter clairement l’application dans le README.md avec un titre explicite et une description concise de son objectif et usage.
  • Ne jamais utiliser install.packages() directement dans le code de l’application, mettre les packages à installer dans l'image Dockerfile
  • Tester la construction de l’image localement en tant que user (pas en root) avant de la pousser dans le pipeline CI/CD pour détecter rapidement les erreurs
  • Structurer l’application Shiny en séparant clairement ui.R, server.R et global.R pour faciliter la maintenance
  • Utiliser validate() pour afficher des messages d’erreur clairs et adaptés à l’utilisateur
  • Ajouter une page d’accueil pour contextualiser l’application et informer l’utilisateur
  • Intégrer des barres de progression pour améliorer l’expérience utilisateur lors des calculs longs
  • Envisager le package {golem} pour une architecture robuste et modulaire sur les projets complexes

Tester en local avant soumission

Avant tout déploiement, vous devez tester votre application localement, sans privilèges root, pour vérifier son bon fonctionnement dans un conteneur :

docker build -t my-shiny-app .
docker run -p 3838:3838 my-shiny-app
Ouvrez votre navigateur à l'adresse http://localhost:3838 pour accèder à l'application

Exemple de projet Shiny

app.R

Voici un exemple minimal de fichier app.R, qui constitue le cœur de l'application Shiny. Il définit à la fois l'interface utilisateur (ui) et le serveur (server), nécessaires pour faire tourner l'application.

library(shiny)
ui <- fluidPage(
  "Hello world!"
)
server <- function(input, output, session) {
}
shinyApp(ui, server)
README.md

Voici un exemple minimal de README.md utilisé pour décrire l'application dans l'interface ShinyProxy. Le titre et la description courte seront affichés dans le catalogue :

# Hello World Shiny App

## Description

Cette application est un exemple minimal d’une application R/Shiny déployée via Docker avec intégration continue GitLab CI/CD.  
Elle permet de tester et démontrer le fonctionnement du pipeline de construction et de déploiement pour des apps Shiny hébergées dans un environnement type ShinyProxy.
.gitlab-ci.yml

Pour permettre la construction automatique de votre image Docker et son déploiement dans ShinyProxy, vous pouvez utiliser le fichier .gitlab-ci.yml suivant :

---
stages:
  - build
  - production

variables:
  IMAGE_TAG: $CI_COMMIT_SHORT_SHA # or $CI_COMMIT_TAG if only building on tags

container-build:
  stage: build
  image:
    name: gcr.io/kaniko-project/executor:debug
    entrypoint: ['']
  script:
    - /kaniko/executor
      --context "${CI_PROJECT_DIR}"
      --dockerfile "${CI_PROJECT_DIR}/Dockerfile"
      --destination "${CI_REGISTRY_IMAGE}:${IMAGE_TAG}"

container-latest:
  stage: production
  image:
    name: gcr.io/go-containerregistry/crane:debug
    entrypoint: ['']
  script:
    - crane auth login -u ${CI_REGISTRY_USER} -p ${CI_REGISTRY_PASSWORD} ${CI_REGISTRY}
    - crane tag ${CI_REGISTRY_IMAGE}:${IMAGE_TAG} latest
Dockerfile

Les packages R et les dépendances système doivent être installés au moment de la construction de l’image Docker, et non à l'exécution de l'application.
Cela permet de garantir un environnement reproductible, stable et plus rapide au lancement.

Comme ici avec ce Dockerfile de base pour une application Shiny simple :

# ref:
#  - https://rocker-project.org/images/versioned/shiny.html
#  - https://hub.docker.com/r/rocker/shiny-verse/tags
FROM docker.io/rocker/shiny-verse:4.2.3

ENV SYSPACKAGES="libudunits2-dev libgdal-dev libgeos-dev libpoppler-cpp-dev libpoppler-glib-dev libglpk-dev"

# Installation des packages système
RUN apt-get update \
&& apt-get install --no-install-recommends -y $SYSPACKAGES \
&& rm -rf /var/lib/apt/lists/*

## Ajout de package R
ENV RPACKAGES="rgdal shiny tidyverse"

# Installation des packages R depuis CRAN
RUN install2.r --ncpus 2 --error --deps TRUE $RPACKAGES && rm -rf /tmp/*

# Copie du code de l'application dans le conteneur
RUN rm -rf /srv/shiny-server/
COPY app/ /srv/shiny-server/

Lorsque les packages R ne sont pas disponibles sur CRAN, ils peuvent être installés via GitHub (avec remotes) ou Bioconductor (avec BiocManager).
Ces installations doivent également être faites dans le Dockerfile, au moment du build de l’image :

# Installation de packages depuis GitHub
RUN R -e 'remotes::install_github("d3treeR/d3treeR")'

# Installation de packages depuis Bioconductor
RUN R -e 'install.packages("BiocManager")'
RUN R -e 'BiocManager::install("graph")'

Ressources

Support

Pour toute demande relative au catalogue Shiny (ajout d'application, accès, problèmes techniques), veuillez contacter l’équipe du Mésocentre via le système de tickets de l’Université :

Veuillez mentionner que votre demande concerne le service Shiny du Mésocentre.

Le catalogue Shiny permet de rendre la science plus interactive et accessible. N’hésitez pas à valoriser vos travaux à travers une application Shiny !