Ruby Quickstart Guides

Ruby On Rails Quickstart Guide

This guide will show you how to set up a Ruby app using the Rails framework and ActiveRecord + PostgreSQL. This guide leverages Dockerfile Deploy.

Create an App

Tell Aptible that you want to provision an App. Until you push code and trigger a build, Aptible uses this as a placeholder.

To create an App, use the Dashboard, or the aptible apps:create command:

# Set or substitute $APP_HANDLE with the app name of your choice

aptible apps:create "$APP_HANDLE"

Aptible will provide your App's Git Remote in return. Copy it, you'll need it later.

Going forward in this document, we'll refer to the App's handle as $APP_HANDLE, and its Remote as $GIT_REMOTE.

Provision a Database

Start by adding a PostgreSQL Database for your App:

aptible db:create "$DB_HANDLE" --type postgresql

Make sure you set or substitute $DB_HANDLE with the database name of your choice (alternatively, you could use the Dashboard to create a Database as well).

The aptible db:create will return a connection string on success. This is a Database Credential. You'll need it later to configure your App.

Going forward in this document, we'll refer to the Credential as $DATABASE_URL.



Databases are only reachable from within your Stack's internal network.

This means your Containers will be able to connect to your database, but if you want to connect from your workstation, you'll need to use a Database Tunnel.

Add a Dockerfile

The Dockerfile is a text file that contains the commands you would otherwise execute manually to build a Docker image. Aptible uses the resulting Image to run Containers for your App.

A few guidelines:

  1. The file needs to be called Dockerfile, starting with a capital letter, and no extension.
  2. Place the Dockerfile at the root of the repository.
  3. Be sure to commit them to version control.

Here is a sample Dockerfile for a Ruby on Rails App:

FROM ruby:2.4

# System prerequisites
RUN apt-get update \
 && apt-get -y install build-essential libpq-dev \
 && rm -rf /var/lib/apt/lists/*

# If you require additional OS dependencies, install them here:
# RUN apt-get update \
#  && apt-get -y install imagemagick nodejs \
#  && rm -rf /var/lib/apt/lists/*

ADD Gemfile /app/
ADD Gemfile.lock /app/
RUN bundle install

ADD . /app

# Collect assets. This approach is not fully production-ready, but
# will help you experiment with Aptible before bothering with assets.
# Review for production-ready advice.
RUN set -a \
 && . ./.aptible.env \
 && bundle exec rake assets:precompile


CMD ["bundle", "exec", "rails", "s", "-b", "", "-p", "3000"]



See Optimizing Dockerfile caching for Bundler to better understand this Dockerfile.



Review How do I serve static assets when using Aptible? for in-depth advice on asset precompilation and serving.

Automate Database Migrations

Finally, your app probably expects you to run database migrations upon deploy to ensure your app code and database are in sync.

You can tell Aptible to run your migrations by adding a .aptible.yml file in your repository.

The file should be named .aptible.yml, and found at the root of your repository (make sure to check it in after creating it).

Here is a sample .aptible.yml file to automate Database migrations:

  - bundle exec rake db:migrate

Bring it all together

At this point, you're almost ready to deploy.

All that is left to do is put the pieces together by configuring your App to point it to your Database, then you'll be ready to push your code to Aptible.

To add the required environment variables, use the aptible config:set command as documented below. Make sure you set or substitute $APP_HANDLE and $DATABASE_URL with their proper values.

aptible config:set --app "$APP_HANDLE" \

Once you're done, push your code to Aptible by adding Aptible as a git remote for your app, and then using git push to push your code:

git remote add aptible "$GIT_REMOTE"
git push aptible master

Deploy logs will stream to your terminal. They'll be useful in case anything goes wrong to understand the cause of the failure.

Add an Endpoint

At this point, your App is running on Aptible. What's next is expose it on the Internet!

Follow the instructions here to proceed: How do I expose my web app on the Internet?.