The Ruby Runtime

Overview

The Ruby runtime is the software stack responsible for installing your application code and its dependencies and running your application. The standard runtime is declared in app.yaml as runtime: ruby:

runtime: ruby
env: flex

Runtimes in the flexible environment are built using Docker. The Ruby runtime is based on Ubuntu 16.04. The source code for the Ruby runtime is publicly available on GitHub.

Interpreter

You can specify which version of the Ruby interpreter to use by providing it as the contents of a .ruby-version file in your application directory. For example:

2.4.1

When this file is present, the runtime will install the requested version of Ruby when you deploy your application, using rbenv. If the requested version cannot be installed, you will receive an error message during deployment.

If you do not provide a .ruby-version file, the Ruby runtime will default to a recent release of Ruby 2.6. Note that the default can change at any time, so it is recommended that your app specify a Ruby version.

Dependencies

The runtime looks for a Gemfile file in your application's source directory and uses Bundler to install any dependencies before starting your application. For more information on declaring and managing packages, see Using Ruby Libraries.

Using C libraries with Ruby

For Ruby libraries that require C extensions, the headers for the current Ruby version and the following Ubuntu packages are pre-installed on the system.

• autoconf
• build-essential
• ca-certificates
• cmake
• curl
• file
• git
• imagemagick
• libcurl3
• libcurl3-gnutls
• libcurl4-openssl-dev
• libffi-dev
• libgdbm-dev
• libgit2-dev
• libgmp-dev
• libicu-dev
• libjemalloc-dev
• libjemalloc1
• libmagickwand-dev
• libmysqlclient-dev
• libncurses5-dev
• libpq-dev
• libqdbm-dev
• libreadline6-dev
• libsqlite3-dev
• libssl-dev
• libxml2-dev
• libxslt-dev
• libyaml-dev
• libz-dev
• systemtap
• tzdata

These packages allow the installation of most popular Ruby libraries. If your application requires additional operating-system level dependencies, you will need to use a custom runtime based on this runtime to install the appropriate packages.

Application startup

The runtime starts your application using the entrypoint defined in app.yaml. The entrypoint should start a process that responds to HTTP requests on the port defined by the environment variable PORT. For example:

entrypoint: bundle exec rails server -p $PORT

Most web applications use a Rack-supported web server such as Puma, Unicorn or Thin.

You must add the server as a dependency in your application's Gemfile configuration file. The runtime will install all dependencies before your entrypoint is called.

source "https://rubygems.org"

gem "rack"
gem "puma"

An example entrypoint using puma for a Rails application:

entrypoint: bundle exec rails server Puma -p $PORT

An example entrypoint using puma for any Rack application:

entrypoint: bundle exec rackup -s Puma -p $PORT

For applications that can handle requests without a Rack server, you can just execute a ruby script:

entrypoint: bundle exec ruby app.rb

Note: The entrypoint command will be executed by bash's exec function. Shell variables such as $PORT will be replaced normally, but shell syntax such as if, for and while embedded in the entrypoint command will not function.

Extending the runtime

The standard Ruby runtime can be used to create a custom runtime. Custom runtimes are configured via Dockerfiles. You can generate a Dockerfile based on the standard Ruby runtime using gen-config:

gcloud beta app gen-config --custom

You can then customize the Dockerfile and .dockerignore as desired. Finally, you will need to specify runtime: custom instead of runtime: ruby in app.yaml.

Environment variables

The following environment variables are set by the runtime environment:

Environment Variable	Description
GAE_INSTANCE	The name of the current instance.
GAE_MEMORY_MB	The amount of memory available to the application process.
GAE_SERVICE	The service name specified in your application's app.yaml file, or if no service name is specified, it is set to default.
GAE_VERSION	The version label of the current application.
GOOGLE_CLOUD_PROJECT	The Project ID associated with your application, which is visible in the Google Cloud Console
PORT	The port that will receive HTTP requests.
RACK_ENV	Set to production.
RAILS_ENV	Set to production.
RAILS_SERVE_STATIC_FILES	Set to true.

You can set additional environment variables with app.yaml.

Metadata server

Each instance of your application can use the Compute Engine metadata server to query information about the instance, including its host name, external IP address, instance ID, custom metadata, and service account information. App Engine does not allow you to set custom metadata for each instance, but you can set project-wide custom metadata and read it from your App Engine and Compute Engine instances.

This example function uses the metadata server to get the external IP address of the instance:

appengine/metadata_server/app.rb

View on GitHub

require "sinatra"
require "net/http"

get "/" do
  uri = URI.parse(
    "http://metadata.google.internal/computeMetadata/v1" +
    "/instance/network-interfaces/0/access-configs/0/external-ip"
  )

  request = Net::HTTP::Get.new uri.path
  request.add_field "Metadata-Flavor", "Google"

  http = Net::HTTP.new uri.host, uri.port

  response = http.request request

  "External IP: #{response.body}"
end