R Academy · leksjon

Distribuere Shiny-apper

Publiser apper til shinyapps.io, Shiny Server og Docker-baserte miljøer.

Leksjon 4 av 413 trinn

Distribuere Shiny-apper er en gratis leksjon i R Academy på CoddyKit. Dette er leksjon 4 av 4. Du kan lese valgfritt 3 leksjoner fra denne læringsstien gratis i sin helhet – deretter låser CoddyKit PRO opp alle leksjoner, samt praktisk øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i R Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i R Academy inneholder totalt 4 leksjoner.

Oversikt over distribusjonsalternativer

Shiny-apper kan distribueres på flere plattformer, avhengig av budsjett, forventet trafikk og krav til kontroll:

shinyapps.io: Administrert nettskyvert hos Posit – enklest, med gratisnivå tilgjengelig.
Shiny Server (open source): Selvvertet på Linux, gratis.
Posit Connect: Kommersiell løsning på bedriftsnivå som også støtter R Markdown og Plumber.
Docker + rocker/shiny: Maksimal portabilitet og kontroll.

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

Strukturen til app.R for distribusjon

En Shiny-app som skal distribueres, må enten ha én enkelt app.R-fil (som inneholder både ui og server) eller to filer, ui.R og server.R. Alle pakkeavhengigheter må deklareres med library() øverst. Datafiler må ligge i samme katalog eller være tilgjengelige med en relativ sti til appen.

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

rsconnect-pakken håndterer distribusjon til shinyapps.io og Posit Connect. Konfigurer først kontolegitimasjonen, og kall deretter rsconnect::deployApp() fra appkatalogen. Funksjonen pakker automatisk alle R-filer, data og et manifest.

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
)

Konfigurere shinyapps.io

shinyapps.io er den raskeste veien til en offentlig URL. Opprett en gratiskonto på shinyapps.io, kopier tokenet og hemmeligheten fra instrumentpanelet, og kall setAccountInfo(). Gratisnivået tillater 5 apper med 25 aktive timer per måned.

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 kjører på Linux (Ubuntu/RHEL) og leverer Shiny-apper fra katalogen /srv/shiny-server/. Hver underkatalog blir en app på http://server:3838/subdirname/. Den er gratis og støtter et ubegrenset antall samtidige brukere, innenfor serverens kapasitet.

# 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 med rocker/shiny

Docker-imaget rocker/shiny inneholder en forhåndskonfigurert Shiny Server. Monter appkatalogen i containeren for å levere appen umiddelbart. Docker sikrer reproduserbarhet – det samme imaget kjører likt på alle verter.

# 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 for reproduserbare avhengigheter

renv oppretter et pakkenivåbibliotek for prosjektet med en låsefil (renv.lock) som registrerer nøyaktige pakkeversjoner. Ved distribusjon sørger denne låsefilen for at serveren eller Docker-imaget installerer nøyaktig de samme pakkeversjonene som ble brukt under utviklingen.

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

Miljøvariabler for konfigurasjon

Hardkod aldri API-nøkler, databasepassord eller miljøspesifikke innstillinger i appkoden. Bruk miljøvariabler som leses med Sys.getenv('VAR_NAME', unset = NA). Angi dem i .Renviron lokalt og i miljøkonfigurasjonen på vertsplattformen i produksjon.

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

Oversikt over Posit Connect

Posit Connect er en bedriftsplattform for distribusjon av Shiny-apper, R Markdown-dokumenter, Plumber-API-er og mer. Den støtter:

Single Sign-On (SSO) via LDAP eller SAML
Planlagt kjøring av R Markdown-rapporter
Tilgangskontroll på appnivå
Automatisk skalering og lastbalansering

Distribusjon bruker samme arbeidsflyt med rsconnect::deployApp() som 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')

Sjekkliste før distribusjon

Kontroller følgende før De distribuerer en Shiny-app til produksjon:

Alle filstier bruker relative stier, ikke absolutte stier.
Sensitive data (API-nøkler, passord) leses fra miljøvariabler.
Pakkeavhengigheter er eksplisitt angitt med library() eller renv.lock.
Store datafiler lastes inn én gang øverst i server.R, ikke inne i en reaktiv kontekst.
Feilmeldinger avslører ikke intern informasjon til sluttbrukere.

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

Vurderinger ved skalering

Shiny-apper er øktbaserte: hver bruker får sin egen R-prosess (eller arbeider). Strategier for skalering:

Last inn forhåndsberegnede data ved oppstart i stedet for å beregne dem for hver økt.
Bruk reaktiv hurtigbufring med bindCache() for kostbare beregninger som deles mellom økter.
Flere arbeidere: Shiny Server Pro og Posit Connect starter parallelle R-prosesser.
Database-tilkoblinger: bruk DBI/pool for samtidig databasetilgang.

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')
  })
}

Hurtigsjekk

Hva er den anbefalte måten å håndtere API-nøkler og databasepassord i en distribuert Shiny-app på?

Besvar den i den interaktive leksjonen

Oppsummering av distribusjon av Shiny-apper

Viktigste punkter fra distribusjon av Shiny-apper:

Distribusjonsalternativer: shinyapps.io (enklest), Shiny Server (selvvertet), Posit Connect (bedrift), Docker.
app.R må deklarere alle avhengigheter med library(). Bruk renv::snapshot() for reproduserbare versjoner.
rsconnect::deployApp() pakker og sender appen til shinyapps.io eller Posit Connect.
Docker med rocker/shiny gir maksimal portabilitet.
Bruk Sys.getenv() for legitimasjon – hardkod aldri hemmeligheter.
Last inn store datasett ved oppstart (utenfor server()) for å dele dem mellom økter.
Bruk tilkoblingspooler (pool-pakken) for samtidig databasetilgang.

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

Gratis å komme i gang

Lær deg R med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 43
Leksjoner: 159

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Distribuere Shiny-apper» gratis?

Ja – du kan lese valgfritt 3 av leksjonene i læringsstien R Academy, inkludert «Distribuere Shiny-apper», gratis i sin helhet her på nettet. Deretter låser CoddyKit PRO opp alle leksjoner, samt interaktiv øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Kurset i R Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «Distribuere Shiny-apper»?

Publiser apper til shinyapps.io, Shiny Server og Docker-baserte miljøer. Du øver på R Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med R Academy?

Ingen tidligere erfaring er nødvendig. R Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 4 av 4.

Hvor lang tid tar leksjonen «Distribuere Shiny-apper»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne R Academy-leksjonen?

Ja. Alle R Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

← Tilbake til R Academy