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

# How to deploy Ruby on Rails to AWS

> Deploy a Ruby on Rails application to your AWS account on ECS Fargate behind an Application Load Balancer through Ravion.

Deploy Ruby on Rails with its bundled Puma server on ECS Fargate behind an Application Load Balancer.

## Prerequisites

* A Git repository containing your application and its production build command.
* A Ravion account with your AWS account connected. Start free at [Ravion signup](https://app.ravion.com/signup).
* The Ravion CLI installed and authenticated. See [CLI installation](/docs/cli/installation).

The examples use `my-org/my-app` as a placeholder. Replace it with your repository before applying the config.

<Prompt description="Set up this Rails app for Ravion ECS hosting." icon="sparkles" actions={["copy", "cursor"]}>
  1. Before any other action, read and follow [https://www.ravion.com/docs/start-here#agent-workflow](https://www.ravion.com/docs/start-here#agent-workflow) as the mandatory agent workflow.
  2. Use [https://www.ravion.com/docs/deploy/aws/rails](https://www.ravion.com/docs/deploy/aws/rails) as the framework-specific source of truth.
  3. Confirm this repository contains Rails and locate the app root in a monorepo.
  4. Inspect `Gemfile`, Rails config, Docker files, credentials, assets, and scripts to detect the real Puma start command, port, health path, and migration or asset steps; bind to `0.0.0.0`.
  5. Generate `ravion.yaml` with `rvn-aws-network` + `rvn-ecs-cluster` + `rvn-ecs-web` + `rvn-rds`, using Secrets Manager for `DATABASE_URL` and `RAILS_MASTER_KEY` rather than inventing RDS references.
  6. Ask the user for AWS account IDs, repository slugs, project IDs, or database credentials before proceeding; do not guess.
</Prompt>

## Configure the deployment

Rails binds to localhost by default, so the production command must bind to `0.0.0.0`.

This example uses [Railpack](https://railpack.com) for the build. Use `build_source: dockerfile` instead when you need a custom Dockerfile. Railpack detects Rails from the application files.

Railpack detects Rails through `Gemfile` and `config/application.rb`. It reads the Ruby version from `.ruby-version`, `Gemfile`, or mise files, installs Node when frontend tooling requires it, precompiles assets and Bootsnap, and configures common native dependencies. Set the production start command to `bin/rails server -e production -b 0.0.0.0` when your repository does not provide one. Ravion injects `PORT` automatically from `container_port`.

```yaml ravion.yaml theme={null}
project:
  givenId: rails-app
  name: Rails app
environments:
  - givenId: production
    name: Production
    moduleInstances:
      - givenId: network
        name: Network
        type: rvn-aws-network
        version: 1.0.0
        input:
          aws_account_id: ravion-prod
          aws_region: us-east-1
          name: rails-production
      - givenId: cluster
        name: ECS cluster
        type: rvn-ecs-cluster
        version: 1.0.0
        input:
          network:
            moduleGivenIdRef: network
          name: rails-production
      - givenId: database
        name: PostgreSQL database
        type: rvn-rds
        version: 1.0.0
        input:
          network:
            moduleGivenIdRef: network
          name: rails-production-db
          db_name: rails
          username: rails
          engine_major_version: "15"
      - givenId: web
        name: Rails web service
        type: rvn-ecs-web
        version: 1.0.0
        input:
          cluster:
            moduleGivenIdRef: cluster
          name: rails-production-web
          build_source: railpack
          source_repo: my-org/my-rails-app
          container_port: 3000
          fargate_size:
            vcpu: 0.5
            memory_gb: 1
```

Set `RAILS_MASTER_KEY`, `SECRET_KEY_BASE`, and `DATABASE_URL` as runtime secrets. Populate the database secret from the RDS outputs before applying the service.

## Apply and connect your domain

```bash theme={null}
ravion project create --given-id rails-app --name "Rails app"
ravion project config apply rails-app --file ravion.yaml --dry-run
ravion project config apply rails-app --file ravion.yaml
```

Follow [custom domains](/docs/guides/custom-domains) to connect your domain to the Application Load Balancer.

## Next steps

<CardGroup cols={2}>
  <Card title="Custom domains" icon="globe" href="/docs/guides/custom-domains">
    Point a domain at your deployed service and manage its certificate.
  </Card>

  <Card title="Project config" icon="file-code" href="/docs/config-as-code/project-config-file">
    Preview and apply Ravion configuration from source control.
  </Card>

  <Card title="Pipelines" icon="arrow-progress" href="/docs/config-as-code/pipeline-config-file">
    Add approvals, migrations, and deployment automation.
  </Card>

  <Card title="Logs and metrics" icon="chart-line" href="/docs/modules/logs">
    Inspect deploy output and production health in Ravion.
  </Card>
</CardGroup>