R Academy · Leçon

Déployer des applications Shiny

Publiez des applications sur shinyapps.io, Shiny Server et des environnements conteneurisés avec Docker.

Leçon 4 sur 413 étapes

Déployer des applications Shiny est une leçon R Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage R Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours R Academy comprend 4 leçons au total.

Présentation des options de déploiement

Les applications Shiny peuvent être déployées sur plusieurs plateformes, selon le budget, le trafic prévu et le niveau de contrôle requis :

shinyapps.io : hébergement infonuagique géré par Posit — la solution la plus simple, avec une offre gratuite.
Shiny Server (open source) : hébergement autonome sous Linux, gratuit.
Posit Connect : solution commerciale de niveau entreprise, qui prend également en charge R Markdown et Plumber.
Docker + rocker/shiny : portabilité et contrôle maximaux.

# Summary of deployment options and their trade-offs:
# shinyapps.io: managed, auto-scaling, per-instance pricing
# Shiny Server: self-hosted, unlimited users, needs sysadmin
# Posit Connect: enterprise SSO, scheduling, REST APIs
# Docker: any cloud provider, reproducible environments

cat('Choose based on: scale, budget, infra control needs')

Structure de app.R pour le déploiement

Une application Shiny déployable doit comporter soit un fichier app.R unique (contenant à la fois ui et server), soit deux fichiers, ui.R et server.R. Toutes les dépendances de packages doivent être déclarées avec library() en haut du fichier. Les fichiers de données doivent se trouver dans le même répertoire que l’application ou être accessibles par un chemin relatif à celle-ci.

# Minimal app.R for deployment
library(shiny)
library(ggplot2)
library(dplyr)

# Load data relative to app directory
data <- readRDS('data/processed_data.rds')

ui <- fluidPage(
  titlePanel('My Deployed App'),
  sidebarLayout(
    sidebarPanel(selectInput('var', 'Variable:', choices = names(data))),
    mainPanel(plotOutput('main_plot'))
  )
)

server <- function(input, output, session) {
  output$main_plot <- renderPlot({
    ggplot(data, aes_string(x = input$var)) + geom_histogram()
  })
}

shinyApp(ui, server)

rsconnect::deployApp()

Le package rsconnect gère le déploiement vers shinyapps.io et Posit Connect. Commencez par configurer les identifiants de votre compte, puis appelez rsconnect::deployApp() depuis le répertoire de l’application. Cette fonction regroupe automatiquement tous les fichiers R, les données et un manifeste.

library(rsconnect)

# One-time setup: link your shinyapps.io account
# rsconnect::setAccountInfo(
#   name   = 'your_account_name',
#   token  = 'YOUR_TOKEN',
#   secret = 'YOUR_SECRET'
# )

# Deploy the app in the current directory
rsconnect::deployApp(
  appDir  = '.',          # or 'path/to/app'
  appName = 'my_analysis_app',
  forceUpdate = TRUE
)

Configuration de shinyapps.io

shinyapps.io est le moyen le plus rapide d’obtenir une URL publique. Créez un compte gratuit sur shinyapps.io, copiez votre jeton et votre secret depuis le tableau de bord, puis appelez setAccountInfo(). L’offre gratuite permet d’utiliser 5 applications pendant 25 heures actives par mois.

library(rsconnect)

# Copy credentials from shinyapps.io -> Account -> Tokens
rsconnect::setAccountInfo(
  name   = 'your_username',
  token  = 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx',
  secret = 'yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy'
)

# Verify the connection
rsconnect::accountInfo()

# List currently deployed apps
rsconnect::applications()

Shiny Server open source

Shiny Server s’exécute sous Linux (Ubuntu/RHEL) et diffuse les applications Shiny depuis le répertoire /srv/shiny-server/. Chaque sous-répertoire devient une application accessible à l’adresse http://server:3838/subdirname/. Il est gratuit et prend en charge un nombre illimité d’utilisateurs simultanés (dans la limite des capacités du serveur).

# Install Shiny Server on Ubuntu:
# sudo apt-get install r-base
# sudo R -e 'install.packages(c("shiny", "rmarkdown"))'
# wget https://download3.rstudio.org/ubuntu-20.04/x86_64/shiny-server-1.5.21.1012-amd64.deb
# sudo dpkg -i shiny-server-1.5.21.1012-amd64.deb

# Deploy an app:
# sudo cp -r /path/to/myapp /srv/shiny-server/myapp
# Access at: http://your-server:3838/myapp

# Config file: /etc/shiny-server/shiny-server.conf
cat('Shiny Server config controls ports, auth, and app paths')

Docker avec rocker/shiny

L’image Docker rocker/shiny fournit un Shiny Server préconfiguré. Montez le répertoire de votre application dans le conteneur pour la diffuser immédiatement. Docker garantit la reproductibilité : la même image s’exécute de manière identique sur n’importe quel hôte.

# Dockerfile for a custom Shiny app
# FROM rocker/shiny:4.4.0
#
# # Install R package dependencies
# RUN R -e 'install.packages(c("ggplot2","dplyr","DT"))'
#
# # Copy app files
# COPY myapp/ /srv/shiny-server/myapp/
#
# EXPOSE 3838

# Build and run:
# docker build -t my-shiny-app .
# docker run -p 3838:3838 my-shiny-app

# Access at: http://localhost:3838/myapp

renv pour des dépendances reproductibles

renv crée une bibliothèque de packages au niveau du projet ainsi qu’un fichier de verrouillage (renv.lock) qui consigne les versions exactes des packages. Lors du déploiement, ce fichier garantit que le serveur ou l’image Docker installe exactement les mêmes versions de packages que celles utilisées pendant le développement.

library(renv)

# Initialise renv in the project (creates renv.lock)
renv::init()

# After installing/updating packages, record the state
renv::snapshot()

# On the server: restore exact versions from lockfile
renv::restore()

# Check lockfile for a specific package version
renv::dependencies()  # lists all used packages

Variables d’environnement pour la configuration

Ne codez jamais en dur les clés d’API, les mots de passe de base de données ou les paramètres propres à un environnement dans le code de l’application. Utilisez des variables d’environnement, lues avec Sys.getenv('VAR_NAME', unset = NA). Définissez-les localement dans .Renviron, puis dans la configuration d’environnement de la plateforme d’hébergement pour la production.

# In .Renviron (never commit this file):
# DB_HOST=prod-db.example.com
# DB_PASSWORD=secret123
# API_KEY=key_abc

# In app.R:
db_host <- Sys.getenv('DB_HOST',     unset = 'localhost')
db_pass <- Sys.getenv('DB_PASSWORD', unset = '')
api_key <- Sys.getenv('API_KEY',     unset = '')

if (api_key == '') {
  warning('API_KEY not set — some features disabled')
}

Présentation de Posit Connect

Posit Connect est la plateforme d’entreprise destinée au déploiement d’applications Shiny, de documents R Markdown, d’API Plumber et d’autres contenus. Elle prend en charge :

l’authentification unique (SSO) via LDAP ou SAML
l’exécution planifiée de rapports R Markdown
le contrôle d’accès au niveau de l’application
la mise à l’échelle automatique et l’équilibrage de charge

Le déploiement utilise le même processus rsconnect::deployApp() que shinyapps.io.

library(rsconnect)

# Configure connection to Posit Connect server
rsconnect::addServer(
  url  = 'https://connect.yourcompany.com',
  name = 'my_connect_server'
)

# Authenticate with API key
rsconnect::connectApiUser(
  account = 'jsmith',
  server  = 'my_connect_server',
  apiKey  = Sys.getenv('CONNECT_API_KEY')
)

# Deploy
rsconnect::deployApp(server = 'my_connect_server')

Liste de vérification avant le déploiement

Avant de déployer une application Shiny en production, vérifiez les points suivants :

Tous les chemins de fichiers utilisent des chemins relatifs et non des chemins absolus.
Les données sensibles (clés d’API, mots de passe) sont lues depuis des variables d’environnement.
Les dépendances de packages sont déclarées explicitement avec library() ou renv.lock.
Les fichiers de données volumineux sont chargés une seule fois en haut de server.R, et non à l’intérieur d’un bloc réactif.
Les messages d’erreur ne divulguent pas d’informations internes aux utilisateurs finaux.

# Production-hardened app.R patterns

# Load data once at startup (not per-session)
app_data <- readRDS('data/processed.rds')  # outside server()

server <- function(input, output, session) {
  # Reference app_data directly — already in memory
  output$plot <- renderPlot({
    subset_data <- app_data[app_data$group == input$grp, ]
    plot(subset_data$x, subset_data$y)
  })

  # Sanitise error messages
  tryCatch({
    risky_operation()
  }, error = function(e) {
    showNotification('An error occurred.', type = 'error')
    # log the real error internally, not to user
    message('Error: ', conditionMessage(e))
  })
}

Considérations relatives à la mise à l’échelle

Les applications Shiny sont basées sur des sessions : chaque utilisateur dispose de son propre processus R (ou travailleur). Stratégies de mise à l’échelle :

Charger les données précalculées au démarrage plutôt que de les calculer pour chaque session.
Utiliser la mise en cache réactive avec bindCache() pour les calculs coûteux partagés entre les sessions.
Plusieurs travailleurs : Shiny Server Pro et Posit Connect lancent des processus R en parallèle.
Backends de base de données : utiliser DBI/pool pour les accès simultanés à la base de données.

library(shiny)
library(pool)

# Create a database connection pool at startup
# (shared across all sessions)
pool <- dbPool(
  drv      = RPostgres::Postgres(),
  host     = Sys.getenv('DB_HOST'),
  dbname   = 'analytics',
  user     = Sys.getenv('DB_USER'),
  password = Sys.getenv('DB_PASSWORD'),
  minSize  = 2,
  maxSize  = 10
)

onStop(function() { poolClose(pool) })

server <- function(input, output, session) {
  output$tbl <- renderTable({
    dbGetQuery(pool, 'SELECT * FROM metrics LIMIT 100')
  })
}

Vérification rapide

Quelle est la méthode recommandée pour gérer les clés d’API et les mots de passe de base de données dans une application Shiny déployée ?

Réponds-y dans la leçon interactive

Récapitulatif du déploiement d’applications Shiny

Points clés du déploiement d’applications Shiny :

Options de déploiement : shinyapps.io (la solution la plus simple), Shiny Server (hébergé soi-même), Posit Connect (entreprise), Docker.
app.R doit déclarer toutes les dépendances avec library() ; utilisez renv::snapshot() pour obtenir des versions reproductibles.
rsconnect::deployApp() regroupe l’application et l’envoie vers shinyapps.io ou Posit Connect.
Docker avec rocker/shiny offre une portabilité maximale.
Utilisez Sys.getenv() pour les identifiants : ne codez jamais les secrets en dur.
Chargez les jeux de données volumineux au démarrage (en dehors de server()) afin de les partager entre les sessions.
Utilisez des pools de connexions (package pool) pour les accès simultanés à la base de données.

# Minimal production-ready structure
# myapp/
#   app.R           <- ui + server + shinyApp()
#   data/           <- processed datasets
#   R/              <- modules and helpers
#   renv.lock       <- package version snapshot
#   .Renviron       <- local env vars (gitignored)

# Deploy:
library(rsconnect)
rsconnect::deployApp(
  appDir  = 'myapp',
  appName = 'my_production_app'
)

Gratuit pour commencer

Apprends R avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours: 43
Leçons: 159

Commencer gratuitement Voir le cours complet

Questions Fréquemment Posées

La leçon « Déployer des applications Shiny » est-elle gratuite ?

Oui — le texte complet de « Déployer des applications Shiny » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours R Academy, passe à CoddyKit PRO. Le cours R Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Déployer des applications Shiny » ?

Publiez des applications sur shinyapps.io, Shiny Server et des environnements conteneurisés avec Docker. Tu pratiques R Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer R Academy ?

Aucune expérience préalable n'est requise. R Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Déployer des applications Shiny » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon R Academy ?

Oui. Chaque leçon R Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Approfondissement de la programmation réactive
Modules Shiny pour réutiliser le code
Interface dynamique avec renderUI et insertUI
Déployer des applications Shiny

← Retour à R Academy