Brilhante no Servidor RStudio hospedado

Shiny é um pacote R, disponível em CRAN, usado para construir aplicações R interativas e dashboards. Pode utilizar o Servidor Shiny dentro do RStudio hospedado nos clusters Azure Databricks.

Para começar com Shiny, veja os tutoriais shiny.

Este artigo descreve como executar aplicações Shiny no RStudio em Azure Databricks e usar Apache Spark dentro de aplicações Shiny.

Requisitos

Importante

Com o RStudio Server Pro, deve desativar a autenticação em proxima. Certifique-se de que auth-proxy=1 não está presente no interior /etc/rstudio/rserver.conf .

Começar com Shiny

  1. Abra o RStudio na Azure Databricks.

  2. No RStudio, importe o pacote Shiny e execute a aplicação de exemplo 01_hello da seguinte forma:

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

    Aparece uma nova janela, exibindo a aplicação Shiny.

    Primeira aplicação Shiny

Executar um aplicativo Shiny a partir de um script R

Para executar uma aplicação Shiny a partir de um script R, abra o script R no editor RStudio e clique no botão 'Executar App' no topo direito.

App de execução shiny

Use Apache Spark dentro de aplicativos Shiny

Pode utilizar o Apache Spark ao desenvolver aplicações Shiny em Azure Databricks. Pode interagir com a Spark usando o SparkR e o sparklyr. Precisas de pelo menos um trabalhador para lançar as tarefas da Spark.

O exemplo a seguir usa o SparkR para lançar empregos spark. O exemplo usa o conjunto de dados de diamantes ggplot2 para traçar o preço dos diamantes por quilate. A gama de quilates pode ser alterada usando o slider na parte superior da aplicação, e a gama do eixo x do enredo mudaria em conformidade.

library(SparkR)
library(sparklyr)
library(dplyr)
library(ggplot2)
sparkR.session()

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)

Aplicativo Spark Shiny

Perguntas Mais Frequentes (FAQ)

Como posso instalar shiny em Databricks Runtime 6.4 Suporte alargado e Databricks Runtime 5.5 LTS?

Instale o pacote Shiny como uma biblioteca Azure Databricks no cluster. A utilização install.packages(‘shiny’) na consola RStudio ou a utilização do gestor de pacotes RStudio pode não funcionar.

Porque é que a minha aplicação Shiny está acinzentada depois de algum tempo?

Se não houver interação com a aplicação Shiny, a ligação à aplicação fecha após cerca de 4 minutos.

Para voltar a ligar, refresque a página de aplicações Shiny. O estado do painel de instrumentos reinicia.

Porque é que a minha janela do espectador brilhante desaparece depois de um tempo?

Se a janela do espectador Shiny desaparecer após a televisão por 2 minutos, deve-se ao mesmo tempo que o cenário "cinza para fora".

A minha aplicação falha imediatamente após o lançamento, mas o código parece estar correto. O que é que se passa?

Existe um limite de 20 MB sobre a quantidade total de dados que podem ser exibidos numa aplicação Shiny em Azure Databricks. Se o tamanho total dos dados da aplicação exceder este limite, este despenhar-se-á imediatamente após o lançamento. Para evitar isto, a Databricks recomenda a redução do tamanho dos dados, por exemplo, reduzindo os dados apresentados ou reduzindo a resolução de imagens.

Por que os trabalhos de faísca nunca voltam?

Isto também é por causa do tempo limite. Qualquer trabalho de Spark a funcionar por mais tempo do que os intervalos anteriormente mencionados não é capaz de apresentar o seu resultado porque a ligação fecha antes do retorno do trabalho.

Como posso evitar o tempo?

  • Há uma solução alternativa sugerida neste fio de edição. A solução envia batimentos cardíacos para manter o websocket vivo quando a aplicação está inativa. No entanto, se a aplicação for bloqueada por um computamento de longa duração, esta solução não funciona.

  • Shiny não suporta tarefas de longa duração. Uma publicação de blogue Shiny recomenda o uso de promessas e futuros para executar tarefas longas e manter a app desbloqueada. Aqui está um exemplo que usa batimentos cardíacos para manter a app Shiny viva, e executa um longo trabalho de Spark numa future construção.

    # 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)
    

Databricks recomenda até 20.

Posso usar uma versão diferente do pacote Shiny do que a instalada no Databricks Runtime?

Sim. Consulte a versão dos pacotes R.

Como posso desenvolver uma aplicação Shiny que pode ser publicada num servidor Shiny e aceder a dados de dados do Azure Databricks?

Embora possa aceder a dados naturalmente usando o SparkR ou o sparklyr durante o desenvolvimento e teste em Azure Databricks, depois de uma aplicação Shiny ser publicada num serviço de hospedagem autónoma, não pode aceder diretamente aos dados e tabelas em Azure Databricks.

Para ativar a sua aplicação para funcionar fora do Azure Databricks, tem de reescrever a forma como acede aos dados. Existem algumas opções:

  • Utilize jDBC/ODBC para submeter consultas a um cluster Azure Databricks.
  • Utilize databricks Connect.
  • Aceda diretamente aos dados sobre o armazenamento de objetos.

A Databricks recomenda que trabalhe com a sua equipa de soluções Azure Databricks para encontrar a melhor abordagem para a sua arquitetura de dados e análise existente.

Como posso salvar as aplicações Shiny que desenvolvo no Azure Databricks?

Pode guardar o seu código de aplicação no DBFS através do suporte FUSE ou verificar o seu código no controlo da versão.

Posso desenvolver uma aplicação Shiny dentro de um caderno Azure Databricks?

Sim, pode desenvolver uma aplicação Shiny dentro de um caderno Azure Databricks. Para mais detalhes consulte Use Shiny dentro dos cadernos Databricks.