Deploying a rails application to Elastic Beanstalk

Rails is an open source, model-view-controller (MVC) framework for Ruby. This tutorial walks you through the process of generating a Rails application and deploying it to an Amazon Elastic Beanstalk environment.

Prerequisites

~/eb-project$ this is a command
this is output

Launch an Elastic Beanstalk environment

Use the Elastic Beanstalk console to create an Elastic Beanstalk environment. Choose the Ruby platform and accept the default settings and sample code.

Environment creation takes about 5 minutes and creates the following resources:

All of these resources are managed by Elastic Beanstalk. When you terminate your environment, Elastic Beanstalk terminates all the resources that it contains.

Install rails and generate a website

Install Rails and its dependencies with the gem command.

~$ gem install rails
Fetching: concurrent-ruby-1.1.9.gem
Successfully installed concurrent-ruby-1.1.9
Fetching: rack-2.2.3.gem
Successfully installed rack-2.2.3
...

Test your Rails installation.

~$ rails --version
Rails 6.1.4.1

Use rails new with the name of the application to create a new Rails project.

~$ rails new ~/eb-rails

Rails creates a directory with the name specified, generates all of the files needed to run a sample project locally, and then runs bundler to install all of the dependencies (Gems) defined in the project's Gemfile.

Test your Rails installation by running the default project locally.

~$ cd eb-rails
~/eb-rails$ rails server
=> Booting Puma
=> Rails 6.1.4.1 application starting in development
=> Run `bin/rails server --help` for more startup options
Puma starting in single mode...
* Puma version: 5.5.2 (ruby 3.0.2-p107) ("Zawgyi")
*  Min threads: 5
*  Max threads: 5
*  Environment: development
*          PID: 77857
* Listening on http://127.0.0.1:3000
* Listening on http://[::1]:3000
Use Ctrl-C to stop
...

Open http://localhost:3000 in a web browser to see the default project in action.

This page is only visible in development mode. Add some content to the front page of the application to support production deployment to Elastic Beanstalk. Use rails generate to create a controller, route, and view for your welcome page.

~/eb-rails$ rails generate controller WelcomePage welcome
      create  app/controllers/welcome_page_controller.rb
       route  get 'welcome_page/welcome'
      invoke  erb
      create    app/views/welcome_page
      create    app/views/welcome_page/welcome.html.erb
      invoke  test_unit
      create    test/controllers/welcome_page_controller_test.rb
      invoke  helper
      create    app/helpers/welcome_page_helper.rb
      invoke    test_unit
      invoke  assets
      invoke    coffee
      create      app/assets/javascripts/welcome_page.coffee
      invoke    scss
      create      app/assets/stylesheets/welcome_page.scss.

This gives you all you need to access the page at /welcome_page/welcome. Before you publish the changes, however, change the content in the view and add a route to make this page appear at the top level of the site.

Use a text editor to edit the content in app/views/welcome_page/welcome.html.erb. For this example, you'll use cat to simply overwrite the content of the existing file.

<h1>Welcome!</h1>
<p>This is the front page of my first Rails application on Elastic Beanstalk.</p>

Finally, add the following route to config/routes.rb:

Rails.application.routes.draw do
  get 'welcome_page/welcome'
  root 'welcome_page#welcome'

This tells Rails to route requests to the root of the website to the welcome page controller's welcome method, which renders the content in the welcome view (welcome.html.erb).

In order for Elastic Beanstalk to successfully deploy the application on the Ruby platform, we need to update Gemfile.lock. Some dependencies of Gemfile.lock might be platform specific. Therefore, we need to add platform ruby to Gemfile.lock so that all required dependencies are installed with the deployment.

~/eb-rails$ bundle lock --add-platform ruby
Fetching gem metadata from https://rubygems.org/............
Resolving dependencies...
Writing lockfile to /Users/janedoe/EBDPT/RubyApps/eb-rails-doc-app/Gemfile.lock

Configure rails settings

Use the Elastic Beanstalk console to configure Rails with environment properties. Set the SECRET_KEY_BASE environment property to a string of up to 256 alphanumeric characters.

Rails uses this property to create keys. Therefore you should keep it a secret and not store it in source control in plain text. Instead, you provide it to Rails code on your environment through an environment property.

Now you're ready to deploy the site to your environment.

Deploy your application

Create a source bundle containing the files created by Rails. The following command creates a source bundle named rails-default.zip.

~/eb-rails$ zip ../rails-default.zip -r * .[^.]*

Upload the source bundle to Elastic Beanstalk to deploy Rails to your environment.

Cleanup

When you finish working with Elastic Beanstalk, you can terminate your environment. Elastic Beanstalk terminates all Amazon resources associated with your environment, such as Amazon EC2 instances, database instances, load balancers, security groups, and alarms.

With Elastic Beanstalk, you can easily create a new environment for your application at any time.

Next steps

For more information about Rails, visit rubyonrails.org.

As you continue to develop your application, you'll probably want a way to manage environments and deploy your application without manually creating a .zip file and uploading it to the Elastic Beanstalk console. The Elastic Beanstalk Command Line Interface (EB CLI) provides easy-to-use commands for creating, configuring, and deploying applications to Elastic Beanstalk environments from the command line.

Finally, if you plan on using your application in a production environment, you will want to configure a custom domain name for your environment and enable HTTPS for secure connections.