# Deploy Shiny App

> Desplegar aplicaciones Shiny en shinyapps.io, Posit Connect o contenedores Docker. Cubre la configuración de rsconnect, generación de manifiestos, creación de Dockerfiles y verificación del despliegue. Úsalo al publicar una app Shiny para usuarios externos o internos, al pasar del desarrollo local a un entorno alojado, al containerizar una app Shiny para despliegue en Kubernetes o Docker, o al configurar pipelines de despliegue automatizados.

- Skill: `pjt222/deploy-shiny-app-2` (Agent Skill)
- Install (CLI): `npx get-skill add pjt222/deploy-shiny-app-2`
- Raw SKILL.md: https://api.skillmd.com/api/skills/pjt222/deploy-shiny-app-2/raw
- Safety review: pending (external: skill-scanner PASS, skillspector PASS)
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: DevOps & Infra
- License: MIT
- Author: pjt222 (https://skillmd.com/u/pjt222)
- Updated: 2026-09-21
- Page: https://skillmd.com/skills/pjt222/deploy-shiny-app-2

---


# Deploy Shiny App

Desplegar una aplicación Shiny en shinyapps.io, Posit Connect o un contenedor Docker.

## Cuándo Usar

- Al publicar una app Shiny para usuarios externos o internos
- Al pasar del desarrollo local a un entorno alojado
- Al containerizar una app Shiny para despliegue en Kubernetes o Docker
- Al configurar pipelines de despliegue automatizados

## Entradas

- **Requerido**: Ruta a la aplicación Shiny
- **Requerido**: Destino de despliegue (shinyapps.io, Posit Connect o Docker)
- **Opcional**: Nombre de cuenta y token (para shinyapps.io/Connect)
- **Opcional**: Preferencia de tamaño de instancia
- **Opcional**: Dominio personalizado o ruta de URL

## Procedimiento

### Paso 1: Preparar la Aplicación

Asegúrate de que la app sea autocontenida y desplegable:

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

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

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

Verifica que estos archivos existen:
- `app.R` (o `ui.R` + `server.R`)
- `renv.lock` (recomendado para despliegues reproducibles)
- `.Rprofile` NO llama a `mcptools::mcp_session()` en producción

**Esperado:** La app se ejecuta localmente sin errores y todas las dependencias están capturadas.

**En caso de fallo:** Si `appDependencies()` reporta paquetes faltantes, instálalos y actualiza `renv.lock`. Si la app usa bibliotecas del sistema (p.ej., gdal, curl), anótalas para el camino de Docker.

### Paso 2a: Desplegar en shinyapps.io

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

Almacena las credenciales en `.Renviron` (nunca en el código):

```bash
# .Renviron
SHINYAPPS_TOKEN=your_token_here
SHINYAPPS_SECRET=your_secret_here
```

**Esperado:** App desplegada y accesible en `https://your-account.shinyapps.io/my-app/`.

**En caso de fallo:** Si la autenticación falla, regenera los tokens en el panel de shinyapps.io > Account > Tokens. Si la instalación del paquete falla en el servidor, verifica que todos los paquetes estén disponibles en CRAN — shinyapps.io no puede instalar desde GitHub por defecto.

### Paso 2b: Desplegar en Posit Connect

```r
# 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"
)
```

**Esperado:** App desplegada y accesible en la instancia de Posit Connect.

**En caso de fallo:** Si el servidor rechaza la conexión, verifica la clave API y la URL del servidor. Si los paquetes no se instalan, verifica que Connect tenga acceso a los repositorios requeridos (CRAN, repos internos tipo CRAN).

### Paso 2c: Desplegar con Docker

Crea un `Dockerfile`:

```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"]
```

Crea `shiny-server.conf`:

```text
run_as shiny;

server {
  listen 3838;

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

Compilar y ejecutar:

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

**Esperado:** App accesible en `http://localhost:3838`.

**En caso de fallo:** Si la compilación falla en la instalación del paquete, añade las bibliotecas del sistema faltantes a la línea `apt-get install`. Si la app no carga, verifica los registros de Shiny Server: `docker exec <container> cat /var/log/shiny-server/*.log`.

### Paso 3: Verificar el Despliegue

```r
# Check the 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)
```

Lista de verificación manual:
1. La app carga sin errores
2. Todos los elementos interactivos responden
3. Las conexiones de datos funcionan en el entorno desplegado
4. La autenticación/autorización funciona (si aplica)

**Esperado:** La app responde con HTTP 200 y todas las funcionalidades funcionan.

**En caso de fallo:** Revisa los registros del servidor para la plataforma de despliegue específica. Problemas comunes: variables de entorno no configuradas en producción, conexiones de base de datos usando localhost en lugar de URLs de producción, o rutas de archivos que solo existen localmente.

### Paso 4: Configurar el Monitoreo (Opcional)

#### shinyapps.io

Monitoriza a través del panel en `https://www.shinyapps.io/admin/#/applications`.

#### Posit Connect

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

#### Docker

Añade verificación de estado al Dockerfile:

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

**Esperado:** Monitoreo configurado para el destino de despliegue.

**En caso de fallo:** Si las verificaciones de estado fallan intermitentemente, aumenta los valores de tiempo de espera. Las apps Shiny pueden ser lentas para responder durante la carga inicial.

## Validación

- [ ] La app se despliega sin errores
- [ ] La URL desplegada responde con HTTP 200
- [ ] Todas las funcionalidades interactivas funcionan en producción
- [ ] Las variables de entorno/secretos están configurados (no hardcodeados)
- [ ] Las credenciales almacenadas en `.Renviron` o secretos de CI, no en el código
- [ ] renv.lock confirmado para resolución reproducible de dependencias

## Errores Comunes

- **Rutas de archivos hardcodeadas**: Reemplaza las rutas absolutas con `system.file()` (para datos del paquete) o variables de entorno (para recursos externos).
- **Dependencias solo de desarrollo**: No despliegues `.Rprofile` que carga `mcptools::mcp_session()` o `devtools`. Usa carga condicional o perfiles separados.
- **Bibliotecas del sistema faltantes en Docker**: Los paquetes R como sf, curl y xml2 necesitan bibliotecas del sistema. Añádelas a la línea `apt-get install` del Dockerfile.
- **Paquetes solo de CRAN en shinyapps.io**: shinyapps.io solo instala desde CRAN por defecto. Los paquetes solo de GitHub necesitan el paquete `remotes` e instalación explícita en el despliegue.
- **Variables de entorno olvidadas**: Las credenciales de base de datos, claves API y otros secretos deben configurarse en el entorno de despliegue separadamente del código.

## Habilidades Relacionadas

- `scaffold-shiny-app` — crear la estructura de la app antes del despliegue
- `create-r-dockerfile` — configuración detallada de Docker para proyectos R
- `setup-docker-compose` — configuraciones multi-contenedor para Shiny con bases de datos
- `setup-github-actions-ci` — CI/CD incluyendo despliegue automatizado
- `optimize-shiny-performance` — optimización del rendimiento antes de desplegar en producción

