Docker deployment in Ruby on Rails - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is Docker in the context of Rails deployment?

Docker is a tool that packages your Rails app and its environment into a container. This container runs the app the same way everywhere, making deployment easier and consistent.

beginner

What is a Dockerfile and why is it important for Rails apps?

A Dockerfile is a simple text file with instructions to build a Docker image. For Rails, it defines the Ruby version, copies app files, installs gems, and sets up the app environment.

intermediate

How does Docker Compose help in deploying a Rails app?

Docker Compose lets you define and run multi-container apps. For Rails, it can start the app container, a database container, and others together with one command.

intermediate

Why should you use volumes in Docker when developing a Rails app?

Volumes let you share code between your computer and the Docker container. This means you can edit code on your computer and see changes immediately inside the container.

beginner

What is the role of environment variables in Docker deployment for Rails?

Environment variables store settings like database passwords or secret keys outside the code. Docker uses them to keep sensitive info safe and configure the app for different environments.

What does a Dockerfile typically specify for a Rails app?

A Ruby version, app files, gems, and commands to run the app

B Only the database configuration

C The HTML templates for the app

D User interface styles

A Dockerfile sets up the environment including Ruby version, copies app files, installs gems, and defines how to run the app.

Which command starts all services defined in a Docker Compose file?

A docker-compose up

B docker build

C docker run

D docker start

The 'docker-compose up' command starts all containers defined in the docker-compose.yml file together.

Why use Docker volumes during Rails development?

A To speed up the internet connection

B To share code changes instantly between host and container

C To increase CPU power

D To change the app's color scheme

Volumes sync code between your computer and the container, so changes appear immediately without rebuilding the image.

What is the main benefit of using Docker for Rails deployment?

A Faster coding speed

B Automatic bug fixing

C Consistent environment across all machines

D Free hosting

Docker ensures the app runs the same way everywhere by packaging the environment with the app.

How do environment variables help in Docker deployment?

A They create user accounts automatically

B They change the app's font size

C They speed up the app's loading time

D They keep sensitive info like passwords outside the code

Environment variables store sensitive data securely and allow easy configuration without changing code.

Explain how Docker and Docker Compose work together to deploy a Rails application.

Think about building and running containers for app and database.

Describe the purpose of using environment variables in Docker deployment for Rails apps.

Why not put secrets directly in your code?

Practice

1. What is the main purpose of using Docker for deploying a Rails application?

easy

A. To package the app and its environment together for consistent deployment

B. To write Rails code faster

C. To replace the Rails framework

D. To automatically fix bugs in the app

Solution

1. Step 1: Understand Docker's role

   Docker packages the app with all dependencies so it runs the same everywhere.

2. Step 2: Compare options

   Options B, C, and D describe unrelated or incorrect uses of Docker.

3. Final Answer:

   To package the app and its environment together for consistent deployment -> Option A

4. Quick Check:

   Docker deployment = packaging app + environment [OK]

Hint: Docker bundles app + environment for consistent runs [OK]

Common Mistakes:

• Thinking Docker speeds up coding
• Confusing Docker with Rails framework
• Believing Docker fixes app bugs automatically

2. Which line correctly exposes port 3000 in a Dockerfile for a Rails app?

easy

A. EXPOSE port 3000

B. EXPOSE '3000'

C. EXPOSE:3000

D. EXPOSE 3000

Solution

1. Step 1: Recall Dockerfile syntax for exposing ports

   The correct syntax is simply EXPOSE followed by the port number without quotes or extra words.

2. Step 2: Evaluate options

   EXPOSE 3000 matches the correct syntax. Options A, B, and D have invalid syntax.

3. Final Answer:

   EXPOSE 3000 -> Option D

4. Quick Check:

   Expose port syntax = EXPOSE 3000 [OK]

Hint: Use EXPOSE followed by port number without quotes [OK]

Common Mistakes:

• Adding quotes around port number
• Writing extra words like 'port'
• Using colon instead of space

3. Given this Dockerfile snippet for a Rails app:

FROM ruby:3.1
WORKDIR /app
COPY . .
RUN bundle install
EXPOSE 3000
CMD ["rails", "server", "-b", "0.0.0.0"]

What happens when you run this container and visit http://localhost:3000 on your host machine?

medium

A. You can access the Rails app running inside the container

B. The app will not be accessible because the port is not exposed

C. The app will crash because of missing files

D. The server will bind only to localhost inside the container

Solution

1. Step 1: Analyze Dockerfile commands

   The Dockerfile exposes port 3000 and runs Rails server bound to 0.0.0.0, allowing external access.

2. Step 2: Understand port exposure and binding

   Exposing port 3000 and binding to 0.0.0.0 lets the host access the app via localhost:3000.

3. Final Answer:

   You can access the Rails app running inside the container -> Option A

4. Quick Check:

   Expose + bind 0.0.0.0 = accessible app [OK]

Hint: Bind Rails to 0.0.0.0 and expose port to access app [OK]

Common Mistakes:

• Thinking EXPOSE alone publishes port to host
• Binding server only to localhost inside container
• Assuming missing files cause crash without evidence

4. You wrote this Dockerfile for your Rails app:

FROM ruby:3.1
WORKDIR /app
COPY . .
RUN bundle install
EXPOSE 3000
CMD ["rails", "server"]

Why might your app not be accessible from your host machine at http://localhost:3000?

medium

A. Because the port 3000 is not exposed in the Dockerfile

B. Because the Rails server is not bound to 0.0.0.0, so it listens only inside the container

C. Because the WORKDIR is incorrect

D. Because bundle install was not run

Solution

1. Step 1: Check server binding in CMD

   The CMD runs 'rails server' without '-b 0.0.0.0', so it binds to localhost inside container only.

2. Step 2: Understand port exposure and binding

   Even though port 3000 is exposed, binding only to localhost prevents external access from host machine.

3. Final Answer:

   Because the Rails server is not bound to 0.0.0.0, so it listens only inside the container -> Option B

4. Quick Check:

   Missing bind 0.0.0.0 = no host access [OK]

Hint: Always bind Rails server to 0.0.0.0 for external access [OK]

Common Mistakes:

• Assuming EXPOSE publishes port to host automatically
• Thinking WORKDIR affects network access
• Believing bundle install affects accessibility

5. You want to deploy a Rails app with Docker and ensure the app reloads code changes during development inside the container. Which Dockerfile and command setup is best?

hard

A. Copy code once in Dockerfile and run: rails server without binding

B. Expose port 3000 but do not bind Rails server to 0.0.0.0

C. Use a volume to mount your app code and run: rails server -b 0.0.0.0

D. Run Rails server with rails server -b localhost and no volume

Solution

1. Step 1: Understand code reload needs

   For code changes to reflect immediately, the app code must be mounted as a volume, not copied once.

2. Step 2: Ensure external access

   Binding Rails server to 0.0.0.0 allows access from host machine.

3. Step 3: Evaluate options

   Use a volume to mount your app code and run: rails server -b 0.0.0.0 mounts code and binds correctly. Others miss volume or binding, causing no reload or no access.

4. Final Answer:

   Use a volume to mount your app code and run: rails server -b 0.0.0.0 -> Option C

5. Quick Check:

   Volume + bind 0.0.0.0 = live reload + access [OK]

Hint: Mount code volume and bind server to 0.0.0.0 for dev [OK]

Common Mistakes:

• Copying code only once, missing live reload
• Not binding server to 0.0.0.0
• Binding server to localhost disables host access