Qu’est-ce que Shiny en R ? Créer des applications web interactives à partir de code R

Transformez une analyse que vos collègues ne peuvent pas exécuter en une application web qu’ils utilisent dans un navigateur.

Programming
Shiny

Shiny est le framework de R pour créer des applications web interactives — sans HTML, CSS ni JavaScript. Découvrez ce qu’est Shiny, le modèle mental ui + server + réactivité, à quoi ressemble une application minimale, quand l’utiliser et où l’héberger.

Date de publication

28 juin 2026

Modifié

7 juillet 2026

AstucePoints clés
  • Shiny transforme du code R en application web. Vous écrivez du R ; Shiny produit le HTML, le CSS et le JavaScript — aucune compétence en développement web n’est nécessaire.
  • Chaque application a deux parties : un ui (ce que l’utilisateur voit) et un server (le R qui répond), reliés par shinyApp().
  • La réactivité est le moteur. Quand une entrée change, Shiny recalcule uniquement les sorties qui en dépendent — automatiquement, sans bouton d’actualisation.
  • Tournez-vous vers Shiny quand les utilisateurs ont besoin d’interagir — modifier un paramètre, filtrer, téléverser un fichier. Pour un rapport figé, un document statique est plus simple.
  • Une application tourne partout où R tourne : votre ordinateur portable pendant que vous la construisez, puis shinyapps.io, Posit Connect ou ShinyProxy pour la partager.

Introduction

Vous avez une analyse en R — un modèle, un graphique, un tableau de synthèse — et quelqu’un qui ne sait pas ouvrir R doit l’utiliser. Cette personne veut changer la plage de dates, choisir un autre groupe ou téléverser son propre fichier et voir le résultat. Un PDF statique ne peut pas faire cela. Lui envoyer votre script par e-mail, c’est pire.

Shiny est la réponse. C’est un package R qui vous permet de créer une application web interactive à partir de votre code R : l’utilisateur ouvre une URL, déplace un curseur ou choisit dans une liste déroulante, et votre R recalcule la sortie sous ses yeux. Vous ne quittez jamais R — Shiny génère la page web à votre place.

Cette leçon explique ce qu’est Shiny, le modèle mental qui sous-tend chaque application, à quoi ressemble la plus petite application fonctionnelle, et quand Shiny est (ou n’est pas) le bon outil. C’est la porte d’entrée vers le reste de la série Fondations de Shiny.

Ce qu’est Shiny

Shiny est un package R open source, créé par Posit (anciennement RStudio), pour créer des applications web interactives directement à partir de R. Installez-le une fois :

install.packages("shiny")

L’essentiel, c’est la partie que vous n’écrivez pas. Une application web classique a besoin d’un front-end (HTML, CSS, JavaScript) et d’un back-end (un langage serveur), plus la plomberie pour les relier. Shiny réduit tout cela à du R : vous décrivez la page et la logique avec des fonctions R, et Shiny génère une vraie page web et exécute votre R derrière elle. Votre code d’analyse existant — lm(), ggplot2, dplyr, tout ce que vous utilisez déjà — fonctionne dans une application sans modification.

Le modèle mental : ui + server + réactivité

Chaque application Shiny repose sur trois idées. Maîtrisez-les et le reste n’est que détail.

1. Le ui — ce que l’utilisateur voit. Une fonction qui dispose la page : les entrées (curseurs, listes déroulantes, champs de texte, téléversements de fichiers) et les emplacements de sortie (un graphique ici, un tableau là). C’est la forme de l’application, sans aucune logique.

2. Le server — ce que fait R. Une fonction qui lit les entrées et construit les sorties. C’est là que vit votre analyse. Elle reçoit un objet input (les valeurs courantes de chaque contrôle) et écrit dans un objet output (les éléments que le ui affiche).

3. La réactivité — le ciment. C’est ce qui donne vie à Shiny. Vous n’écrivez jamais « quand le curseur bouge, redessine le graphique ». Au lieu de cela, la sortie du server dépend de input$bins, et Shiny le remarque. Déplacez le curseur et Shiny réexécute automatiquement uniquement le code qui lit input$bins — rien d’autre. Pas de gestionnaires d’événements, pas de bouton d’actualisation, aucun câblage manuel.

# The shape of every Shiny app
library(shiny)

ui <- fluidPage(
  # inputs and output slots go here
)

server <- function(input, output, session) {
  # read input$..., write output$...
}

shinyApp(ui = ui, server = server)

shinyApp() relie les deux moitiés et lance l’application. Enregistrez ceci sous app.R et vous avez une application exécutable — c’est tout le contrat.

Une application minimale

Voici une application complète et fonctionnelle : un curseur contrôle le nombre de classes d’un histogramme, et le graphique se redessine tout seul dès que vous le déplacez. Elle utilise le jeu de données intégré faithful de R (temps d’attente entre éruptions), elle tourne donc avec pour seule installation le package shiny.

Le ui déclare une entrée — un curseur nommé "bins" — et un emplacement de sortie pour un graphique nommé "distPlot" :

library(shiny)

ui <- fluidPage(
  titlePanel("Old Faithful eruptions"),
  sidebarLayout(
    sidebarPanel(
      sliderInput("bins", "Number of bins:",
                  min = 1, max = 50, value = 30)
    ),
    mainPanel(
      plotOutput("distPlot")
    )
  )
)

Le server remplit cet emplacement. renderPlot() enveloppe le code de tracé ; comme ce code lit input$bins, Shiny le réexécute à chaque changement du curseur — et seulement alors :

server <- function(input, output, session) {
  output$distPlot <- renderPlot({
    x    <- faithful$waiting
    bins <- seq(min(x), max(x), length.out = input$bins + 1)
    hist(x, breaks = bins, col = "#3a86d4", border = "white",
         xlab = "Waiting time to next eruption (min)",
         main = "")
  })
}

Remarquez l’appariement : l’identifiant de sortie "distPlot" dans plotOutput() correspond à output$distPlot dans le server, et l’identifiant d’entrée "bins" dans sliderInput() correspond à input$bins. Ce nommage est toute la connexion — Shiny suit la dépendance à votre place. Reliez les moitiés et lancez :

shinyApp(ui = ui, server = server)

Collez les trois blocs dans un seul fichier app.R et exécutez-le en local avec shiny::runApp() (ou cliquez sur Run App dans RStudio). Déplacez le curseur ; l’histogramme se redessine de lui-même. C’est ça, la réactivité.

NoteCopiez n’importe quel bloc et exécutez-le en local

Le code de cette page n’est pas exécuté ici — une application Shiny a besoin d’une session R active, elle ne peut donc pas tourner dans une page web statique. Copiez n’importe quel bloc dans un fichier app.R et exécutez-le en local avec shiny::runApp() (ou Run App dans RStudio) pour le voir fonctionner. Chaque exemple est autonome et n’utilise que des données intégrées.

Quand utiliser Shiny

Shiny est le bon outil quand l’utilisateur a besoin de faire quelque chose, pas seulement de lire. C’est surdimensionné quand il n’en a pas besoin.

Votre collègue a besoin de… Tournez-vous vers
Lire une analyse figée une fois Un rapport statique — Quarto / R Markdown (HTML ou PDF)
Modifier des paramètres et réexécuter votre analyse Shiny
Téléverser ses propres données et obtenir votre résultat Shiny
Explorer un jeu de données finalisé avec des graphiques par glisser-déposer Un outil de BI (Power BI, Tableau)
Intégrer un modèle statistique personnalisé dans un outil interactif Shiny

La ligne de partage, c’est l’interactivité sur de la logique R. Si la valeur tient dans « laisser les gens piloter mon analyse R », Shiny l’emporte — il parle R nativement, donc vos modèles, tests et figures ggplot2 s’y intègrent directement. Si la valeur tient dans « publier un document figé », un rapport statique est plus simple et plus rapide à charger. Si c’est « laisser des non-codeurs construire leurs propres tableaux de bord à partir d’une table propre », un outil de BI convient généralement mieux que de construire cela vous-même.

Où tourne une application Shiny

Une application Shiny a besoin d’un processus R actif derrière elle, donc « déployer » signifie placer R quelque part qu’un navigateur peut atteindre. Pendant que vous la construisez, elle tourne sur votre propre machine (runApp() la sert à une URL locale). Pour la partager :

  • shinyapps.io — le service hébergé de Posit. Un palier gratuit met une vraie application sur le web public en quelques clics ; le moyen le plus simple de mettre en ligne votre première application.
  • Posit Connect — un serveur commercial pour les équipes : planification, contrôle d’accès et déploiement géré.
  • ShinyProxy — un hébergement open source basé sur Docker qui exécute chaque session dans son propre conteneur ; courant dans les environnements auto-hébergés et réglementés.

Choisir et configurer ces options, c’est le travail de la série production. Pour les fondations, retenez que le même app.R tourne dans toutes — vous construisez une fois et choisissez où il vit. (Les séries architecture, performance et déploiement en production s’appuient sur ces fondations.)

Problèmes fréquents

« Could not find function fluidPage » — le package shiny n’est pas chargé. Ajoutez library(shiny) en haut de app.R, et installez-le d’abord avec install.packages("shiny").

L’application s’ouvre mais rien ne se met à jour quand je déplace un contrôle. L’identifiant d’entrée et le code qui le lit ne correspondent pas. Une entrée déclarée par sliderInput("bins", …) se lit avec input$bins — exactement le même nom. De même, une sortie plotOutput("distPlot") est remplie par output$distPlot. Une faute de frappe dans l’un ou l’autre identifiant rompt silencieusement le lien.

Mon code de tracé/modèle fonctionne dans la console mais provoque une erreur dans l’application. Le code qui construit une sortie doit vivre à l’intérieur d’une fonction render*() (renderPlot({ … }), renderTable({ … })). Du code placé librement dans le corps du server s’exécute une seule fois au démarrage et ne peut pas réagir aux entrées.

Questions fréquentes

Shiny sert à transformer une analyse R en application web interactive — un tableau de bord, un explorateur de données ou un outil qui permet à des non-codeurs de modifier des paramètres, de filtrer des données ou de téléverser un fichier et de voir votre résultat généré par R dans un navigateur. C’est ainsi que les analyses R sont partagées avec des personnes qui n’utilisent pas R.

Non. Vous écrivez l’application entièrement en R, et Shiny génère le HTML, le CSS et le JavaScript à votre place. Les compétences web permettent de personnaliser davantage l’apparence, mais elles ne sont pas requises pour construire et mettre en ligne une application utile.

Le ui (interface utilisateur) définit ce que l’utilisateur voit — les entrées et les emplacements de sortie — et le server définit la logique R qui lit ces entrées et construit les sorties. shinyApp(ui, server) les réunit en une application exécutable.

La réactivité est le système de mise à jour automatique de Shiny : une sortie déclare de quelles entrées elle dépend (en lisant input$...), et Shiny réexécute le code de cette sortie chaque fois qu’une de ces entrées change — et rien d’autre. Vous n’écrivez jamais vous-même le câblage « quand X change, fais Y ».

Utilisez Shiny quand vous avez besoin d’analytique personnalisée ou d’intégrer un modèle R/une méthode statistique dans un outil interactif ; il vous donne un contrôle total parce que la logique est du R. Utilisez un outil de BI quand des utilisateurs non techniques ont besoin de construire leurs propres tableaux de bord par glisser-déposer à partir d’une table propre et que vous n’avez pas besoin de code personnalisé.

Testez vos connaissances

Reprenez l’application minimale de cette leçon. Sans remonter, répondez :

  1. Quelle fonction déclare le curseur, et quel est son identifiant d’entrée ?
  2. Quel nom output$... le server doit-il utiliser pour remplir l’emplacement plotOutput("distPlot") ?
  3. Pourquoi l’histogramme se redessine-t-il quand vous déplacez le curseur, alors que vous n’avez jamais écrit d’instruction « redessiner » ?

Regardez les identifiants — les chaînes passées à sliderInput() et plotOutput(). Le server fait référence aux mêmes noms via input$ et output$. Pour (3), réfléchissez à ce que lit renderPlot().

  1. sliderInput("bins", …) déclare le curseur ; son identifiant d’entrée est "bins", lu avec input$bins.
  2. Le server doit affecter à output$distPlot — le nom doit correspondre à l’identifiant dans plotOutput("distPlot").
  3. Le code de tracé à l’intérieur de renderPlot() lit input$bins. Cela rend la sortie dépendante du curseur, donc le système réactif de Shiny la réexécute automatiquement chaque fois que la valeur du curseur change.

Quelle affirmation à propos de Shiny est correcte ?

A. Vous devez écrire du HTML et du JavaScript pour construire l’interface utilisateur. B. Le ui contient la logique d’analyse et le server contient la mise en page. C. La réactivité signifie que Shiny réexécute le code d’une sortie quand une entrée qu’elle lit change. D. Une application Shiny ne peut tourner que sur shinyapps.io.

C. La réactivité réexécute automatiquement le code d’une sortie quand une entrée dont elle dépend change. A est faux — Shiny génère le code web à votre place. B est inversé — le ui est la mise en page, le server est la logique. D est faux — une application tourne en local et sur plusieurs hébergeurs (shinyapps.io, Posit Connect, ShinyProxy).

Conclusion

Shiny transforme R en framework web : un ui décrit la page, un server contient votre logique R, et la réactivité maintient les sorties synchronisées avec les entrées — automatiquement. Ce modèle en trois parties est toute la fondation, et vous l’avez déjà vu dans une application complète et fonctionnelle. Ensuite, configurez votre environnement et construisez-en une de zéro.

Leçons connexes

Cette page vous a-t-elle été utile ?

Recevez les nouvelles leçons R & Python par e-mail

Pratique, reproductible, sans spam. Désinscription à tout moment.

Double opt-in. Nous ne partageons jamais votre e-mail.

Partager cette pageXLinkedInRedditHN

Réutilisation

Citation

BibTeX
@online{2026,
  author = {},
  title = {Qu’est-ce que Shiny en R\,? Créer des applications web
    interactives à partir de code R},
  date = {2026-06-28},
  url = {https://www.datanovia.com/learn/programming/shiny/foundations/what-is-shiny},
  langid = {fr}
}
Veuillez citer ce travail comme suit :
“Qu’est-ce que Shiny en R ? Créer des applications web interactives à partir de code R.” 2026. June 28. https://www.datanovia.com/learn/programming/shiny/foundations/what-is-shiny.