DEV Community

Cover image for Deploying Rails 8 Applications: A Complete Guide with Docker, Kamal, and Cloudflare
Sulman Baig
Sulman Baig

Posted on • Edited on • Originally published at sulmanweb.com

Deploying Rails 8 Applications: A Complete Guide with Docker, Kamal, and Cloudflare

#docker #rails #ruby #devops

Introduction

When I first started deploying Rails applications, the process felt overwhelming. Today, I'm excited to share a complete guide that transforms this complexity into a straightforward process. Let's dive into deploying a Rails 8 app using Docker, with PostgreSQL containerization, all orchestrated by Kamal on a Hetzner server.

Prerequisites

Before we begin our deployment journey, you'll need:

  • A Rails 8 application ready for production
  • Docker installed locally
  • A Hetzner account
  • Domain name and Cloudflare account
  • 1Password account (for secrets management)
  • Basic SSH knowledge

Step 1: Server and DNS Configuration

Hetzner Server Setup

Let's start by creating our production environment:

  1. Create a Hetzner server with these specifications: 
   - Ubuntu 24.04
   - ARM64 (Ampere) CPU
   - CAX11 size (or choose based on your needs)
   - IPv4 only configuration
   - Your SSH keys added
Enter fullscreen mode Exit fullscreen mode

Cloudflare Configuration

Set up your domain with proper DNS and security settings:

  1. DNS Configuration: 
   - Add A record: @ → your-server-ip (Proxy enabled)
   - Add CNAME: www → @ (Proxy enabled)
Enter fullscreen mode Exit fullscreen mode
  1. SSL/TLS Settings: 
   - Edge Certificates: Enable "Always use HTTPS"
   - Overview: Set SSL/TLS mode to "Full"
Enter fullscreen mode Exit fullscreen mode
  1. Page Rules for www to root redirect: 
   URL: https://www.yourdomain.com/*
   Setting: Forwarding URL
   Status Code: 301 - Permanent Redirect
   Destination URL: https://yourdomain.com/$1
Enter fullscreen mode Exit fullscreen mode

Step 2: Secrets Management

I've learned that proper secrets management is crucial. Let's set it up with 1Password:

  1. Create a secure note in 1Password with these credentials: 
   KAMAL_REGISTRY_PASSWORD: your-docker-registry-password
   RAILS_MASTER_KEY: your-rails-master-key
   POSTGRES_PASSWORD: your-postgres-password
Enter fullscreen mode Exit fullscreen mode
  1. Update .kamal/secrets to handle 1Password integration: 
   SECRETS=$(kamal secrets fetch --adapter 1password --account YOUR_1PASSWORD_ACCOUNT_ID --from YOUR_VAULT_NAME/YOU_SECURE_NOTE KAMAL_REGISTRY_PASSWORD RAILS_PRODUCTION_KEY POSTGRES_PASSWORD)

   KAMAL_REGISTRY_PASSWORD=$(kamal secrets extract KAMAL_REGISTRY_PASSWORD $SECRETS)
   RAILS_MASTER_KEY=$(kamal secrets extract RAILS_PRODUCTION_KEY $SECRETS)
   POSTGRES_PASSWORD=$(kamal secrets extract POSTGRES_PASSWORD $SECRETS)
Enter fullscreen mode Exit fullscreen mode

For more info visit Kamal Secrets.

Step 3: Database Configuration

PostgreSQL Setup

  1. Create config/init.sql for database initialization: 
   CREATE DATABASE IF NOT EXISTS `your_app_production`;
   CREATE DATABASE IF NOT EXISTS `your_app_production_cache`;
   CREATE DATABASE IF NOT EXISTS `your_app_production_queue`;
   CREATE DATABASE IF NOT EXISTS `your_app_production_cable`;
Enter fullscreen mode Exit fullscreen mode
  1. Configure PostgreSQL accessory in config/deploy.yml: 
   accessories:
     postgres:
       image: postgres:16-alpine
       host: your-server-ip
       port: 5432
       options:
         restart: always
       env:
         clear:
           POSTGRES_USER: postgres
           POSTGRES_DB: your_app_production
         secret:
           - POSTGRES_PASSWORD
       files:
         - config/init.sql:/docker-entrypoint-initdb.d/init.sql
       volumes:
         - /var/lib/postgresql/your_app_production:/var/lib/postgresql/data
Enter fullscreen mode Exit fullscreen mode

  1. Update config/database.yml for production:

    production:
    primary: &primary_production
        <<: *default host: <%= ENV["DB_HOST"] %>
        database: your_app_production
        username: postgres
        password: <%= ENV["POSTGRES_PASSWORD"] %>
    cache:
        <<: *primary_production
        database: your_app_production_cache
        migrations_paths: db/cache_migrate
    queue:
        <<: *primary_production 
        database: your_app_production_queue
        migrations_paths: db/queue_migrate
    cable: 
        <<: *primary_production
        database: your_app_production_cable
        migrations_paths: db/cable_migrate

Step 4: Production Environment Configuration

Update config/environments/production.rb with these essential settings:

Rails.application.configure do
  # Asset handling
  config.require_master_key = false
  config.assets.css_compressor = nil
  config.assets.compile = false
  config.public_file_server.enabled = true
  config.asset_host = "https://yourdomain.com"
  config.assets.enabled = true
  config.assets.version = "1.0"

  # SSL and security
  config.ssl_options = { 
    redirect: { 
      exclude: ->(request) { request.path == "/up" } 
    } 
  }

  # Health checks
  config.silence_healthcheck_path = "/up"

  # Domain configuration
  config.hosts = [
    "yourdomain.com",
    /.*\.yourdomain\.com/
  ]

  config.host_authorization = { 
    exclude: ->(request) { request.path == "/up" } 
  }

  # URL options
  config.action_mailer.default_url_options = { 
    host: "yourdomain.com", 
    protocol: "https" 
  }

  routes.default_url_options = {
    host: "yourdomain.com",
    protocol: "https"
  }
end
Enter fullscreen mode Exit fullscreen mode

Step 5: Kamal Deployment Setup

Kamal, Rails 8's built-in deployment tool, makes containerized deployment straightforward:

  1. Update rest of config/deploy.yml: 
service: your_app_name

registry:
  username: your_dockerhub_username
  password:
    - KAMAL_REGISTRY_PASSWORD

aliases:
    console: app exec --interactive --reuse "bin/rails console"
    shell: app exec --interactive --reuse "bash"
    logs: app logs -f
    dbc: app exec --interactive --reuse "bin/rails dbconsole"

image: your_dockerhub_username/your_app_name

builder:
    arch: arm64

proxy:
  ssl: true
  host: yourdomain.com

servers:
  web:
    hosts:
      - your_server_ip

volumes:
  - your_app_storage:/rails/storage:rw
  - /tmp/storage:/rails/tmp/storage:rw
  - your_app_data:/data

env:
  secret:
    - RAILS_MASTER_KEY
    - POSTGRES_PASSWORD
  clear:
    HOST: yourdomain.com
    RAILS_ENV: production
    DB_HOST: your_app-postgres
    SOLID_QUEUE_IN_PUMA: true
    RAILS_SERVE_STATIC_FILES: true
    RAILS_LOG_TO_STDOUT: true
Enter fullscreen mode Exit fullscreen mode

Step 6: Deployment

Now for the exciting part - deploying our application:

  1. Initial setup: 
   bin/kamal setup
Enter fullscreen mode Exit fullscreen mode
  1. Watch the logs to ensure everything starts correctly: 
   bin/kamal logs
Enter fullscreen mode Exit fullscreen mode
  1. For subsequent deployments: 
   bin/kamal deploy
Enter fullscreen mode Exit fullscreen mode

Deployment Verification Checklist

After deployment, I always verify these key points:

  • [ ] Health check endpoint (/up) responds
  • [ ] Database migrations completed successfully
  • [ ] Assets are serving correctly
  • [ ] SSL certificate is valid
  • [ ] www to root domain redirect works
  • [ ] PostgreSQL container is running and accessible

Troubleshooting Tips

From my experience, here are some common issues and solutions:

  1. Database Connection Issues: 
   bin/kamal dbc
Enter fullscreen mode Exit fullscreen mode
  1. Container Inspection: 
   bin/kamal shell
Enter fullscreen mode Exit fullscreen mode
  1. PostgreSQL Logs: 
   bin/kamal accessory logs postgres
Enter fullscreen mode Exit fullscreen mode

For more info go to kamal-deploy.

Conclusion

Deploying a Rails 8 application might seem daunting at first, but with this structured approach, it becomes a manageable and repeatable process. I've learned that proper configuration of each component - from DNS to secrets management to database setup - is crucial for a robust production deployment.

Remember to always test your deployment in a staging environment first, and keep your secrets secure using proper management tools like 1Password.

Have you deployed a Rails application using this approach? I'd love to hear about your experience in the comments below! 🚀

Happy Coding!

Originally published at sulmanweb.com

Top comments (0)