Scaffold Shiny App

Crear una nueva aplicación Shiny con estructura lista para producción usando scaffolding de golem, rhino o vanilla.

Cuándo Usar

• Al iniciar una nueva aplicación web interactiva en R
• Al crear un prototipo de panel o explorador de datos
• Al configurar una aplicación Shiny de producción como paquete R (golem)
• Al arrancar un proyecto Shiny empresarial (rhino)

Entradas

• Requerido: Nombre de la aplicación
• Requerido: Elección del framework (golem, rhino o vanilla)
• Opcional: Si incluir scaffolding de módulos (predeterminado: sí)
• Opcional: Si usar renv para gestión de dependencias (predeterminado: sí)
• Opcional: Destino de despliegue (shinyapps.io, Posit Connect, Docker)

Procedimiento

Paso 1: Elegir el Framework

Evalúa los requisitos del proyecto para seleccionar el framework apropiado:

Framework	Mejor Para	Estructura
golem	Apps de producción distribuidas como paquetes R	Paquete R con DESCRIPTION, tests, viñetas
rhino	Apps empresariales con pipeline de compilación JS/CSS	Módulos box, Sass, bundling JS, rhino::init()
vanilla	Prototipos rápidos y aprendizaje	Un solo app.R o par ui.R/server.R

Esperado: Decisión clara de framework basada en el alcance del proyecto y las necesidades del equipo.

En caso de fallo: Si no estás seguro, usa golem por defecto — proporciona la mayor estructura y se puede simplificar más adelante. Vanilla solo es apropiado para prototipos desechables.

Paso 2: Crear el Scaffolding del Proyecto

Camino Golem

golem::create_golem("myapp", package_name = "myapp")

Esto crea:

myapp/
├── DESCRIPTION
├── NAMESPACE
├── R/
│   ├── app_config.R
│   ├── app_server.R
│   ├── app_ui.R
│   └── run_app.R
├── dev/
│   ├── 01_start.R
│   ├── 02_dev.R
│   ├── 03_deploy.R
│   └── run_dev.R
├── inst/
│   ├── app/www/
│   └── golem-config.yml
├── man/
├── tests/
│   ├── testthat.R
│   └── testthat/
└── vignettes/

Camino Rhino

rhino::init("myapp")

Esto crea:

myapp/
├── app/
│   ├── js/
│   ├── logic/
│   ├── static/
│   ├── styles/
│   ├── view/
│   └── main.R
├── tests/
│   ├── cypress/
│   └── testthat/
├── .github/
├── app.R
├── dependencies.R
├── rhino.yml
└── renv.lock

Camino Vanilla

Crea

app.R

:

library(shiny)
library(bslib)

ui <- page_sidebar(
  title = "My App",
  sidebar = sidebar(
    sliderInput("n", "Sample size", 10, 1000, 100)
  ),
  card(
    card_header("Output"),
    plotOutput("plot")
  )
)

server <- function(input, output, session) {
  output$plot <- renderPlot({
    hist(rnorm(input$n), main = "Random Normal")
  })
}

shinyApp(ui, server)

Esperado: Directorio del proyecto creado con todos los archivos de scaffolding.

En caso de fallo: Para golem, asegúrate de que el paquete golem esté instalado:

install.packages("golem")

. Para rhino, instala desde GitHub:

remotes::install_github("Appsilon/rhino")

. Para vanilla, asegúrate de que shiny y bslib estén instalados.

Paso 3: Configurar las Dependencias

Golem/Vanilla

# Inicializar renv
renv::init()

# Añadir dependencias principales
usethis::use_package("shiny")
usethis::use_package("bslib")
usethis::use_package("DT")         # si se usan tablas de datos
usethis::use_package("plotly")     # si se usan gráficos interactivos

# Capturar estado
renv::snapshot()

Rhino

Las dependencias se gestionan en

dependencies.R

:

# dependencies.R
library(shiny)
library(bslib)
library(DT)

Esperado: Todas las dependencias registradas en DESCRIPTION (golem) o dependencies.R (rhino) y bloqueadas con renv.

En caso de fallo: Si renv::init() falla, verifica los permisos de escritura. Si los paquetes no se instalan, verifica la compatibilidad de la versión de R.

Paso 4: Crear el Primer Módulo

Golem

golem::add_module(name = "dashboard", with_test = TRUE)

Esto crea

R/mod_dashboard.R

y

tests/testthat/test-mod_dashboard.R

.

Rhino

Crea

app/view/dashboard.R

:

box::use(
  shiny[moduleServer, NS, tagList, h3, plotOutput, renderPlot],
)

#' @export
ui <- function(id) {
  ns <- NS(id)
  tagList(
    h3("Dashboard"),
    plotOutput(ns("plot"))
  )
}

#' @export
server <- function(id) {
  moduleServer(id, function(input, output, session) {
    output$plot <- renderPlot({
      plot(1:10)
    })
  })
}

Vanilla

Añade las funciones del módulo a un archivo separado

R/mod_dashboard.R

:

dashboardUI <- function(id) {
  ns <- NS(id)
  tagList(
    h3("Dashboard"),
    plotOutput(ns("plot"))
  )
}

dashboardServer <- function(id) {
  moduleServer(id, function(input, output, session) {
    output$plot <- renderPlot({
      plot(1:10)
    })
  })
}

Esperado: Archivo de módulo creado con funciones UI y server usando el espacio de nombres correcto.

En caso de fallo: Asegúrate de que el módulo use

NS(id)

para todos los IDs de input/output en la función UI. Sin el espacio de nombres, los IDs colisionarán cuando el módulo se use varias veces.

Paso 5: Ejecutar la Aplicación

# Golem
golem::run_dev()

# Rhino
shiny::runApp()

# Vanilla
shiny::runApp("app.R")

Esperado: La aplicación se lanza en el navegador sin errores.

En caso de fallo: Revisa la consola de R para ver mensajes de error. Problemas comunes: paquetes faltantes (instálalos), puerto ya en uso (especifica un puerto diferente con

port = 3839

), o errores de sintaxis en el código UI/server.

Validación

• El directorio de la aplicación tiene la estructura correcta para el framework elegido

• shiny::runApp()

  se lanza sin errores
• Al menos un módulo está creado con funciones UI y server
• Las dependencias están registradas (DESCRIPTION o dependencies.R)
• renv.lock captura todas las versiones de paquetes
• El módulo usa

  NS(id)

  para aislamiento correcto del espacio de nombres

Errores Comunes

• Elegir vanilla para producción: La estructura vanilla carece de infraestructura de tests, documentación y herramientas de despliegue. Usa golem o rhino para cualquier cosa más allá de prototipos.
• Espacio de nombres faltante en módulos: Cada

  inputId

  y

  outputId

  en la UI de un módulo debe estar envuelto con

  ns()

  . Olvidarlo provoca colisiones silenciosas de IDs.
• golem sin flujo de trabajo devtools: Las apps golem son paquetes R. Usa

  devtools::load_all()

  ,

  devtools::test()

  y

  devtools::document()

  — no

  source()

  .
• rhino sin box: rhino usa box para importaciones de módulos. No uses llamadas

  library()

  — usa

  box::use()

  para importaciones explícitas.

Habilidades Relacionadas

• build-shiny-module

  — crear módulos Shiny reutilizables con aislamiento correcto del espacio de nombres

• test-shiny-app

  — configurar tests de shinytest2 y testServer()

• deploy-shiny-app

  — desplegar en shinyapps.io, Posit Connect o Docker

• design-shiny-ui

  — temas bslib y diseño de layout responsivo

• create-r-package

  — scaffolding de paquetes R (las apps golem son paquetes R)

• manage-renv-dependencies

  — gestión detallada de dependencias renv