Bootstrap Ruby project in Docker

In the Ruby community, we have a lot of tools to help us to create a new project. But, if you are a beginner, you can be lost in the middle of all these tools. This code is a simple way to start a new project in Ruby using Docker without Rails, dip or any other framework dependencies.
Great examples to start a new project in Ruby:

• Ruby on Whales
• Dockerizing a Ruby on Rails Application
• Setting Up Development Environment for Rails

Development environment

Requirements

Installed Docker with BuildKit support and docker-compose are required:

• Docker
• Docker Compose

Docker setup

This article will use Docker Compose to run the Ruby code. Docker Compose is a tool for defining and running multi-container Docker applications. With Compose, you use a YAML file to configure your application's services. Then, you create and start all the services from the configuration with a single command.

Let's build the image with the following docker/Dockerfile where we can pass the RUBY_VERSION, DEBIAN_CODENAME as build arguments. The UID and GID are the neat parameters to configure file permissions for container volume that will be set in docker/docker-compose. Another important thing is that we are using a non-root user (UID:GID -> app_user:app_group) to run the application.

ARG RUBY_VERSION=3.1.2 ARG DEBIAN_CODENAME=bullseye FROM ruby:$RUBY_VERSION-$DEBIAN_CODENAME ENV APP_DIR=/app ARG UID=1000 ARG GID=1000 RUN groupadd --gid $GID app_group \ && useradd --no-log-init --uid $UID --gid $GID app_user --create-home \ \ && mkdir -p $APP_DIR \ && chown -R $UID:$GID $APP_DIR \ \ && gem update bundler \ && chown -R $UID:$GID /usr/local/bundle \ && bundler --version # copy files required for `bundle install` step COPY --chown=$UID:$GID Gemfile* $APP_DIR/ # entry point setup COPY --chmod=755 docker/entrypoint.sh /usr/bin/ # switching to app user USER $UID:$GID WORKDIR $APP_DIR RUN echo "!!!!! Install gems !!!!!" \ && bundle install -j "$(($(nproc)+1))" ENTRYPOINT ["entrypoint.sh"] CMD /bin/bash 

Docker entrypoint script docker/entrypoint.sh can be used to run commands as a non-root user on container start:

#!/bin/bash -e export PATH="$PATH:/app" bundle check || bundle install -j "$(($(nproc) + 1))" # Then exec the container's main process (what's set as CMD in the Dockerfile). exec "$@" 

In this article, we have a simple Docker environment with Ruby-only app service. The docker-compose.yml file is responsible for creating the containers and the docker/Dockerfile is accountable for creating the image.

version: '3' services: app: build: context: . dockerfile: docker/Dockerfile args: RUBY_VERSION: 3.1.2 DEBIAN_CODENAME: bullseye UID: 1000 GID: 1000 environment: RAILS_ENV: development volumes: - .:/app:delegated - bundle:/usr/local/bundle stdin_open: true tty: true volumes: bundle: 

Gemfile is copied to the container and installed gems. The bundle volume is used to cache the gems.

# frozen_string_literal: true source "https://rubygems.org" gem "byebug" 

We have a final file structure:

$ tree . . ├── Gemfile ├── docker │ ├── Dockerfile │ └── entrypoint.sh └── docker-compose.yml 

To run app container in other OS versions, different user/group ids, build composed containers with docker-compose build --build-arg RUBY_VERSION="3.0.4" --build-arg DEBIAN_CODENAME="buster" --build-arg UID="1001" --build-arg GID="1001", re-build it docker-compose build --no-cache. All the build arguments are optional.

The development environment can be started with

docker-compose run app 

and then run any ruby commands.

The complete repository source code is available on docker-rails-bootstrap. Feel free to use it as a template for your projects. If you have any questions, feel free to ask them in the comments or reach out to me at @pocheptsov.

Next steps

In the following article, we will add Rails app to the project and compare full-size solution with our skeleton bootstrap.