Shiny sur Databricks

Shiny est un package R, disponible sur CRAN, utilisé pour créer des applications R interactives et des tableaux de bord. Vous pouvez utiliser Shiny dans RStudio Server hébergé sur des clusters Databricks. Vous pouvez également développer, héberger et partager des applications Shiny directement depuis un notebook Databricks.

Pour start avec Shiny, consultez les didacticiels Shiny. Vous pouvez exécuter ces didacticiels sur des Notebooks Databricks.

Cet article décrit comment exécuter des applications Shiny sur Databricks et utiliser Apache Spark au sein des applications Shiny.

Shiny dans les Notebook R

Le package Shiny est inclus avec Databricks Runtime. Vous pouvez développer et tester de manière interactive des applications Shiny dans les notebooks R Databricks, comme avec RStudio hébergé.

Bien démarrer avec Shiny dans les notebooks R

Suivez ces étapes pour commencer :

1. Créer un notebook R.

2. Importez le package Shiny et exécutez l'application exemple 01_hello comme suit :

   R

     library(shiny)
     runExample("01_hello")

3. Lorsque l'application est prête, la sortie inclut l'URL de l'application Shiny comme Link cliquable qui ouvre un nouveau tab. Pour partager cette application avec d'autres utilisateurs, consultez Partager l'URL de l'application Shiny.

   

remarque

• Les messages de Logs apparaissent dans le résultat de la commande, comme le message de log default (Listening on http://0.0.0.0:5150) affiché dans l'exemple.
• Pour arrêter l'application Shiny, cliquez sur **Annuler**.
• L'application Shiny utilise le processus R du Notebook. Si vous détachez le Notebook du cluster, ou si vous annulez l'exécution de la cellule de l'application, l'application Shiny se termine. Vous ne pouvez pas exécuter d'autres cellules tant que l'application Shiny est en cours d'exécution.

Exécuter les applications Shiny à partir des dossiers Git Databricks

Vous pouvez exécuter des applications Shiny qui sont intégrées dans les dossiers Git Databricks.

1. Cloner un Git repository distant.

2. Exécutez l’application.

   R

   library(shiny)
   runApp("006-tabsets")

Exécuter les applications Shiny à partir de fichiers

Si votre code d'application Shiny fait partie d'un projet géré par le contrôle de version, vous pouvez l'exécuter dans le Notebook.

remarque

Vous devez utiliser le chemin absolu ou définir le répertoire de travail avec setwd().

1. Extrayez le code d'un repository en utilisant un code similaire à :

     %sh git clone https://github.com/rstudio/shiny-examples.git
     cloning into 'shiny-examples'...

2. Pour exécuter l'application, saisissez un code similaire à ce qui suit dans une autre cellule :

   R

   library(shiny)
   runApp("/databricks/driver/shiny-examples/007-widgets/")

Partager l'URL de l'application Shiny

L'URL de l'application Shiny générée lorsque vous start une application est partageable avec d'autres utilisateurs. Tout utilisateur Databricks disposant de l'autorisation CAN ATTACH TO sur le cluster peut afficher et interagir avec l'application tant que l'application et le cluster sont en cours d'exécution.

Si le cluster sur lequel l'application s'exécute s'arrête, l'application n'est plus accessible. Vous pouvez désactiver l'arrêt automatique dans les paramètres du cluster.

Si vous associez et exécutez le Notebook hébergeant l'application Shiny sur un cluster différent, l'URL Shiny change. De plus, si vous redémarrez l'application sur le même cluster, Shiny pourrait choisir un port aléatoire différent. Pour garantir une URL stable, vous pouvez définir l'option shiny.port ou, lors du redémarrage de l'application sur le même cluster, vous pouvez spécifier l'argument port.

Shiny sur RStudio Server hébergé

important

RStudio Server hébergé par Databricks est obsolète et n'est disponible que sur les versions 15,4 et antérieures de Databricks Runtime. Pour d'autres options, consultez Alternatives à RStudio Server hébergé.

Exigences

• RStudio Server hébergé.

important

Avec RStudio Server Pro, vous devez désactiver l'authentification par proxy. Assurez-vous que auth-proxy=1 n'est pas présent dans /etc/rstudio/rserver.conf.

Get start

1. Ouvrir RStudio sur Databricks.

2. Dans RStudio, importez le package Shiny et exécutez l’exemple d’application 01_hello comme suit :

   R

   > library(shiny)
   > runExample("01_hello")
   
   Listening on http://127.0.0.1:3203

   Une nouvelle fenêtre apparaît, affichant l'application Shiny.

   

Exécuter une application Shiny à partir d'un script R

Pour exécuter une application Shiny à partir d'un script R, ouvrez le script R dans l'éditeur RStudio et cliquez sur le bouton Run App en haut à droite.

Utiliser Apache Spark dans les applications Shiny

Vous pouvez utiliser Apache Spark dans les applications Shiny avec SparkR ou sparklyr.

Utilisez SparkR avec Shiny dans un Notebook

important

SparkR dans Databricks est obsolète dans Databricks Runtime 16.0 et versions supérieures.

R

library(shiny)
library(SparkR)
sparkR.session()

ui <- fluidPage(
  mainPanel(
    textOutput("value")
  )
)

server <- function(input, output) {
  output$value <- renderText({ nrow(createDataFrame(iris)) })
}

shinyApp(ui = ui, server = server)

Utiliser sparklyr avec Shiny dans un Notebook

R

library(shiny)
library(sparklyr)

sc <- spark_connect(method = "databricks")

ui <- fluidPage(
  mainPanel(
    textOutput("value")
  )
)

server <- function(input, output) {
  output$value <- renderText({
    df <- sdf_len(sc, 5, repartition = 1) %>%
      spark_apply(function(e) sum(e)) %>%
      collect()
    df$result
  })
}

shinyApp(ui = ui, server = server)

R

library(dplyr)
library(ggplot2)
library(shiny)
library(sparklyr)

sc <- spark_connect(method = "databricks")
diamonds_tbl <- spark_read_csv(sc, path = "/databricks-datasets/Rdatasets/data-001/csv/ggplot2/diamonds.csv")

# Define the UI
ui <- fluidPage(
  sliderInput("carat", "Select Carat Range:",
              min = 0, max = 5, value = c(0, 5), step = 0.01),
  plotOutput('plot')
)

# Define the server code
server <- function(input, output) {
  output$plot <- renderPlot({
    # Select diamonds in carat range
    df <- diamonds_tbl %>%
      dplyr::select("carat", "price") %>%
      dplyr::filter(carat >= !!input$carat[[1]], carat <= !!input$carat[[2]])

    # Scatter plot with smoothed means
    ggplot(df, aes(carat, price)) +
      geom_point(alpha = 1/2) +
      geom_smooth() +
      scale_size_area(max_size = 2) +
      ggtitle("Price vs. Carat")
  })
}

# Return a Shiny app object
shinyApp(ui = ui, server = server)

Questions fréquemment posées (FAQ)

• Pourquoi mon application Shiny est-elle grisée après un certain temps ?
• Pourquoi ma fenêtre d'affichage Shiny disparaît-elle après un certain temps ?
• Pourquoi les Jobs Spark longs ne se terminent-ils jamais ?
• Comment puis-je éviter le délai d'expiration ?
• Mon application plante immédiatement après le lancement, mais le code semble correct. Que se passe-t-il ?
• Combien de connexions peuvent être acceptées pour un Link d'application Shiny pendant le développement ?
• Puis-je utiliser une version différente du package Shiny que celle installée dans Databricks Runtime ?
• Comment puis-je développer une application Shiny qui peut être publiée sur un serveur Shiny et accéder aux données sur Databricks ?
• Puis-je développer une application Shiny dans un Notebook Databricks ?
• Comment puis-je enregistrer les applications Shiny que j'ai développées sur le serveur RStudio hébergé ?

Pourquoi mon application Shiny est-elle grisée après un certain temps ?

S'il n'y a pas d'interaction avec l'application Shiny, la connexion à l'application se ferme après environ 10 minutes.

Pour vous reconnecter, refresh la page de l'application Shiny. L'état du tableau de bord se Reset.

Pourquoi ma fenêtre de visionneur Shiny disparaît-elle après un certain temps ?

Si la fenêtre d'affichage Shiny disparaît après être restée inactive pendant plusieurs minutes, cela est dû au même délai d'attente que le scénario de « grisonnement ».

Pourquoi les jobs Spark longs ne retournent-ils jamais ?

Cela est également dû au délai d’expiration d’inactivité. Tout job Spark s’exécutant plus longtemps que les délais mentionnés précédemment ne peut pas afficher son résultat, car la connexion se ferme avant que le job ne revienne.

Comment puis-je éviter le délai d'expiration ?

• Une solution de contournement est suggérée dans Demande de fonctionnalité : demander au client d’envoyer un message Keep-Alive pour empêcher le délai d’expiration TCP sur certains équilibreurs de charge sur Github. La solution de contournement envoie des signaux de pulsation pour maintenir la connexion WebSocket active lorsque l’application est inactive. Toutefois, si l’application est bloquée par un calcul de longue durée, cette solution de contournement ne fonctionne pas.

• Shiny ne prend pas en charge les tâches de longue durée. Un billet de blog Shiny recommande d’utiliser les promises and futures pour exécuter des tâches longues de manière asynchrone et maintenir l’application débloquée. Voici un exemple qui utilise des signaux de vie pour maintenir l'application Shiny active, et exécute un job Spark de longue durée dans une construction future.

  R

  # Write an app that uses spark to access data on Databricks
  # First, install the following packages:
  install.packages('future')
  install.packages('promises')
  
  library(shiny)
  library(promises)
  library(future)
  plan(multisession)
  
  HEARTBEAT_INTERVAL_MILLIS = 1000  # 1 second
  
  # Define the long Spark job here
  run_spark <- function(x) {
    # Environment setting
    library("SparkR", lib.loc = "/databricks/spark/R/lib")
    sparkR.session()
  
    irisDF <- createDataFrame(iris)
    collect(irisDF)
    Sys.sleep(3)
    x + 1
  }
  
  run_spark_sparklyr <- function(x) {
    # Environment setting
    library(sparklyr)
    library(dplyr)
    library("SparkR", lib.loc = "/databricks/spark/R/lib")
    sparkR.session()
    sc <- spark_connect(method = "databricks")
  
    iris_tbl <- copy_to(sc, iris, overwrite = TRUE)
    collect(iris_tbl)
    x + 1
  }
  
  ui <- fluidPage(
    sidebarLayout(
      # Display heartbeat
      sidebarPanel(textOutput("keep_alive")),
  
      # Display the Input and Output of the Spark job
      mainPanel(
        numericInput('num', label = 'Input', value = 1),
        actionButton('submit', 'Submit'),
        textOutput('value')
      )
    )
  )
  server <- function(input, output) {
    #### Heartbeat ####
    # Define reactive variable
    cnt <- reactiveVal(0)
    # Define time dependent trigger
    autoInvalidate <- reactiveTimer(HEARTBEAT_INTERVAL_MILLIS)
    # Time dependent change of variable
    observeEvent(autoInvalidate(), {  cnt(cnt() + 1)  })
    # Render print
    output$keep_alive <- renderPrint(cnt())
  
    #### Spark job ####
    result <- reactiveVal() # the result of the spark job
    busy <- reactiveVal(0)  # whether the spark job is running
    # Launch a spark job in a future when actionButton is clicked
    observeEvent(input$submit, {
      if (busy() != 0) {
        showNotification("Already running Spark job...")
        return(NULL)
      }
      showNotification("Launching a new Spark job...")
      # input$num must be read outside the future
      input_x <- input$num
      fut <- future({ run_spark(input_x) }) %...>% result()
      # Or: fut <- future({ run_spark_sparklyr(input_x) }) %...>% result()
      busy(1)
      # Catch exceptions and notify the user
      fut <- catch(fut, function(e) {
        result(NULL)
        cat(e$message)
        showNotification(e$message)
      })
      fut <- finally(fut, function() { busy(0) })
      # Return something other than the promise so shiny remains responsive
      NULL
    })
    # When the spark job returns, render the value
    output$value <- renderPrint(result())
  }
  shinyApp(ui = ui, server = server)

• Il y a une limite stricte de 12 heures depuis le chargement initial de la page, après quoi toute connexion, même si elle est active, sera interrompue. Vous devez refresh l'application Shiny pour vous reconnecter dans ces cas. Cependant, la connexion WebSocket sous-jacente peut se fermer à tout moment en raison de divers facteurs, notamment l'instabilité du réseau ou le mode veille de l'ordinateur. Databricks recommande de réécrire les applications Shiny de manière à ce qu'elles ne nécessitent pas une connexion persistante et ne dépendent pas excessivement de l'état de session.

Mon application plante immédiatement après le lancement, mais le code semble correct. Que se passe-t-il ?

Il existe une limite de 50 Mo sur la quantité totale de données pouvant être affichées dans une application Shiny sur Databricks. Si la taille totale des données de l'application dépasse cette limite, elle se bloquera immédiatement après le lancement. Pour éviter cela, Databricks recommande de réduire la taille des données, par exemple en sous-échantillonnant les données affichées ou en réduisant la résolution des images.

Combien de connexions peuvent être acceptées pour un Link d'application Shiny pendant le développement ?

Databricks recommande jusqu'à 20.

Puis-je utiliser une version du package Shiny différente de celle installée dans Databricks Runtime ?

Oui. Consultez Corriger la version des packages R.

Comment développer une application Shiny qui peut être publiée sur un serveur Shiny et accéder aux données sur Databricks ?

Bien que vous puissiez accéder naturellement aux données à l'aide de SparkR ou de sparklyr pendant le développement et les tests sur Databricks, une fois qu'une application Shiny est publiée sur un service d'hébergement autonome, elle ne peut pas accéder directement aux données et aux tables sur Databricks.

Pour permettre à votre application de fonctionner en dehors de Databricks, vous devez réécrire la façon dont vous accédez aux données. Il existe quelques options :

• Utilisez JDBC/ODBC pour soumettre des queries à un cluster Databricks.
• Use Databricks Connect.
• Accédez directement aux données sur le stockage d'objets.

Databricks vous recommande de travailler avec votre équipe de solutions Databricks pour trouver la meilleure approche pour votre architecture de données et d'analytique existante.

Puis-je développer une application Shiny dans un notebook Databricks ?

Oui, vous pouvez développer une application Shiny dans un Notebook Databricks.

Comment puis-je enregistrer les applications Shiny que j'ai développées sur un serveur RStudio hébergé ?

Vous pouvez soit enregistrer votre code d'application sur DBFS, soit enregistrer votre code dans le contrôle de version.