Let's run a Rails app on our server to test it out.

We're going to clone a Rails ap to the server via Git.

And then, use Bungler to install the specific version of

the rails gem our app needs.

Along with all the apps other gem dependencies.

We're going to be installing a large number of gems here.

And since this is a production server,

we're not going to need the documentation that comes along with them.

So. let's make a quick change to our Gem

configuration here.

I'm going to use the Nano editor to edit the hidden gem RC file.

That's dot gem RC in our home directory.

That command will create the file if it doesn't exist and

I'm going to add a line to it.

Gem, colon double dash no-document.

And that'll add a flag to the command line.

That gets used when it's installing gems.

As usual, hit Ctrl+O to write out the file and Ctrl+X to exit.

Now, let's visit the site for the project will be cloning.

It's a project here on Github.

The link's in the show notes if you want it and

I'm going to get its clone URL .I'm not going to use the SSH URL.

I'm going to use the Https URL.

I'm going to select that, copy it.

Switch back to my terminal and I'm going to run the command git clone and the URL.

That will clone the app down from Github.

In a moment, we're going to change it to the apps directory and

use bundler to install its dependent gems.

But first, we're going to need the bundler gem installed.

So, we'll do that with the command gem.

Install bundler.

No need to put the word suedo before it.

Hit return.

It'll install bundler and then,

we can change the app directory and run bundle install.

It will take a few minutes to download rails and all its dependent gems.

And when it goes back to the command line, your install will be complete.

Since we've never run this Rails app in the production environment before,

the database doesn't exist there.

Also, since this is a brand new instance of the rails app,

we should load the schema for the database.

We shouldn't create it by running migrations.

Rails has a sub command that'll do all that for us.

First, we need to ensure that it's running in the production environment.

Not development or testing.

So, we do that by specifying the RAILS_ENV

environment variable here on the command line.

And we're going to set that to the string production.

Type a space and then right after that, we're going to run the bin/rails command.

So, this set up here will run the bin/rails command

with the rails nth environment variable set to production.

With all that set, we're going to run the sub command db:setup.

Db:setup is like several other commands rolled into one.

It'll create a database for us and then, it'll automatically load the schema for

that database.

Hit return to run it and

it will create a database for us and load the schema into it.

Okay with all that done, our app should be ready to test.

Let's give it a try.

We're going to run the exact same command.

RAILS EMV production bin slash rails,

but we're going to run the server sub-command this time.

It'll start up and note, that it's running on port 3000.

We'll be showing you how to hook it into a web server

running on port 80 in a later workshop.

But we'll just connect to it on port 3000 for now.

In a browser address bar,

type the public IP address of your server, followed by the port.

In my case, I'm running my server in VirtualBox on my local machine.

So, I'll connect 127.0.0.1:3000 So that's 127.0.0.1:3000.

For info on finding your server's public

IP address, see the teacher's notes.

So, I hit Enter to attempt to load the page but what I see is,

127.0.0.1 refused to connect.

There's a variety of reasons this can happen.

You should see the teacher's notes and it's for some troubleshooting help.

But in my case, it's because port 3000 on my virtual machine can't be reached.

So, I'm going to go to virtual box and bring up the settings for

my virtual server.

Go to the network tab and expand the advanced settings and

click on the port forwarding button.

And we currently have rules set up to forward port 80 to port 8080 on the host.

As well as port 22 to port 2222, but we don't have anything for port 3000.

So, let's go ahead and add that one now.

I'm going to go and give this rule this rule a name of H-T-T-P for development.

Protocol as always is, going to be T-C-P.

I won't specify a host I-P, so that'll match any host.

And it's actually okay if I forward to the exact same host on the port

that I'm getting from the guest.

Because there isn't going to be a service already running on port three thousand in

my case.

So, I'll forward all traffic received on host port 3,000 to port

3,000 on the guest.

Click OK and OK again to save the changes and they should take effect immediately.

So, let me go back to my browser and try sending the request again to port 3,000.

I actually connect successfully this time, but I see the error.

An unhandled low level error occurred.

The application logs may have details.

If I go back to my terminal, we'll see the rails log there.

And we see a RuntimeError.

Missing secret_key_base for the production environment.

Set this value in config/secret.yml.

So, this looks like something we're going to need to fix in our configuration.

Let's take a look at that file it recommends.

So, we're going to fire up the Nano editor and

we're going to edit the file it requests.

Config, directory,

secrets.yml and

down here at the bottom, we see a warning in the comments.

Do not keep production secrets in the repository.

Instead, read the values from the environment.

By repository, it means our GitHub, our source code repo.

And it suggests that instead, we should read values from an environment variable.

That's precisely what it's doing here.

It's got the secret key base setting for the production environment.

Just like it does for the development and test environments.

But it's using an ERB tag to load it from an environment variable.

So all we have to do is, set that environment variable and

it will be loaded here.

So, I'm going to go ahead an exit out of this without making any changes.

So, first we need to generate the secret key.

Then, we're going to need a way to store it in an environment variable without

checking any kind of script into our Git repository.

So we're going to need a place to store that environment variable.

There's an RBM plugin named RBM VARs that can help us.

Here's its page on Github.

Basically as its description says, RBM Fars is a plugin for our RBM.

That lets you set global and

project specific environment variables before spawning Ruby processes.

Sounds like just what we need.

There's a command here that you can copy and paste into a terminal to install it.

So, let's copy it, Switch to our server terminal and paste it here.

It'll clone the rbenv-vars plugin repository into our rbenv plugins

directory and after that, it will be installed.

Now, let's run the command that will generate a rail secret key for

a spin slash rails secret.

It will generate this big long hexadecimal string, which will copy to our clipboard.

Environment variables for

rbrnv fars get stored in a hidden conflict file within your Rails apps directory.

So, let's edit file now.

We'll run our nano editor and

will edit the file name to dot rbenv dash bars.

The dot at the start of course,

keeps the files hidden from an ordinary directory listing.

Hit inner, it'll create the file, if it doesn't exist already.

And the format for

this file is just the name of the environment variable you want to set.

Which in this case is, secret underscore key underscore base.

All caps, an equal sign and then,

the value you want to assign to it, which we'll paste here.

Make sure there are no spaces surrounding the equal sign.

Okay, that should be all we need, so let's hit control O to write out the file.

Hit enter to confirm the file name and hit Control x to exit.

Now, let's try running our real server again.

I'll just bring up the command from before,

RAILs_ENV=production bin/rails server.

Okay, and let's go back to our browser and try reloading the page again.

The page loads successfully.

We're also able to click the link to create a new signature.

And it will be saved to the database.