Official Repository

Last pushed: 14 days ago
Short Description
Rails is an open-source web application framework written in Ruby.
Full Description

DEPRECATED

This image is officially deprecated in favor of the standard ruby image, and will receive no further updates after 2016-12-31 (Dec 31, 2016). Please adjust your usage accordingly.

For most usages of this image, it was already not bringing in rails from this image, but actually from your project's Gemfile, so the only "value" being added here was the pre-installing of nodejs, mysql-client, postgresql-client, and sqlite3 for various uses of the rails framework.

For example, a Dockerfile similar to the following would be a good starting point for a Rails project using PostgreSQL:

FROM ruby:2.3

RUN apt-get update \
    && apt-get install -y --no-install-recommends \
        postgresql-client \
    && rm -rf /var/lib/apt/lists/*

WORKDIR /usr/src/app
COPY Gemfile* ./
RUN bundle install
COPY . .

EXPOSE 3000
CMD ["rails", "server", "-b", "0.0.0.0"]

Supported tags and respective Dockerfile links

For more information about this image and its history, please see the relevant manifest file (library/rails). This image is updated via pull requests to the docker-library/official-images GitHub repo.

For detailed information about the virtual/transfer sizes and individual layers of each of the above supported tags, please see the repos/rails/tag-details.md file in the docker-library/repo-info GitHub repo.

What is Ruby on Rails?

Ruby on Rails or, simply, Rails is an open source web application framework which runs on the Ruby programming language. It is a full-stack framework. This means that "out of the box", Rails can create pages and applications that gather information from a web server, talk to or query a database, and render templates. As a result, Rails features a routing system that is independent of the web server.

wikipedia.org/wiki/Ruby_on_Rails

How to use this image

Create a Dockerfile in your Rails app project

FROM rails:onbuild

Put this file in the root of your app, next to the Gemfile.

This image includes multiple ONBUILD triggers which should cover most applications. The build will COPY . /usr/src/app, RUN bundle install, EXPOSE 3000, and set the default command to rails server.

You can then build and run the Docker image:

$ docker build -t my-rails-app .
$ docker run --name some-rails-app -d my-rails-app

You can test it by visiting http://container-ip:3000 in a browser or, if you need access outside the host, on port 8080:

$ docker run --name some-rails-app -p 8080:3000 -d my-rails-app

You can then go to http://localhost:8080 or http://host-ip:8080 in a browser.

Generate a Gemfile.lock

The onbuild tag expects a Gemfile.lock in your app directory. This docker run will help you generate one. Run it in the root of your app, next to the Gemfile:

$ docker run --rm -v "$PWD":/usr/src/app -w /usr/src/app ruby:2.1 bundle install

Bootstrap a new Rails application

If you want to generate the scaffolding for a new Rails project, you can do the following:

$ docker run -it --rm --user "$(id -u):$(id -g)" -v "$PWD":/usr/src/app -w /usr/src/app rails rails new --skip-bundle webapp

This will create a sub-directory named webapp inside your current directory.

Image Variants

The rails images come in many flavors, each designed for a specific use case.

rails:<version>

This is the defacto image. If you are unsure about what your needs are, you probably want to use this one. It is designed to be used both as a throw away container (mount your source code and start the container to start your app), as well as the base to build other images off of.

rails:onbuild

This image makes building derivative images easier. For most use cases, creating a Dockerfile in the base of your project directory with the line FROM rails:onbuild will be enough to create a stand-alone image for your project.

While the onbuild variant is really useful for "getting off the ground running" (zero to Dockerized in a short period of time), it's not recommended for long-term usage within a project due to the lack of control over when the ONBUILD triggers fire (see also docker/docker#5714, docker/docker#8240, docker/docker#11917).

Once you've got a handle on how your project functions within Docker, you'll probably want to adjust your Dockerfile to inherit from a non-onbuild variant and copy the commands from the onbuild variant Dockerfile (moving the ONBUILD lines to the end and removing the ONBUILD keywords) into your own file so that you have tighter control over them and more transparency for yourself and others looking at your Dockerfile as to what it does. This also makes it easier to add additional requirements as time goes on (such as installing more packages before performing the previously-ONBUILD steps).

License

View license information for the software contained in this image.

Supported Docker versions

This image is officially supported on Docker version 1.13.0.

Support for older versions (down to 1.6) is provided on a best-effort basis.

Please see the Docker installation documentation for details on how to upgrade your Docker daemon.

User Feedback

Issues

If you have any problems with or questions about this image, please contact us through a GitHub issue. If the issue is related to a CVE, please check for a cve-tracker issue on the official-images repository first.

You can also reach many of the official image maintainers via the #docker-library IRC channel on Freenode.

Contributing

You are invited to contribute new features, fixes, or updates, large or small; we are always thrilled to receive pull requests, and do our best to process them as fast as we can.

Before you start to code, we recommend discussing your plans through a GitHub issue, especially for more ambitious contributions. This gives other contributors a chance to point you in the right direction, give you feedback on your design, and help you find out if someone else is working on the same thing.

Documentation

Documentation for this image is stored in the rails/ directory of the docker-library/docs GitHub repo. Be sure to familiarize yourself with the repository's README.md file before attempting a pull request.

Docker Pull Command

Comments (16)
julianonunes
10 months ago

I tried running this sequence of commands:
$ docker build -t my-rails-app .
$ docker run -it --rm --user "$(id -u):$(id -g)" -v "$PWD":/usr/src/app -w /usr/src/app rails rails new --skip-bundle webapp

However I can't find the files of the newly created Rails app either in my host machine and the Rails based container.

rcelha
a year ago

This 'json' bug happens because when you execute a container with a uid that doesn't exists on it, the user will have no 'home'. So it will try to write some data on '/'.

You have some options, (1) run with root - the default behavior - and change the owner later, (2) create a user inside the container with the same uid that your host user or (3) create a user and change the uid in the entrypoint.

The entrypoint could be something like:

#!/bin/bash

set -ex;

groupmod -g $NEW_GUID node;
usermod -g $NEW_GUID -u $NEW_UID node;

params=${@}

set +ex;

exec su -c "$params" node;
josephsiefers
2 years ago

Trying to use rails:onbuild as the base for my app. I don't really understand the point of freezing the gems for a container that will be used in a development environment. Could someone please explain? How do i subsequently run bundle install to install a new gem?

hadmut
2 years ago

831.5 MB just to run a rails app is somewhat crazy....

ogarciacar
2 years ago

I've been working with this image on boot2docker for Windows 7. In order to get http://<boot2docker-ip>:3000 as the working IP I must run the server:

docker run -d -p 0.0.0.0:3000:3000 -w /usr/source/app/webapp rails rails server -b 0.0.0.0
esmelab
2 years ago

Sending build context to Docker daemon 26.47 MB
Sending build context to Docker daemon
Step 0 : FROM rails:onbuild

Executing 4 build triggers

Trigger 0, COPY Gemfile /usr/src/app/
Step 0 : COPY Gemfile /usr/src/app/
---> Using cache
Trigger 1, COPY Gemfile.lock /usr/src/app/
Step 0 : COPY Gemfile.lock /usr/src/app/
---> Using cache
Trigger 2, RUN bundle install
Step 0 : RUN bundle install
---> Running in 526e7579b1ee
Don't run Bundler as root. Bundler can ask for sudo if it is needed, and
installing your bundle as root will break this application for all non-root
users on this machine.
Fetching source index from https://rubygems.org/
Using rake 10.4.2
Installing i18n 0.7.0

Gem::Ext::BuildError: ERROR: Failed to build gem native extension.

/usr/local/bin/ruby -r ./siteconf20150226-8-13s6qdv.rb extconf.rb 

Cannot allocate memory - /usr/local/bin/ruby -r ./siteconf20150226-8-13s6qdv.rb extconf.rb 2>&1

Gem files will remain installed in /usr/local/bundle/gems/json-1.8.2 for inspection.
Results logged to /usr/local/bundle/extensions/x86_64-linux/2.2.0-static/json-1.8.2/gem_make.out
An error occurred while installing json (1.8.2), and Bundler cannot continue.
Make sure that gem install json -v '1.8.2' succeeds before bundling.
INFO[0156] The command [/bin/sh -c bundle install] returned a non-zero code: 5
azureuser@ctrl-gym-01 ~/app $ sudo docker build -t control-gimnasio .

socketwiz
2 years ago

It failed to build for me :(

Gem::Ext::BuildError: ERROR: Failed to build gem native extension.

    /usr/local/bin/ruby -r ./siteconf20150131-8-1smpc.rb extconf.rb
creating Makefile

make "DESTDIR=" clean

make "DESTDIR="
compiling generator.c
In file included from generator.c:1:0:
../fbuffer/fbuffer.h: In function 'fbuffer_to_s':
../fbuffer/fbuffer.h:175:47: error: macro "rb_str_new" requires 2 arguments, but only 1 given
     VALUE result = rb_str_new(FBUFFER_PAIR(fb));
                                           ^
../fbuffer/fbuffer.h:175:20: warning: initialization makes integer from pointer without a cast
     VALUE result = rb_str_new(FBUFFER_PAIR(fb));
                ^
Makefile:237: recipe for target 'generator.o' failed
make: *** [generator.o] Error 1

make failed, exit code 2

Gem files will remain installed in /usr/local/bundle/gems/json-1.7.7 for inspection.
Results logged to /usr/local/bundle/extensions/x86_64-linux/2.2.0-   static/json-1.7.7/gem_make.out
An error occurred while installing json (1.7.7), and Bundler cannot continue.
Make sure that `gem install json -v '1.7.7'` succeeds before bundling.
INFO[0182] The command [/bin/sh -c bundle install] returned a non-zero code: 5
dmlond
2 years ago

on mac with boot2docker/docker 1.4.1 I had to remove --user "$(id -u):$(id -g)" from the bootstrap command, but other than that it works very nicely (it even created everything with the correct user:group). I find it is helpful to do the following instead of creating a Dockerfile:

docker run -it --rm -v "$(pwd)":/usr/src/app -w /usr/src/app rails rails new webapp 
docker run -it --rm -v "$(pwd)/webapp":/usr/src/app/webapp -w /usr/src/app/webapp rails bundle install --path vendor/bundle
docker run -it --rm -v "$(pwd)/webapp":/usr/src/app/webapp -w /usr/src/app/webapp -P rails bundle exec rails s
lindburg
2 years ago

Be aware that the rails server binds to localhost (127.0.0.1) -- so on OSX (with boot2docker) I needed to add the following to my Dockerfile:

ENTRYPOINT ["rails", "server", "-b", "0.0.0.0"]

And now I can see my server running at http://<boot2docker-ip>:3000

(Thanks for the assistance, Jerry Baker)

mazzolino
2 years ago

As an additional comment on my bootstrapping advice: In order to be able to add gems to your bundle later on, your Dockerfile needs to look like this:

FROM rails:onbuild

# Disable bundle freeze so we can install additional gems
RUN bundle config --global frozen 0

Then, after making changes to your Gemfile, you can run the following to update your Gemfile.lock:

`docker run -it -v $(pwd):/usr/src/app -w /usr/src/app <your image name> bundle

Afterwards, run docker build once in order to update the gems in your image.