Heroku deployment in Ruby on Rails - Deep Dive

Overview - Heroku deployment

What is it?

Heroku deployment is the process of publishing a Rails application to the Heroku cloud platform so it can be accessed by users on the internet. Heroku provides a simple way to host web apps without managing servers. It handles the infrastructure, letting developers focus on their code and app features.

Why it matters

Without Heroku or similar platforms, developers would need to manage servers, networking, and scaling themselves, which is complex and time-consuming. Heroku makes deploying apps fast and easy, so ideas can reach users quickly. This speeds up development and reduces technical barriers for beginners and teams.

Where it fits

Before deploying to Heroku, you should know basic Rails app development and Git version control. After mastering Heroku deployment, you can learn advanced cloud concepts like continuous integration, scaling, and monitoring apps in production.

Mental Model

Core Idea

Heroku deployment is like sending your finished app in a package to a cloud warehouse that automatically sets it up and makes it available online.

Think of it like...

Imagine you baked a cake (your Rails app) and want to sell it. Instead of building your own shop, you send it to a big bakery (Heroku) that displays and sells your cake to customers without you worrying about the shop's details.

┌───────────────┐      git push heroku main      ┌───────────────┐
│ Local Rails   │ ---------------------------> │ Heroku Cloud  │
│ App & Git    │                              │ Platform      │
└───────────────┘                              └───────────────┘
          │                                              │
          │                                              ▼
          │                                   ┌───────────────────┐
          │                                   │ App is built,     │
          │                                   │ dependencies      │
          │                                   │ installed, and    │
          │                                   │ web server runs   │
          │                                   └───────────────────┘
          │                                              │
          │                                              ▼
          │                                   ┌───────────────────┐
          │                                   │ App is live on    │
          │                                   │ internet at URL   │
          │                                   └───────────────────┘

Build-Up - 8 Steps

1

Foundation

Understanding Heroku and Its Role

Concept: Learn what Heroku is and why it helps developers deploy apps easily.

Heroku is a cloud platform that hosts web applications. It removes the need to manage servers or infrastructure. Developers push their code to Heroku, which then runs the app and makes it accessible online. It supports many languages including Ruby on Rails.

Result

You understand Heroku as a service that simplifies app hosting and deployment.

Knowing Heroku's purpose helps you see why deployment is easier and faster compared to managing your own servers.

2

Foundation

Preparing a Rails App for Deployment

Concept: Learn the basic setup steps needed in a Rails app before deploying to Heroku.

You need a Git repository for your app, a 'Gemfile' listing dependencies, and a 'Procfile' to tell Heroku how to run your app. Also, ensure your app uses environment variables for secrets and database config. This preparation makes deployment smooth.

Result

Your Rails app is ready to be pushed to Heroku without errors.

Preparing your app correctly prevents common deployment failures and makes Heroku understand how to run your app.

3

Intermediate

Deploying Rails App Using Git Push

🤔Before reading on: Do you think 'git push heroku main' uploads your code and automatically runs your app? Commit to your answer.

Concept: Learn how pushing code to Heroku triggers build and deployment processes.

After setting up Heroku CLI and linking your app, running 'git push heroku main' sends your code to Heroku. Heroku detects the Rails app, installs gems, compiles assets, sets up the database, and starts the web server automatically.

Result

Your app is live on a Heroku URL and accessible from any browser.

Understanding that 'git push' triggers a full build and deploy cycle helps you troubleshoot and optimize deployment.

4

Intermediate

Managing Environment Variables and Secrets

🤔Before reading on: Should you store API keys directly in your Rails code or use Heroku config vars? Commit to your answer.

Concept: Learn to use Heroku config vars to keep secrets safe and configurable.

Heroku lets you set environment variables using 'heroku config:set'. Your Rails app accesses these via ENV variables. This keeps sensitive info like API keys out of your codebase and allows different values per environment.

Result

Your app uses secure, flexible configuration without exposing secrets in code.

Knowing how to manage secrets securely is critical for safe production apps and easier configuration changes.

5

Intermediate

Using Heroku Add-ons for Databases

Concept: Learn how to add and connect a database to your Rails app on Heroku.

Heroku offers add-ons like Heroku Postgres. You can add it with 'heroku addons:create heroku-postgresql'. Heroku sets DATABASE_URL environment variable automatically. Rails uses this to connect to the database without manual config.

Result

Your app has a live database connected and ready for data storage.

Understanding add-ons simplifies adding essential services without manual setup or complex config.

6

Advanced

Handling Asset Precompilation and Buildpacks

🤔Before reading on: Do you think Heroku automatically compiles Rails assets every time you deploy? Commit to your answer.

Concept: Learn how Heroku uses buildpacks to prepare your app, including asset compilation.

Heroku uses buildpacks to detect your app type and run build steps. For Rails, it runs 'assets:precompile' to prepare CSS and JavaScript for production. You can customize buildpacks or add multiple for extra functionality.

Result

Your app serves optimized assets, improving load speed and user experience.

Knowing buildpacks and asset compilation helps you optimize deployment and fix related errors.

7

Advanced

Scaling and Managing Dynos in Production

🤔Before reading on: Is scaling on Heroku as simple as increasing dyno count? Commit to your answer.

Concept: Learn how Heroku runs your app in dynos and how to scale them.

Heroku runs apps in lightweight containers called dynos. You can scale by increasing dyno count or size using 'heroku ps:scale web=2'. This handles more traffic. You also learn about dyno sleeping, restart, and logs for monitoring.

Result

Your app can handle more users and you can monitor its health effectively.

Understanding dynos and scaling is key to running reliable, performant apps in production.

8

Expert

Optimizing Deployment with Pipelines and Review Apps

🤔Before reading on: Do you think Heroku pipelines only help with deployment speed? Commit to your answer.

Concept: Learn advanced Heroku features like pipelines and review apps for team workflows.

Heroku pipelines let you create stages like development, staging, and production. Review apps automatically create temporary apps for each pull request, enabling testing before merging. This improves collaboration and deployment safety.

Result

Your team can deploy, test, and release changes smoothly with minimal risk.

Knowing pipelines and review apps transforms deployment from a manual step to an integrated, automated workflow.

Under the Hood

When you push code to Heroku, the platform receives your Git repository and runs a build process using buildpacks. These scripts detect your app type and install dependencies like Ruby gems. Then, Heroku compiles assets and prepares the environment. It creates dynos, which are isolated containers running your app processes. Environment variables configure runtime behavior. Heroku routes web traffic to your dynos and manages scaling and restarts automatically.

Why designed this way?

Heroku was designed to abstract away server management, letting developers focus on code. Using buildpacks allows support for many languages without custom setup. Dynos provide lightweight, isolated environments for apps, enabling easy scaling and reliability. This design balances simplicity for beginners with power for experts.

┌───────────────┐
│ Git Push Code │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Buildpacks    │
│ - Detect app  │
│ - Install deps│
│ - Compile     │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Dyno Manager  │
│ - Create dynos│
│ - Set ENV     │
│ - Start app   │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Router        │
│ - Direct HTTP │
│   requests    │
│ - Manage load │
└───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does pushing code to Heroku instantly make your app live without any build steps? Commit yes or no.

Common Belief: Pushing code to Heroku immediately runs the app without any preparation.

Reality: Heroku runs a build process including dependency installation and asset compilation before the app runs.

Why it matters: Ignoring build steps can cause confusion when the app doesn't work as expected after deployment.

Quick: Can you store your database password directly in your Rails code safely on Heroku? Commit yes or no.

Common Belief: It's fine to hardcode secrets like database passwords in your app code on Heroku.

Reality: Secrets should be stored in Heroku config vars (environment variables) to keep them secure and configurable.

Why it matters: Hardcoding secrets risks exposing sensitive data and makes changing them harder.

Quick: Does scaling dynos always mean your app will handle infinite traffic? Commit yes or no.

Common Belief: Simply increasing dyno count guarantees unlimited app scalability.

Reality: Scaling helps but app design, database limits, and other factors also affect capacity.

Why it matters: Over-relying on dyno scaling without optimizing app can lead to poor performance and high costs.

Quick: Are Heroku pipelines only useful for big teams? Commit yes or no.

Common Belief: Pipelines are only for large teams and complex projects.

Reality: Pipelines help any size team automate testing and deployment safely.

Why it matters: Missing pipelines can cause manual errors and slow down development even in small projects.

Expert Zone

1

Heroku dynos have an ephemeral filesystem, so any file changes during runtime are lost on restart; persistent storage requires add-ons or external services.

2

Buildpacks can be customized or combined to support complex build steps, enabling advanced app setups beyond default Rails behavior.

3

Heroku's routing layer uses a load balancer that can cause sticky sessions issues; understanding this helps design stateless apps or use session stores.

When NOT to use

Heroku is not ideal for apps needing persistent local storage, very high custom server configurations, or extremely low latency. Alternatives include AWS EC2, DigitalOcean droplets, or container orchestration platforms like Kubernetes.

Production Patterns

Professionals use Heroku pipelines for continuous delivery, add-ons for databases and caching, and monitor logs with Heroku's logging tools. They automate deployments with CI/CD tools and use review apps for safe feature testing.

Connections

Continuous Integration/Continuous Deployment (CI/CD)

Heroku deployment builds on CI/CD principles by automating build, test, and release steps.

Understanding Heroku deployment helps grasp how CI/CD pipelines automate software delivery in modern development.

Containerization (Docker)

Heroku dynos are lightweight containers similar to Docker containers but managed by Heroku.

Knowing Heroku dynos clarifies container concepts and differences between managed and self-managed container platforms.

Supply Chain Management (Logistics)

Deploying an app to Heroku is like managing a supply chain where code is packaged, shipped, and delivered efficiently.

Seeing deployment as a supply chain highlights the importance of automation, quality checks, and delivery speed in software releases.

Common Pitfalls

#1 Pushing code without a Procfile causes Heroku not to know how to start the app.

Wrong approach:

git push heroku main
# No Procfile in project

Correct approach:

Create a Procfile with: web: bundle exec puma -C config/puma.rb
Then git push heroku main

Root cause:

Not providing a Procfile leaves Heroku without instructions to run the web server.

#2 Hardcoding database credentials in config/database.yml instead of using DATABASE_URL.

Wrong approach:

production:
adapter: postgresql
database: mydb
username: user
password: pass

Correct approach:

production:
url: <%= ENV['DATABASE_URL'] %>

Root cause:

Ignoring Heroku's environment variable for database connection causes config mismatch and connection failures.

#3 Committing secrets like API keys directly to Git and pushing to Heroku.

Wrong approach:

config/initializers/secret.rb:
API_KEY = 'mysecretapikey'
# Committed to Git

Correct approach:

Set with heroku config:set API_KEY='mysecretapikey'
Access in app with ENV['API_KEY']

Root cause:

Not using environment variables exposes secrets and breaks best security practices.

Key Takeaways

Heroku deployment lets you publish Rails apps easily by handling servers and infrastructure for you.

Preparing your app with Git, a Procfile, and environment variables is essential for smooth deployment.

Pushing code triggers a build process that installs dependencies, compiles assets, and starts your app in dynos.

Managing secrets with config vars and using add-ons like databases keeps your app secure and functional.

Advanced features like pipelines and review apps improve team workflows and deployment safety.