> ## Documentation Index
> Fetch the complete documentation index at: https://docs.fly.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Getting Started

<img src="https://mintcdn.com/fly-io/izaS1l2UMuz6sm1H/images/rails-intro.webp?fit=max&auto=format&n=izaS1l2UMuz6sm1H&q=85&s=789fb10e6b0c89329abd968177af0ab2" alt="" width="720" height="342" data-path="images/rails-intro.webp" />

In this guide we'll develop and deploy a Rails application that first
demonstrates a trivial view.

In order to start working with Fly.io, you will need `flyctl`, our CLI app for managing apps. If you've already installed it, carry on. If not, hop over to [our installation guide](/flyctl/install). Once that's installed you'll want to [log in to Fly](/getting-started/sign-up-sign-in).

Once you have logged on, here are the three steps and a recap.

## Rails Splash Screen

A newly generated Rails application will display a flashy splash screen when
run in development, but will do absolutely nothing in production until you
add code.

In order to demonstrate deployment of a Rails app on fly, we will create a new application, make
a one line change that shows the splash screen even when run in production mode,
and deploy the application.

### Create an application

Start by verifying that you have Rails installed, and then by
creating a new application:

```shell theme={null}
$ rails --version
$ rails new welcome
$ cd welcome
<CodeGroup>
```

Now use your favorite editor to make a one line change to `config/routes.rb`:

```diff theme={null}
 Rails.application.routes.draw do
  # Define your application routes per the DSL in
  # https://guides.rubyonrails.org/routing.html

  # Reveal health status on /up that returns 200 if the app boots
  # with no exceptions, otherwise 500.
  # Can be used by load balancers and uptime monitors to verify
  # that the app is live.
  get "up" => "rails/health#show", as: :rails_health_check

   # Defines the root path route ("/")
-  # root "articles#index"
+  root "rails/welcome#index"
 end
```

Now that we have an application that does something, albeit something trivial,
let's deploy it.

### Launch

To configure and launch the app, you can use `fly launch` and follow the
wizard.  This demo does not need a database or redis.

<CodeGroup>
  ```bash cmd theme={null}
  fly launch
  ```

  ```output output theme={null}
  Scanning source code
  Detected a Rails app
  Creating app in ~/tmp/welcome
  We're about to launch your Rails app on Fly.io. Here's what you're getting:

  Organization: Jane Developer          (fly launch defaults to the personal org)
  Name:         welcome-proud-sun-3423  (generated)
  Region:       Ashburn, Virginia (US) (this is the fastest region for you)
  App Machines: shared-cpu-1x, 1GB RAM (most apps need about 1GB of RAM)
  Postgres:     <none>                 (not requested)
  Redis:        <none>                 (not requested)
  Tigris:       <none>                 (not requested)

  ? Do you want to tweak these settings before proceeding? (y/N) 
  ```
</CodeGroup>

For demo purposes you can accept the defaults.  You can always change these later.
So respond with "N" (or simply press enter).

This will take a few seconds as it uploads your application, builds a machine image,
deploys the images, and then monitors to ensure it starts successfully. Once complete
visit your app with the following command:

```bash theme={null}
fly apps open
```

That's it!  You are up and running!  Wasn't that easy?

## Arrived at Destination

You have successfully built, deployed, and connected to your first Rails application on Fly.

We've accomplished a lot with only just one line of code and
just one command.

Now that you have seen it up and running, a few things are worth noting:

* No changes were required to your application to get it to work.
* Your application is running on a VM, which starts out based on a
  docker image. To make things easy, `fly launch` generates a
  `Dockerfile` and a `bin/docker-entrypoint` for you which you are free to modify.
* As your application needs change, you can have us update your `Dockerfiles` for you by running: `bin/rails generate dockerfile`.
* There is also a `config/dockerfile.yml` file which keeps track of your
  dockerfile generation options.  This is covered by the
  [FAQ](/rails/getting-started/dockerfiles).
* Other files of note: `.dockerignore` and
  [`fly.toml`](/reference/configuration), both of which
  you can also modify.
  All five files should be checked into your git repository.
* `fly dashboard` can be used to monitor and adjust your application. Pretty
  much anything you can do from the browser window you can also do from the
  command line using `fly` commands. Try `fly help` to see what you can do.
* `fly ssh console` can be used to ssh into your VM. `fly console` can be used to open a rails console.

Now that you have seen how to deploy a trivial application, it is time
to move on to [The Basics](/rails/the-basics).