Getting Started With Ruby


Step 1: The sample application and git repository

Sample Ruby application

The sample application used in this tutorial is based on Sinatra and prints out environment variables.

Even though it’s a minimal application it will serve well to describe the basic concepts. You do not have to use our sample application, but for the first steps it might be helpful.

Git repository hosting

To create new application you need to have your source code hosted somewhere on the internet and have it accessible using git. Popular choices are GitHub, GitLab or BitBucket. For example, our sample application is hosted at Github. For this tutorial you may use the code from the provided repository or you can fork the repository. Forking is necessary if you want to follow also through Step 3.

Step 2: Creating new application

Creating new application using terminal

Once ready, open a terminal and at the command prompt, enter the following command to create a Ruby application (replace the username in the URL if you have forked, or the whole URL if you are using your own application):

oc new-app --name=myapp ruby~https://github.com/OpenShiftDemos/os-sample-ruby.git

And the output should look something like this:

--> Found image d5ca607 (5 weeks old) in image stream "ruby" in project "openshift" under tag "2.2" for "ruby"

    Ruby 2.2
    --------
    Platform for building and running Ruby 2.2 applications

    Tags: builder, ruby, ruby22

    * A source build using source code from https://github.com/OpenShiftDemos/os-sample-ruby.git will be created
      * The resulting image will be pushed to image stream "myapp:latest"
    * This image will be deployed in deployment config "myapp"
    * Port 8080/tcp will be load balanced by service "myapp"
      * Other containers can access this service through the hostname "myapp"

--> Creating resources with label app=myapp ...
    imagestream "myapp" created
    buildconfig "myapp" created
    deploymentconfig "myapp" created
    service "myapp" created
--> Success
    Build scheduled, use 'oc logs -f bc/myapp' to track its progress.
    Run 'oc status' to view your app.

The --name=myapp names the application. By default it would be the base name of the URL without extension, in our case os-sample-ruby, but it’s much nicer to have the application named myapp and that’s what we did using this switch.

OpenShift automatically linked ruby with Ruby 2.2 as the latest version. You could as well use ruby20 as the template to deploy using the specific version, e.g.

oc new-app --name=myapp ruby20~https://github.com/OpenShiftDemos/os-sample-ruby.git

OpenShift prints a lot of information that is not that important for us at this moment, what we care about is if our application is accessible from the internet and if we can see it running. For exposing application to the outside world, OpenShift has a concept of routes that map domain names to specific applications.
To expose our application we need to know the name of the internal service in all the information printed when we created our application it’s this line service "myapp" created.
OpenShift automatically created new service, according to the name of the application. Now, let’s expose that service, to do that, run this command:

oc expose svc myapp

And you should see something like this:

route "myapp" exposed

Now we can run oc status to get information about your deployment

oc status

and you should see something like this

http://myapp-demo.44fs.preview.openshiftapps.com to pod port 8080-tcp (svc/myapp)
  dc/myapp deploys istag/myapp:latest <-
    bc/myapp builds https://github.com/OpenShiftDemos/os-sample-ruby.git with openshift/ruby:2.2
    deployment #1 deployed 41 seconds ago - 1 pod

There again is a lot of information that we mostly do not care about at this moment but what we need is the first line. It shows you the domain, your application is available at. To access the application, simply open the domain in your browser of choice and you should see the environment variables.

Creating new application using web console

You can deploy your application using web console as well as wit cli tools. To deploy using web, click on the Add to project in the top bar. Then type ruby into the Filter by keyword text field. And you will see list of Ruby based templates similar to:

builders list
Select ruby:latest and fill in the form like this:
new app

 

Depending on your selection of forking or not deploying the sample application you will need to adjust the URL accordingly. And finally click Create and you will be taken to summary page like this:
new app overview

 

And click Continue to overview. On the overview page you will see detail of your new deployment similar to:
new deployment

Clicking the URL in the top white box will take you straight to your newly deployed application with the environment variables.

Step 3: Making first changes

To make changes to the application, you need to fork it and deploy from your own fork instead of from the original repository of the sample application. That means, that for creating the application the URL will have a different username/organization.

oc new-app --name=myapp ruby~https://github.com/[your user name]/os-sample-ruby.git

Except for that, the whole process process in the Step 1 is the same.

Editing the source code

You can edit the source code in Github’s web based editor. If you choose to do so, there no need to copy the source code to your local machine and can skip directly to Step 2.2.

Or you can clone the repository locally, edit the file, and push back to the server. To do so, first clone the git repository and enter the new directory

git clone https://github.com/[your user name]/os-sample-ruby.git
cd os-sample-ruby

Edit the config.ru file to your liking and commit the changes

git add -A .
git commit -m "My application changes"
And finally push back to the git hosting:
git push origin master

and that’s it, the change is in the git repository, now let’s go and deploy it.

Deploying the changes using terminal

OpenShift already knows how to reach your git repository as it did while first deploying the application. As it created the service that we referenced before it also created buildconfig buildconfig "myapp" created.

Note

BuildConfigs contain information necessary for building an application. It also contain information what strategy should be used for building it. In our case the strategy is Source. For strategy from source it contains the URL of git repository to fetch the source code from and other important stuff. you can check more details by running
oc describe bc myapp.

BuildConfig is the reference for building stuff and allows us to trigger the building process, to do this run

oc start-build myapp

And you should see something like this:

myapp-2

Once the build finishes, refresh your browser with the application and you shall see the changes you just made.

Deploying the changes using web console

The web UI allows you to trigger builds as well. In the web console go to Browser → Builds and there you will see a line similar to

new build

 

Click on the myapp and on the next page click the Start Build button in the top right corner.
start build
Then click Overview in the main left navigation panel. You will be taken back to the overview page, where you will see that you build is running:
running build
And once finished:
finished build

You can again click your application URL and see the changes.

Categories
News, OpenShift Online, Ruby
Tags
,
Comments are closed.