It's easy to get started developing Ruby on Rails apps that run on the App Engine flexible environment. Because the apps you create run on the same infrastructure that powers all of Google's products, you can be confident that they can scale to serve all of your users, whether there are a few or millions of them.
This tutorial assumes you are familiar with Rails web development. It walks you through setting up Cloud SQL for PostgreSQL with a new Rails app. You can also use this tutorial as a reference for configuring existing Rails apps to use Cloud SQL for PostgreSQL.
This tutorial requires Ruby 2.3.4 or newer.
Before you begin
Check off each step as you complete it.
Create a project in the Google Cloud Platform Console.
If you haven't already created a project, create one now. Projects enable you to manage all Google Cloud Platform resources for your app, including deployment, access control, billing, and services.
- Open the GCP Console.
- In the drop-down menu at the top, select Create a project.
- Click Show advanced options. Under App Engine location, select a United States location.
- Give your project a name.
- Make a note of the project ID, which might be different from the project name. The project ID is used in commands and in configurations.
Enable billing for your project, and sign up for a free trial.
If you haven't already enabled billing for your project, enable billing now, and sign up for a free trial. Enabling billing allows the app to consume billable resources such as running instances and storing data. During your free trial period, you won't be billed for any services.
Install the Cloud SDK.
If you haven't already installed the Cloud SDK, install and initialize the Cloud SDK now. The Cloud SDK contains tools and libraries that enable you to create and manage resources on GCP.
Enable APIs for your project.
This takes you to the GCP Console and automatically enables the APIs used by this tutorial. The APIs used are: Cloud SQL Administration.
Preparing a Cloud SQL for PostgreSQL instance
Set up a Cloud SQL for PostgreSQL instance for this tutorial.
Create a PostgreSQL instance. In this tutorial, the name of the instance is
Create a database in the instance. In this tutorial, the name of the production database is
Setting up your local environment for Rails
To set up your local environment for this tutorial:
For additional information on installing Rails and its dependencies, see the official Getting started with Rails guide.
After you complete the prerequisites, create and deploy a Rails app by using Cloud SQL for PostgreSQL. The following sections guide you through configuring, connecting to Cloud SQL for PostgreSQL, and deploying an app.
Create a new app to list cats
rails newcommand to create a new Rails app. This app stores a list of cats in Cloud SQL for PostgreSQL.
rails new cat_sample_app
Go to the directory that contains the generated Rails app.
Run the app locally
To run the new Rails app on your local computer:
Install dependencies by using Bundler.
Start a local web server:
bundle exec bin/rails server
In a browser, go to http://localhost:3000/
A Yay! You're on Rails! message from the app displays on the page.
Generate scaffolding for a list of cats
Generate scaffolding for a resource named
Cat that is used to form a list
of cats with their name and age.
Generate the scaffolding.
bundle exec rails generate scaffold Cat name:string age:integer
The command generates a model, controller, and views for the
Open the file
config/routes.rbto see the following generated content.
Rails.application.routes.draw do resources :cats get 'cats/index' # For details on the DSL available within this file, see http://guides.rubyonrails.org/routing.html end
root 'cats#index'to the file.
Rails.application.routes.draw do resources :cats get 'cats/index' # For details on the DSL available within this file, see http://guides.rubyonrails.org/routing.html root 'cats#index' end
Save the file and close it.
Test the Rails app as instructed before.
Using Cloud SQL for PostgreSQL with App Engine
Cloud SQL for PostgreSQL is a fully-managed database service to set up, maintain, manage, and administer your relational PostgreSQL databases in Google Cloud Platform (GCP). You can use Cloud SQL in a Rails app like any other relational database.
Set up Cloud SQL for PostgreSQL
To begin using Cloud SQL with your Rails app in production:
appenginegems to the
bundle add pg bundle add appengine
Gemfilecontains the following additional
# Added at 2017-08-23 15:24:52 -0700 by franknatividad: gem "pg", "~> 0.21.0" # Added at 2017-08-07 11:54:12 -0700 by USER: gem "appengine", "~> 0.4.1"
To configure the Rails app to connect with Cloud SQL, open the
config/database.ymlfile. The following boilerplate database settings for SQLite are displayed:
# SQLite version 3.x # gem install sqlite3 # # Ensure the SQLite 3 gem is defined in your Gemfile # gem 'sqlite3' # default: &default adapter: sqlite3 pool: 5 timeout: 5000 development: <<: *default database: db/development.sqlite3 # Warning: The database defined as "test" will be erased and # re-generated from your development database when you run "rake". # Do not set this db to the same as development or production. test: <<: *default database: db/test.sqlite3 production: <<: *default database: db/production.sqlite3
Configure the Cloud SQL instance connection name for the App Engine production environment.
Retrieve the instance connection name.
gcloud sql instances describe rails-cloudsql-instance
Copy the value next to
database.ymlproduction database configuration to the following:
production: adapter: postgresql encoding: unicode pool: 5 timeout: 5000 username: "[YOUR_POSTGRES_USERNAME]" password: "[YOUR_POSTGRES_PASSWORD]" database: "cat_list_production" host: "/cloudsql/[YOUR_INSTANCE_CONNECTION_NAME]"
[YOUR_POSTGRES_USERNAME]represents your PostgreSQL username.
[YOUR_POSTGRES_PASSWORD]represents your PostgreSQL password.
[YOUR_INSTANCE_CONNECTION_NAME]represents the instance connection name that you copied in the previous step.
The Rails app is now set up to use Cloud SQL when deploying to App Engine flexible environment.
Deploying the app to the App Engine flexible environment
App Engine flexible environment uses a file called app.yaml to describe an app's deployment configuration. If this file isn't present, the Cloud SDK tries to guess the deployment configuration. However, you should define the file to provide required configuration settings for the Rails secret key and Cloud SQL.
To configure the sample app for deployment to App Engine, create a new
app.yaml at the root of the Rails app directory and add the
entrypoint: bundle exec rackup --port $PORT env: flex runtime: ruby
Configure the Rails secret key in the
When a Rails app is deployed to the
production environment, set the
SECRET_KEY_BASE with a secret key to protect user session
data. This environment variable is read from the
config/secrets.yml file in
your Rails app.
Generate a new secret key.
bundle exec bin/rails secret
Copy the generated secret key.
app.yamlfile that you created earlier, and add an
env_variablesdefines environment variables in the App Engine flexible environment. The
app.yamlfile should look similar to the following example with
[SECRET_KEY]replaced with your secret key.
entrypoint: bundle exec rackup --port $PORT env: flex runtime: ruby env_variables: SECRET_KEY_BASE: [SECRET_KEY]
Configure the Cloud SQL instance in the
Next, configure the App Engine flexible environment to use a specified
Cloud SQL instance by providing the Cloud SQL instance
connection name in the
app.yaml configuration file.
app.yamlfile, and add a new section named
Define a nested parameter
cloud_sql_instanceswith the instance connection name as the value.
app.yamlshould look similar to the following:
entrypoint: bundle exec rackup --port $PORT env: flex runtime: ruby env_variables: SECRET_KEY_BASE: [SECRET_KEY] beta_settings: cloud_sql_instances: [YOUR_INSTANCE_CONNECTION_NAME]
Create an App Engine flexible environment app
If this is the first time you are deploying an app, you need to create an App Engine flexible environment app and select the region where you want to run the Rails app.
Create an App Engine app.
gcloud app create
Select a region that supports App Engine flexible environment for Ruby apps. Read more about Regions and zones.
Deploy a new version
Next, deploy a new version of the Rails app described in the
without redirecting traffic from the current default serving version.
Precompile the Rails assets.
bundle exec bin/rails assets:precompile
After the assets finish compiling, deploy a new version of the app.
gcloud app deploy --no-promote
It can take several minutes to finish the deployment. Wait for a success message. You can view deployed versions in the App Engine version list.
After you deploy the new version, if you attempt to access this new version, it shows the following error message because you haven't migrated the database.
Grant required permission for the
Next, grant access to the cloudbuild service account to run production database
migrations with the
List available projects.
gcloud projects list
In the output, find the project you want to use to deploy your app, and copy the project number.
Add a new member to your project IAM policy for the role
roles/editorto run database migrations. Replace
[YOUR-PROJECT-ID]with your GCP project ID and replace
[PROJECT_NUMBER]with the project number you copied in the previous step.
gcloud projects add-iam-policy-binding [YOUR-PROJECT-ID] \ --member=serviceAccount:[PROJECT_NUMBER]@cloudbuild.gserviceaccount.com \ --role=roles/editor
Migrate your Rails database
Rails database migrations are used to update the schema of your database without
using SQL syntax directly. Next you migrate your
appengine gem provides the Rake task
appengine:exec to run a command
against the most recent deployed version of your app in the production
App Engine flexible environment.
Migrate the Cloud SQL for PostgreSQL
cat_list_productiondatabase in production.
bundle exec rake appengine:exec -- bundle exec rake db:migrate
You should see output similar to:
---------- EXECUTE COMMAND ---------- bundle exec rake db:migrate Debuggee gcp:787021104993:8dae9032f8b02004 successfully registered == 20170804210744 CreateCats: migrating ======================================= -- create_table(:cats) -> 0.0219s == 20170804210744 CreateCats: migrated (0.0220s) ============================== ---------- CLEANUP ----------
To verify the database migration, go to:
The following is displayed for a successful deployment:
Migrate traffic to new version
Finally, direct traffic to your newly deployed version by using the following command:
gcloud app services set-traffic default --splits [YOUR-VERSION]=1
The new version of the app is now accessible from:
Reading App Engine logs
Now that you have deployed your Rails app, you might want to read the logs. You can read the app logs by using the Logs Viewer located in the Google Cloud Platform Console.
You can learn more about reading logs using the Cloud SDK.
Clean up resources
After you've finished the Using Cloud SQL for PostgreSQL with Rails 5 tutorial, you can clean up the resources you created on Google Cloud Platform so they won't take up quota and you won't be billed for them in the future. The following sections describe how to delete or turn off these resources.
The easiest way to eliminate billing is to delete the project you created for the tutorial.
To delete the project:
- In the GCP Console, go to the Manage resources page.
- In the project list, select the project you want to delete and click Delete delete.
- In the dialog, type the project ID, and then click Shut down to delete the project.
Delete an App Engine version
To delete an app version:
- In the GCP Console, go to the Versions page for App Engine.
- Select the checkbox for the non-default app version you want to delete.
- Click Delete deleteto delete the app version.
Delete a Cloud SQL instance
To delete a Cloud SQL instance:
- In the GCP Console, go to the SQL Instances page.
- Click the name of the SQL instance you want to delete.
- Click Delete delete to delete the instance.