Deploy Shiny App

Deploy Shiny application to shinyapps.io, Posit Connect, or Docker container.

When Use

• Publish Shiny app for external or internal users
• Move from local development to hosted environment
• Containerize Shiny app for Kubernetes or Docker deployment
• Set up automated deployment pipelines

Inputs

• Required: Path to Shiny application
• Required: Deployment target (shinyapps.io, Posit Connect, or Docker)
• Optional: Account name and token (for shinyapps.io/Connect)
• Optional: Instance size preference
• Optional: Custom domain or URL path

Steps

Step 1: Prep Application

Ensure app is self-contained and deployable:

# Check for missing dependencies
rsconnect::appDependencies("path/to/app")

# For golem apps, ensure DESCRIPTION lists all Imports
devtools::check()

# Verify app runs cleanly
shiny::runApp("path/to/app")

Verify these files exist:

• app.R (or ui.R + server.R)
• renv.lock (recommended for reproducible deployments)
• .Rprofile does NOT call mcptools::mcp_session() in production

Got: App runs locally without errors. All dependencies captured.

If fail: If appDependencies() reports missing packages, install them and update renv.lock. If app uses system libraries (e.g., gdal, curl), note them for Docker path.

Step 2a: Deploy to shinyapps.io

# One-time account setup
rsconnect::setAccountInfo(
  name = "your-account",
  token = Sys.getenv("SHINYAPPS_TOKEN"),
  secret = Sys.getenv("SHINYAPPS_SECRET")
)

# Deploy
rsconnect::deployApp(
  appDir = "path/to/app",
  appName = "my-app",
  appTitle = "My Application",
  account = "your-account",
  forceUpdate = TRUE
)

Store credentials in .Renviron (never in code):

# .Renviron
SHINYAPPS_TOKEN=your_token_here
SHINYAPPS_SECRET=your_secret_here

Got: App deployed and accessible at https://your-account.shinyapps.io/my-app/.

If fail: If authentication fails, regenerate tokens at shinyapps.io dashboard > Account > Tokens. If package installation fails on server, check all packages available on CRAN — shinyapps.io cannot install from GitHub by default.

Step 2b: Deploy to Posit Connect

# Register server (one-time)
rsconnect::addServer(
  url = "https://connect.example.com",
  name = "production"
)

# Authenticate (one-time)
rsconnect::connectApiUser(
  account = "your-username",
  server = "production",
  apiKey = Sys.getenv("CONNECT_API_KEY")
)

# Deploy
rsconnect::deployApp(
  appDir = "path/to/app",
  appName = "my-app",
  server = "production",
  account = "your-username"
)

Got: App deployed and accessible on Posit Connect instance.

If fail: If server rejects connection, verify API key and server URL. If packages fail to install, check Connect has access to required repositories (CRAN, internal CRAN-like repos).

Step 2c: Deploy with Docker

Create Dockerfile:

FROM rocker/shiny-verse:4.4.0

# Install system dependencies
RUN apt-get update && apt-get install -y \
    libcurl4-openssl-dev \
    libssl-dev \
    libxml2-dev \
    && rm -rf /var/lib/apt/lists/*

# Install R packages
RUN R -e "install.packages(c('shiny', 'bslib', 'DT', 'plotly'))"

# Copy app
COPY . /srv/shiny-server/myapp/

# Configure Shiny Server
COPY shiny-server.conf /etc/shiny-server/shiny-server.conf

# Expose port
EXPOSE 3838

# Run
CMD ["/usr/bin/shiny-server"]

Create shiny-server.conf:

run_as shiny;

server {
  listen 3838;

  location / {
    site_dir /srv/shiny-server/myapp;
    log_dir /var/log/shiny-server;
    directory_index on;
  }
}

Build and run:

docker build -t myapp:latest .
docker run -p 3838:3838 myapp:latest

Got: App accessible at http://localhost:3838.

If fail: If build fails on package installation, add missing system libraries to apt-get install line. If app doesn't load, check Shiny Server logs: docker exec <container> cat /var/log/shiny-server/*.log.

Step 3: Verify Deployment

# Check deployed URL responds
response <- httr::GET("https://your-app-url/")
httr::status_code(response)  # Should be 200

# For Docker
response <- httr::GET("http://localhost:3838/")
httr::status_code(response)

Manual verification checklist:

1. App loads without errors
2. All interactive elements respond
3. Data connections work in deployed environment
4. Authentication/authorization works (if applicable)

Got: App responds with HTTP 200. All features work.

If fail: Check server logs for specific deployment platform. Common issues: environment variables not set in production, database connections using localhost instead of production URLs, or file paths only existing locally.

Step 4: Configure Monitoring (Optional)

shinyapps.io

Monitor via dashboard at https://www.shinyapps.io/admin/#/applications.

Posit Connect

# Check deployment status via API
connectapi::connect(
  server = "https://connect.example.com",
  api_key = Sys.getenv("CONNECT_API_KEY")
)

Docker

Add health check to Dockerfile:

HEALTHCHECK --interval=30s --timeout=10s --retries=3 \
  CMD curl -f http://localhost:3838/ || exit 1

Got: Monitoring configured for deployment target.

If fail: If health checks fail intermittently, increase timeout values. Shiny apps can be slow to respond during initial load.

Checks

• App deploys without errors
• Deployed URL responds with HTTP 200
• All interactive features work in production
• Environment variables/secrets configured (not hardcoded)
• Credentials stored in .Renviron or CI secrets, not in code
• renv.lock committed for reproducible dependency resolution

Pitfalls

• Hardcoded file paths: Replace absolute paths with system.file() (for package data) or environment variables (for external resources).
• Development-only dependencies: Don't deploy .Rprofile that loads mcptools::mcp_session() or devtools. Use conditional loading or separate profiles.
• Missing system libraries in Docker: R packages like sf, curl, and xml2 need system libraries. Add them to Dockerfile's apt-get install.
• CRAN-only packages on shinyapps.io: shinyapps.io only installs from CRAN by default. GitHub-only packages need remotes package and explicit installation in deployment.
• Forgotten environment variables: Database credentials, API keys, other secrets must be configured in deployment environment separately from code.

See Also

• scaffold-shiny-app — create app structure before deployment
• create-r-dockerfile — detailed Docker configuration for R projects
• setup-docker-compose — multi-container setups for Shiny with databases
• setup-github-actions-ci — CI/CD including automated deployment
• optimize-shiny-performance — performance tuning before deploying to production