Introducing dockitect: Making Docker Feel More Native to R

If you’ve ever struggled with the disconnect between R’s elegant data workflows and Docker’s containerization capabilities, I’ve got exciting news. Today, I’m introducing {dockitect} (package website), a new R package that brings pipe-friendly and programmatic principles to Docker integration.

{dockitect} is designed to make creating and managing Dockerfile files a natural extension of your R workflow, with a pipe-friendly API that feels right at home alongside your modern R code. By building on the foundation of the Rocker Project’s container ecosystem, {dockitect} provides a streamlined bridge between R’s elegant programming model and Docker’s powerful containerization.

Why Docker with R?

Docker containers offer compelling benefits for R users:

• Reproducibility: Capture the exact environment needed for your analysis
• Deployment simplicity: Package everything needed to run your Shiny apps or Plumber APIs
• Isolation: Keep project dependencies separate and avoid conflicts
• Scaling: Easily distribute your work to different computing environments

But writing a Dockerfile file by hand can be tedious and error-prone, especially when you need to incorporate R-specific needs like package dependencies and system requirements.

Enter dockitect

{dockitect} offers a programmatic, pipe-friendly approach to building Docker configurations directly from R. At its core are these guiding principles:

1. R-first design: Built specifically for R project containerization needs
   • We’re working to incorporate Python and Julia support in the future.
2. Intuitive API: Consistent naming patterns and pipe-friendliness
3. Automatic environment detection: Generate a Dockerfile based on your current R session, package, or scripts.
4. Template-driven: Pre-built templates for common R project types
5. Comprehensive: Manage both Dockerfile and .dockerignore files

Building on a Rocker Project Foundation

{dockitect} stands on the shoulders of the excellent Rocker Project, which provides a suite of Docker images with pre-installed R environments. These images solve the complex problem of properly installing R and its dependencies in Docker containers, giving us a solid foundation to build upon. Most {dockitect} templates and generated Dockerfile files use images like rocker/r-ver and rocker/shiny by default, ensuring you get the benefits of these well-maintained, optimized containers with minimal configuration.

Getting Started

{dockitect} is currently in development, but you can install it from GitHub:

# install.packages("remotes")
remotes::install_github("coatless-rpkg/dockitect")

Please note that dockitect is still in early development, and some features may be subject to change. For mission-critical applications, please use with caution.

Overview

For the rest of the post, we’ll take a closer look at some of {dockitect}’s features.

You may also want to check out the package website for more detailed information.

Design Philosopy

The package employs a consistent naming convention that makes the API intuitive and discoverable:

• dockerfile() - Create a new Dockerfile object
  • dfi_*() - Dockerfile instruction functions (e.g., dfi_from(), dfi_run())
  • dfm_*() - Dockerfile modification functions (e.g., dfm_add_line())
• dockerignore() - Create a new .dockerignore object
  • di_*() - Dockerignore functions (e.g., di_add(), di_remove())
• dk_*() - Docker configuration/template functions (e.g., dk_from_session())

Creating Dockerfiles from Scratch

Even for experienced Docker users, repeatedly writing Dockerfiles by hand can be tedious and error-prone. The syntax is rigid, and it’s easy to miss important steps or introduce inconsistencies across different projects. dockitect addresses this by providing a programmatic, pipe-friendly interface for building a Dockerfile one instruction at a time.

Each Docker instruction has a corresponding function prefixed with dfi_*() (Dockerfile Instruction), making the API predictable and discoverable. The example below shows how to chain together instructions to create a basic Dockerfile for an R script:

library(dockitect)

dockerfile() |>
  dfi_from("rocker/r-ver:4.4.3") |>
  dfi_label(maintainer = "user@example.com") |>
  dfi_run("apt-get update && apt-get install -y libcurl4-openssl-dev") |>
  dfi_workdir("/app") |>
  dfi_copy("analysis.R", "/app/") |>
  dfi_cmd("Rscript analysis.R") |>
  write_dockerfile("Dockerfile")

Automatic Dockerfile Generation

The most challenging part of creating a Dockerfile for an R project is often identifying all the dependencies - both R packages and their system requirements. Manually tracking these dependencies is time-consuming and prone to errors, especially for complex projects with dozens of packages.

{dockitect}’s automatic Dockerfile generation functions solve this problem by analyzing your existing R environment and creating appropriate Dockerfile files with all necessary dependencies. Here’s glimpse of the different supported ways to generate Dockerfile files:

# Create a Dockerfile from your current R session
dk_from_session() |> 
  write_dockerfile()

# Create a Dockerfile from an renv.lock file
dk_from_renv("renv.lock") |>
  write_dockerfile()

# Create a Dockerfile from a DESCRIPTION file
dk_from_description() |>
  write_dockerfile()

# Create a Dockerfile for an R script
dk_from_script("analysis.R") |>
  write_dockerfile()

Application Templates

Containerizing different types of R applications—like Shiny apps or Plumber APIs—often requires specific configurations that follow established best practices. Starting from scratch each time leads to redundant work and potential inconsistencies. dockitect’s template system provides ready-to-use configurations for common R application types.

# Create a Dockerfile for a Shiny app
dk_template_shiny(r_version = "4.4.3", port = 3838) |>
  write_dockerfile()

# Create a Dockerfile for a Plumber API
dk_template_plumber(r_version = "4.4.3", port = 8000) |>
  write_dockerfile()

Managing .dockerignore Files

One often overlooked aspect of Docker is the .dockerignore file, which specifies which files and directories should be excluded from the build context. Setting up an ignore file improves:

1. Build performance: Excluding large files dramatically speeds up the build process
2. Image size optimization: Preventing unnecessary files from being copied into your image
3. Security: Avoiding accidental inclusion of sensitive information

{dockitect} provides a structured approach to managing .dockerignore files with the same pipe-friendly approach used for Dockerfile files:

# Create a .dockerignore file
dockerignore() |>
  di_add(".git/") |>
  di_add("*.Rdata") |>
  di_add("renv/library/") |>
  write_dockerignore()

# Or use templates for common patterns
dk_template_ignore_common(
  git = TRUE, 
  r = TRUE, 
  editor = TRUE
) |>
  write_dockerignore()

Future Development

dockitect is still in early development, but we’re excited about its potential to make Docker more accessible to R users. Planned features include:

• Integration with renv for precise dependency handling
• Better support for multi-stage builds
• More application templates
• Python and Julia template support

Related Works

{dockitect} isn’t the only package in the R ecosystem for working with Docker. Here are some related packages that you might find useful:

• {containerit}: Focuses on reproducible research workflows and can automatically generate Dockerfiles from R sessions with an emphasis on preserving the computational environment.

• {dockerfiler}: Another approach to Dockerfile generation in R that uses a different syntax structure. It offers functions for adding Docker instructions and writing Dockerfiles.

• {renv}: While not directly focused on Docker, renv provides robust dependency management for R projects and pairs excellently with dockitect for creating fully reproducible environments.

Each package has its strengths and may be suited to different workflows and preferences. {dockitect} distinguishes itself through its intuitive naming conventions, comprehensive approach to both Dockerfile and .dockerignore files, and strong integration with existing R project structures.

Conclusion

If you’ve been hesitant to use Docker with your R projects due to the complexity, give dockitect a try. It brings a familiar, pipe-friendly workflow approach to containerization and makes Docker feel like a natural extension of your R environment.

We welcome contributions and feedback at the GitHub repository.