Ruby on Rails mit Docker für die lokale Entwicklungsumgebung

Hallo, Ruby-Entwicklerinnen und -Entwickler! Wenn Sie nach einer effektiven Möglichkeit suchen, Ruby on Rails mit Docker in Ihrer lokalen Entwicklungsumgebung einzurichten, ist dieser Beitrag genau richtig für Sie. Er knüpft an unseren vorherigen Artikel darüber an, wie Sie Ruby unter macOS für die lokale Entwicklung installieren.

Ruby-Entwicklerinnen und -Entwickler müssen bei der Entwicklung eines Ruby-on-Rails-Projekts häufig eine Datenbank sowie weitere Voraussetzungen für die Entwicklungsumgebung berücksichtigen. Es kann jedoch eine Herausforderung sein, sicherzustellen, dass all diese Komponenten auf Ihrem Hostbetriebssystem installiert sind und genau die erforderlichen Versionen verwenden.

Jedes Mal, wenn ich ein neues Projekt erstellen wollte, wünschte ich mir einen Button, der dafür eine neue, saubere Umgebung einrichtet. Deshalb habe ich eine Docker-gestützte Umgebung erstellt, die sich mit Docker docker-compose.yml ganz einfach starten und stoppen lässt.

Was ist Docker Compose?

Docker Compose ist ein Infrastructure-as-Code-Tool (IaC), mit dem Sie Anwendungen und Dienste wie Proxys, Datenbanken und Volume-Mounts konfigurieren und miteinander verbinden können, um sie wiederverwendbar bereitzustellen. Es ist im Docker-Softwarepaket enthalten und wird mit YAML definiert.

Diese Docker-Compose-Konfiguration für eine lokale Entwicklungsumgebung eignet sich für verschiedene Projekttypen und ist nicht nur auf Ruby on Rails beschränkt. Sie kann auch für Nebenprojekte oder clientseitige Frontend-Projekte verwendet werden. Die wichtigsten Gründe, warum ich Docker-Umgebungen Änderungen am eigenen Hostbetriebssystem vorziehe, sind:

• einfach zu konfigurieren

• Logik einfach von der Umgebung zu trennen

• dieselbe Umgebung problemlos für verschiedene Projekte zu verwenden

• die Umgebung problemlos mit allen zu teilen, die Hilfe benötigen, ohne vertraulichen Code weiterzugeben

• der Hostcomputer bleibt sauber

Eine Ruby-on-Rails-Docker-Umgebung

Um eine Ruby-on-Rails-Docker-Umgebung für die lokale Entwicklung einzurichten, benötigen Sie Folgendes:

• Ein Unix-ähnliches Betriebssystem (ich verwende macOS, Sie können aber Ubuntu oder eine andere Linux-Distribution nutzen. Windows sollte ebenfalls funktionieren)

• Git

• make (Version 3.81 oder höher)

• Docker (Version 19.03.12 oder höher)

• docker-compose (Version 1.26.0 oder höher)

• Ihr bevorzugter Texteditor (in meinem Fall Visual Studio Code)

Sobald Sie all das haben, können Sie loslegen. Falls Sie nicht lesen möchten: Hier finden Sie das Open-Source-Repository mit allen erforderlichen Anweisungen und dem vollständigen Quellcode zu den Codeausschnitten, die wir uns ansehen. Da Sie bereits hier sind, folgen Sie einfach dieser Schritt-für-Schritt-Anleitung.

Zunächst erstelle ich der Einfachheit halber ein Ruby-on-Rails-Projekt mit dem Namen foo_bar_project.

1) Rufen Sie die Docker-Compose-Umgebungskonfiguration ab und entfernen Sie das Git-Repository. Wenn Sie alles in einem Git-Quellcode-Repository nachverfolgen möchten, können Sie später Ihr eigenes erstellen.

1git clone git@github.com:mtereschenko/simple_ror_environment.git && cd simple_ror_environment && rm -rf .git

Die nächsten Schritte sollten im Verzeichnis ./environment ausgeführt werden. Stellen Sie also sicher, dass Sie die Befehle dort ausführen:

1cd ./environment

2) Jetzt müssen Sie dieser Umgebungskonfiguration einen Projektnamen zuweisen. Standardmäßig lautet er test_project. Für unseren hier beschriebenen Code müssen wir ihn wie zuvor erläutert in foo_bar_project ändern. Nehmen Sie dazu die Änderungen in der Datei ./environment/.env.example vor und passen Sie den Wert der Variablen PROJECT_NAME an. Verwenden Sie für Variablenwerte unbedingt Snake Case in Kleinbuchstaben:

1PROJECT_NAME=foo_bar_project

3) Als Nächstes können Sie Ihr Projekt mit dem folgenden Befehl erstellen:

1make init

Wie Sie sehen, gibt es jetzt einen neuen Ordner namens application, der Ruby-on-Rails-Code enthält.

4) Jetzt müssen Sie Ihre lokale Entwicklungsumgebung mit Docker Compose erstellen. Dieser Schritt ist nach jeder Änderung an der Dockerfile oder Gemfile Ihrer Anwendung erforderlich.

1make build

5) Damit können Sie nun die lokale Ruby-Entwicklungsumgebung wie folgt starten:

1make start

Beachten Sie, dass dadurch noch keine Ruby-on-Rails-Anwendung gestartet wird. Dazu müssen wir eine Shell in der Docker-Umgebung öffnen und sie anweisen, den Prozess rails zu starten. So geht's:

1make shell
2rails s -p 3000 –binding=0.0.0.0

Ruby on Rails mit Docker für die lokale Entwicklungsumgebung. Wenn Sie schließlich Ihren Browser öffnen und diese URL aufrufen: http://foo_bar_project.localhost/, sollten Sie das gerade erstellte Ruby-on-Rails-Projekt sehen.

Was steht uns jetzt also zur Verfügung?

• Wir haben ein Projekt mit einem Umgebungsverzeichnis, das alles enthält, was wir zum Ausführen des Projekts benötigen, und einem Anwendungsverzeichnis mit unserem Anwendungscode. Dieses Verzeichnis ist in den Docker-Container eingebunden, sodass Sie über das Ruby-Docker-Image uneingeschränkten Zugriff darauf haben.

• Wir können schnell auf die Ruby-Shell zugreifen und müssen daher keine Ruby-Umgebung wie Rails, Rake, Bundler oder eine andere Ruby-Toolchain lokal installieren.

• Befehle können nach dem Befehl make shell ausgeführt werden.

• Diese Docker-Compose-Konfiguration des Projekts umfasst zwei vorkonfigurierte Stages. Wenn Sie Ihre Ruby-Anwendung also einmal bereitstellen möchten, können Sie eine eigene Stage erstellen. So einfach ist das!

Wenn Sie wissen möchten, wie die oben beschriebene Docker-Umgebung für Ruby on Rails funktioniert, sehen wir uns die einzelnen Komponenten an: das Ruby-Docker-Image, die Makefile und die Docker-Compose-Definition, die alles zusammenbringt.

Ein Ruby-Docker-Image

Zunächst ist das Ruby-Docker-Image ein wesentlicher Bestandteil. Es ist wichtig, es richtig zu erstellen, damit der Cache der Docker-Image-Layer effektiv wiederverwendet werden kann und auch andere Anforderungen einer lokalen Entwicklungsumgebung erfüllt werden.

Hier sehen Sie die Dockerfile für das Ruby-Docker-Image:

1FROM ruby:2.7.6-alpine3.16 as base_image
2RUN apk add --no-cache git \
3    build-base \
4    libpq-dev \
5    tzdata
6
7FROM base_image as development
8COPY ./artifacts/rails/Gemfile /tmp/Gemfile
9COPY ./artifacts/rails/Gemfile.lock /tmp/Gemfile.lock
10COPY ./containers/ruby/runners/runner.development.sh /rdebug_ide/runner.sh
11RUN cd /tmp && \
12  gem install ruby-debug-ide && \
13  gem install debase && \
14  bundle install && \
15  chmod +x /rdebug_ide/runner.sh && \
16  apk add --no-cache git \
17  nodejs \
18  yarn
19WORKDIR /app
20
21ENTRYPOINT ["tail", "-f", "/dev/null"]
22
23FROM base_image as init
24COPY ./containers/ruby/initializers/runner.init.sh /tmp/runner.sh
25COPY ./containers/ruby/initializers/database.yml /tmp/database.yml
26COPY ./containers/ruby/initializers/.gitignore /tmp/.gitignore
27COPY ./containers/ruby/initializers/development.rb /tmp/development.rb
28RUN chmod +x /tmp/runner.sh
29
30WORKDIR /app
31
32ENTRYPOINT ["/tmp/runner.sh"]

Wie Sie sehen, werden einige Annahmen zu den zusätzlich erforderlichen Konfigurationen getroffen, damit eine funktionsfähige Ruby-on-Rails-Anwendungsumgebung bereitsteht. Dazu gehören:

• die Datei database.yml, die mit den Verbindungsdetails für die Ruby-on-Rails-Datenbank befüllt wird

• development.rb für die Ruby-on-Rails-Laufzeitkonfiguration der Entwicklungsumgebung

Dazu wird das Skript runners.sh im Verzeichnis ./environment/containers/ruby/initializers verwendet:

1#!/bin/ash
2
3cd /app
4
5gem install rails
6
7rails new . -d=postgresql --skip-git
8
9yes | cp -rf /tmp/database.yml /app/config/database.yml
10yes | cp -rf /tmp/development.rb /app/config/environments/development.rb
11cp /tmp/.gitignore /app/.gitignore

Diese Dockerfile nutzt außerdem Docker-Multistage-Builds, sodass bestimmte Teile bei Bedarf effektiv in verschiedenen Umgebungen wiederverwendet werden können, wenn Sie dieselbe Konfiguration für unterschiedliche Workflows wie Tests oder Staging einsetzen möchten.

Eine Rails-Docker-Compose-Konfiguration

Die Docker-Compose-Datei unter `./environment/docker-compose.development.yml` verbindet alle Dienste zu einer funktionsfähigen Ruby-on-Rails-Anwendung in Docker:

• Ein nginx-HTTP-Server

• Eine Ruby-Anwendung

• Ein PostgreSQL-Datenbankserver

Hier sehen Sie die von dieser Konfiguration verwendete Rails-Docker-Compose-Datei:

1version: '3.7'
2services:
3  nginx:
4    image: "${PROJECT_NAME}/nginx:development"
5    container_name: ${PROJECT_NAME}-nginx
6    build: 
7      context: ./
8      dockerfile: ./containers/nginx/Dockerfile
9    depends_on:
10      - ruby
11    tty: true
12    ports:
13      - 80:80
14    volumes:
15      - ./`artifacts`/nginx/:/`var`/log/nginx:cached
16   ruby:
17    image: "${PROJECT_NAME}/ruby:development"
18    container_name: ${PROJECT_NAME}-ruby
19    depends_on:
20      - postgres
21    build:
22      context: ./
23      dockerfile: ./containers/ruby/Dockerfile
24      target: development
25    ports:
26      - 13030:13030
27    volumes:
28      - ${APP_PATH}:/app:cached
29    environment:
30      DB_NAME: ${DB_NAME}
31      PROJECT_NAME: ${PROJECT_NAME}
32      DB_USER: ${DB_USER}
33      DB_PASSWORD: ${DB_PASSWORD}
34      DB_PORT: ${DB_PORT}
35      PUMA_WORKERS: 0
36      RAILS_MAX_THREADS: 1
37     postgres:
38    image: "${PROJECT_NAME}/postgres:development"
39    container_name: ${PROJECT_NAME}-postgres
40    environment:
41      POSTGRES_DB: ${DB_NAME}
42      POSTGRES_USER: ${DB_USER}
43      POSTGRES_PASSWORD: ${DB_PASSWORD}
44    build:
45      context: ./
46      dockerfile: ./containers/postgres/Dockerfile
47    ports:
48      - ${DB_PORT}:5432
49    volumes:
50      - postgres_volume:/var/lib/postgresql/data
51
52volumes:
53  postgres_volume:

Makefile für Docker

Um Entwicklerinnen und Entwicklern schließlich eine leicht zugängliche Schnittstelle für die Interaktion mit dieser lokalen Ruby-Entwicklungsumgebung bereitzustellen, wird ein Makefile verwendet:

1.PHONY: help
2# Make stuff
3
4-include .env
5
6export DOCKER_BUILDKIT=1
7export COMPOSE_DOCKER_CLI_BUILD=1
8
9.DEFAULT_GOAL := help
10
11ARTIFACTS_DIRECTORY := "./artifacts"
12
13CURRENT_PATH :=${abspath .}
14
15SHELL_CONTAINER_NAME := $(if $(c),$(c),ruby)
16BUILD_TARGET := $(if $(t),$(t),development)
17
18help: ## Help.
19@grep -E '^[a-zA-Z-]+:.*?## .*$$' Makefile | awk 'BEGIN {FS = ":.*?## "}; {printf "[32m%-27s[0m %s\n", $$1, $$2}'
20
21init: ## Project installation.
22@rm -f ./.env
23@cp .env.example .env
24@make init_app_directory
25@make create_postgress_volume
26@docker-compose -f docker-compose.init.yml build
27@docker-compose -f docker-compose.init.yml up
28
29build: ## Build images.
30@make create_project_artifacts
31@cp ${APP_PATH}/Gemfile "${ARTIFACTS_DIRECTORY}/rails/Gemfile"
32@cp ${APP_PATH}/Gemfile.lock "${ARTIFACTS_DIRECTORY}/rails/Gemfile.lock"
33@docker-compose -f docker-compose.$(BUILD_TARGET).yml build
34
35shell: ## Internal image bash command line.
36@if [[ -z `docker ps | grep ${SHELL_CONTAINER_NAME}` ]]; then \
37echo "${SHELL_CONTAINER_NAME} is NOT running (make start)."; \
38else \
39docker-compose -f docker-compose.$(BUILD_TARGET).yml exec $(SHELL_CONTAINER_NAME) /bin/ash; \
40fi
41
42start: ## Start previously builded application images.
43@make create_project_artifacts
44@make start_postgres
45@make start_ruby
46@make start_nginx
47
48run: ## Run ruby debugger session.
49@docker-compose -f docker-compose.$(BUILD_TARGET).yml exec ruby /bin/ash /rdebug_ide/runner.sh
50
51start_ruby: ## Start ruby image.
52@if [[ -z `docker ps | grep ruby` ]]; then \
53docker-compose -f docker-compose.$(BUILD_TARGET).yml up -d ruby; \
54else \
55echo "Ruby is running."; \
56fi
57
58start_postgres: ## Start postgres image.
59@if [[ -z `docker ps | grep postgres` ]]; then \
60docker-compose -f docker-compose.$(BUILD_TARGET).yml up -d postgres; \
61else \
62echo "Postgres is running."; \
63fi
64
65start_nginx: ## Start nginx image.
66@if [[ -z `docker ps | grep nginx` ]]; then \
67docker-compose -f docker-compose.$(BUILD_TARGET).yml up -d nginx; \
68else \
69echo "Nginx is running."; \
70fi
71
72stop: ## Stop all images.
73@docker-compose -f docker-compose.$(BUILD_TARGET).yml stop
74
75create_project_artifacts:
76mkdir -p ./artifacts/rails
77mkdir -p ./artifacts/db
78
79init_app_directory:
80@mkdir -p ${APP_PATH}
81
82create_postgress_volume:
83@sed -i '' -r  "s/postgres_volume:/${PROJECT_NAME}_db_volume:/g" docker-compose.development.yml

Ruby-Anwendungen effizient ausführen

Hoffentlich haben Sie nun eine neue Fähigkeit erworben: Ruby-Anwendungen wie Ruby on Rails mithilfe einer Docker-Containerkonfiguration in Ihrer lokalen Umgebung auszuführen. Eine weitere Möglichkeit, Ruby-Anwendungen lokal auszuführen, sind Ruby-Virtual-Environments. Diese haben wir bereits in unserem Beitrag zur Installation von Ruby unter macOS behandelt.

Nachdem Sie Ihre Ruby-Entwicklungsumgebung eingerichtet haben, möchten Sie vielleicht auch erfahren, wie Sie Ihre Ruby-Anwendungen schützen. Weitere Informationen zur Ruby-Sicherheit finden Sie in den folgenden Artikeln:

• Ruby-Gems mit Snyk scannen

• Der umfassende Leitfaden zur Verwaltung von Ruby-Gem-Abhängigkeiten