Adds another example: A simple Ruby web app

Author: colszowka

README.md

@@ -63,4 +63,5 @@ To understand best practice regarding building a `Dockerfile` and thus container
 
 Enough with all the theory - we have fully documented and working examples that you can use as reference on getting started with Docker integration. All examples are selected so that minimal code is needed.
 
-  * **[Logstash](example-logstash/)** - A fully working example that creates a custom logstash image that consumes the heise.de RSS feed, puts it into Elasticsearch and makes it searchable using Kibana
+  * **[Logstash](example-logstash/)** - A fully working example that creates a custom logstash image that consumes the heise.de RSS feed, puts it into Elasticsearch and makes it searchable using Kibana
+  * **[Ruby Web App](example-ruby-webapp/)** - Shows how to use containerize a Ruby web application using the community-provided [Ruby docker base image](https://hub.docker.com/_/ruby/)

example-ruby-webapp/README.md

@@ -0,0 +1,46 @@
+# Platform Integration - Ruby Web app example
+
+This example shows how to wrap a web application written in Ruby in a Docker container using the community-provided
+[Ruby docker base image](https://hub.docker.com/_/ruby/) and hence should give you a basic overview of how to
+wrap a software application in a docker image based on the existing public language stack images.
+
+The `docker-compose.yml` and `Dockerfile` include comments on what is happening.
+
+## What does it do?
+
+The app directory contains an example ruby app that acts as a caching proxy: It fetches data from another HTTP
+api, caching the response for 30 seconds inside redis because our remote API is slow - for the sake of this demo
+we are using a special HTTP service that intentionally responds very slowly.
+
+## Running it
+
+On your local checkout of this repository, open this directory in your terminal, then launch:
+
+    docker-compose up
+
+This should build the app image, pull the redis image and launch both.
+
+You can now `curl localhost`. The first request should take around two seconds since the response is not cached in
+redis yet, subsequent requests should be screaming fast thanks to the cached response stored in our redis container.
+After 30 seconds the cache expires and will be fetched from the upstream server again.
+
+## Stopping it
+
+You can hit `ctrl+c` in your terminal to stop the running services, then you can remove the local containers:
+
+    docker-compose rm -f
+
+## Development flow
+
+Running `docker-compose build` will re-build your image as you are putting together your Dockerfile.
+
+Once the image is built, you can also execute the unit tests for the app inside a docker container using:
+
+    docker run -i -t --rm examplerubywebapp_app bundle exec rspec spec.rb
+
+This can also be helpful for setting up continuous integration for your image repository. On a CI server, on each
+push to your source code repository you could:
+
+  1. Build the image using `docker build --pull -t myrepo/myapp:latest .`
+  2. Run your test suite inside the container to verify it works: `docker run -i -t --rm myrepo/myapp:latest bundle exec rspec spec.rb`
+  3. Push the image to your registry repo on success: `docker push myrepo/myapp:latest`

example-ruby-webapp/app/.rspec

@@ -0,0 +1 @@
+--colour --format documentation

example-ruby-webapp/app/Dockerfile

@@ -0,0 +1,14 @@
+# Use the onbuild ruby language image that installs our dependencies 
+# and copies the app source automatically.
+# See https://hub.docker.com/_/ruby/
+FROM ruby:2.3-onbuild
+
+# Set environment variables used by our app for configuration
+ENV RACK_ENV  production
+ENV REDIS_URL redis://redis:6379
+
+# Open up port 5000 for consumption by other containers
+EXPOSE 5000
+
+# The default command to execute when running this container
+CMD ["bundle", "exec", "puma", "-p", "5000"]

example-ruby-webapp/app/Gemfile

@@ -0,0 +1,11 @@
+source 'https://rubygems.org'
+
+gem 'sinatra'
+gem 'redis'
+gem 'httpclient'
+gem 'puma', require: false
+
+group :test do
+  gem 'rspec'
+  gem 'rack-test'
+end

example-ruby-webapp/app/Gemfile.lock

@@ -0,0 +1,44 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.2.5)
+    httpclient (2.7.1)
+    puma (2.15.3)
+    rack (1.6.4)
+    rack-protection (1.5.3)
+      rack
+    rack-test (0.6.3)
+      rack (>= 1.0)
+    redis (3.2.2)
+    rspec (3.4.0)
+      rspec-core (~> 3.4.0)
+      rspec-expectations (~> 3.4.0)
+      rspec-mocks (~> 3.4.0)
+    rspec-core (3.4.1)
+      rspec-support (~> 3.4.0)
+    rspec-expectations (3.4.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.4.0)
+    rspec-mocks (3.4.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.4.0)
+    rspec-support (3.4.1)
+    sinatra (1.4.6)
+      rack (~> 1.4)
+      rack-protection (~> 1.4)
+      tilt (>= 1.3, < 3)
+    tilt (2.0.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  httpclient
+  puma
+  rack-test
+  redis
+  rspec
+  sinatra
+
+BUNDLED WITH
+   1.11.2

example-ruby-webapp/app/app.rb

@@ -0,0 +1,37 @@
+ENV["RACK_ENV"] ||= "development"
+require "bundler"
+Bundler.require :default, ENV["RACK_ENV"]
+require 'digest/sha1'
+
+class App < Sinatra::Base
+  helpers do
+    # Initializes memoized redis client instance
+    def redis
+      @redis ||= Redis.new url: ENV["REDIS_URL"]
+    end
+
+    # Converts given string into a shorter cache key
+    def cache_key(string)
+      Digest::SHA1.hexdigest string
+    end
+
+    # Try to fetch the given url from redis cache, otherwise request it and store 
+    # it in cache for 30 seconds
+    def try_cached(url)
+      if cached = redis.get(cache_key(url))
+        cached
+      else
+        response_body = HTTPClient.get(url).body
+        redis.set cache_key(url), response_body
+        redis.expire cache_key(url), 30
+        response_body
+      end
+    end
+  end
+
+  get "/" do
+    # Fetches response from a slow response fake http web service. Subsequent requests
+    # should be fast thanks to our redis cache until the cache key expires.
+    try_cached 'http://fake-response.appspot.com/?sleep=2'
+  end
+end

example-ruby-webapp/app/config.ru

@@ -0,0 +1,2 @@
+require './app'
+run App

example-ruby-webapp/app/spec.rb

@@ -0,0 +1,35 @@
+ENV['RACK_ENV'] = 'test'
+require './app'
+
+RSpec.describe App do
+  include Rack::Test::Methods
+  let(:app) { App }
+
+  let(:url) { "http://fake-response.appspot.com/?sleep=2" }
+  let(:cache_key) { Digest::SHA1.hexdigest url }
+
+  let(:redis) { double("Redis") }
+
+  before(:each) do
+    # Mock out our Redis client
+    allow(Redis).to receive(:new).and_return(redis)
+  end
+
+  it "queries the HTTP endpoint when not cached, storing it in cache" do
+    expect(HTTPClient).to receive(:get).with(url).and_return(double("response", body: 'The Response'))
+    expect(redis).to receive(:get).with(cache_key).and_return(nil)
+    expect(redis).to receive(:set).with(cache_key, 'The Response')
+    expect(redis).to receive(:expire).with(cache_key, 30)
+
+    get '/'
+    expect(last_response.body).to be == 'The Response'
+  end
+
+  it "uses the cached value and does not query HTTP when cached" do
+    expect(HTTPClient).not_to receive(:get)
+    expect(redis).to receive(:get).with(cache_key).and_return('Cached Response')
+    
+    get '/'
+    expect(last_response.body).to be == 'Cached Response'
+  end
+end

example-ruby-webapp/docker-compose.yml

@@ -0,0 +1,13 @@
+app:
+  # We want docker to build the image based upon the Dockerfile in the app directory
+  build: app
+  # We want to allow access to our running redis service
+  links:
+    - redis
+  # Expose our app server on localhost
+  ports:
+    - "80:5000"
+
+redis:
+  # Just fire up the default redis image as a container
+  image: redis