Entwicklungsumgebung für Ruby on Rails-Anwendungen mit Docker Compose erstellen

Erfahren Sie, wie Sie mit Docker Compose eine effiziente Entwicklungsumgebung für Ruby on Rails-Anwendungen einrichten können. Unser Tutorial führt Sie durch den Prozess der Containerisierung, der Synchronisierung von Anwendungscodes und der Konfiguration von Datenbanken und Services.

Entwicklung von Anwendungen kann eine komplexe Aufgabe sein, insbesondere wenn es um die Einrichtung von Entwicklungsumgebungen geht. Docker bietet hier eine elegante Lösung, indem es die Kapselung von Anwendungen in Container ermöglicht. Diese Container sind isoliert, portabel und bieten konsistente Umgebungen, was die Entwicklung, Fehlerbehebung und Bereitstellung von Anwendungen erleichtert.

Die Einrichtung umfasst die folgenden Schritte:

  1. Synchronisieren des Anwendungscodes auf dem Host mit dem Code im Container, um Änderungen während der Entwicklung zu erleichtern.
  2. Persistieren von Anwendungsdaten zwischen Neustarts der Container.
  3. Konfiguration von Sidekiq-Workern, um Jobs wie erwartet zu verarbeiten.

Voraussetzungen

Bevor Sie mit diesem Tutorial beginnen, benötigen Sie:

  • Eine lokale Entwicklungs- oder Serversystem mit Ubuntu 18.04.
  • Docker und Docker Compose installiert gemäß den Anweisungen in den entsprechenden Anleitungen.

Schritt 1: Projekt klonen und Abhängigkeiten hinzufügen

git clone https://github.com/do-community/rails-sidekiq.git rails-docker
cd rails-docker
nano Gemfile

gem ‚pg‘, ‚~>1.1.3′

# Kommentieren Sie sqlite-Gem aus
# gem ’sqlite3′

# Kommentieren Sie spring-watcher-listen-Gem aus
# gem ’spring-watcher-listen‘, ‚~> 2.0.0‘

Schritt 2: Anwendung für PostgreSQL und Redis konfigurieren


default: &default
adapter: postgresql
encoding: unicode
database: <%= ENV[‚DATABASE_NAME‘] %>
username: <%= ENV[‚DATABASE_USER‘] %>
password: <%= ENV[‚DATABASE_PASSWORD‘] %>
port: <%= ENV[‚DATABASE_PORT‘] || ‚5432‘ %>
host: <%= ENV[‚DATABASE_HOST‘] %>
pool: <%= ENV.fetch(„RAILS_MAX_THREADS“) { 5 } %>
timeout: 5000

development:
<<: *default

test:
<<: *default

production:
<<: *default



DATABASE_NAME=rails_development
DATABASE_USER=sammy
DATABASE_PASSWORD=shark
DATABASE_HOST=database
REDIS_HOST=redis

Schritt 3: Dockerfile und Einstiegsskripte schreiben


FROM ruby:2.5.1-alpine

ENV BUNDLER_VERSION=2.0.2

RUN apk add –update –no-cache \
binutils-gold \
build-base \
curl \
file \
g++ \
gcc \
git \
less \
libstdc++ \
libffi-dev \
libc-dev \
linux-headers \
libxml2-dev \
libxslt-dev \
libgcrypt-dev \
make \
netcat-openbsd \
nodejs \
openssl \
pkgconfig \
postgresql-dev \
python \
tzdata \
yarn

RUN gem install bundler -v 2.0.2

WORKDIR /app

COPY Gemfile Gemfile.lock ./

RUN bundle config build.nokogiri –use-system-libraries

RUN bundle check || bundle install

COPY package.json yarn.lock ./

RUN yarn install –check-files

COPY . ./

ENTRYPOINT [„./entrypoints/docker-entrypoint.sh“]


mkdir entrypoints
nano entrypoints/docker-entrypoint.sh

#!/bin/sh

set -e

if [ -f tmp/pids/server.pid ]; then
rm tmp/pids/server.pid
fi

bundle exec rails s -b 0.0.0.0


chmod +x entrypoints/docker-entrypoint.sh

nano entrypoints/sidekiq-entrypoint.sh

#!/bin/sh

set -e

if [ -f tmp/pids/server.pid ]; then
rm tmp/pids/server.pid
fi

bundle exec sidekiq


chmod +x entrypoints/sidekiq-entrypoint.sh

Schritt 4: Definieren von Diensten mit Docker Compose

Mit Docker Compose können wir die für unsere Einrichtung erforderlichen mehreren Container ausführen. Wir werden unsere Kompositions-Dienste in unserer Hauptdatei `docker-compose.yml` definieren. Ein Dienst in Compose ist ein laufender Container, und die Dienstdefinitionen, die Sie in Ihrer `docker-compose.yml`-Datei einschließen, enthalten Informationen darüber, wie jedes Container-Image ausgeführt wird. Das Compose-Tool ermöglicht es Ihnen, mehrere Dienste zu definieren, um Multi-Container-Anwendungen zu erstellen.

Unsere Anwendungseinrichtung wird folgende Dienste umfassen:

  • Die Anwendung selbst
  • Die PostgreSQL-Datenbank
  • Redis
  • Sidekiq

Wir werden auch ein Bind-Mount als Teil unserer Einrichtung einschließen, damit alle Änderungen am Code, die wir während der Entwicklung vornehmen, sofort mit den Containern synchronisiert werden, die auf diesen Code zugreifen müssen.

Öffnen Sie die `docker-compose.yml`-Datei:

Zuerst fügen Sie die Dienstdefinition für die Anwendung hinzu:

version: ‚3.4‘

services:
app:
build:
context: .
dockerfile: Dockerfile
depends_on:
– database
– redis
ports:
– „3000:3000“
volumes:
– .:/app
– gem_cache:/usr/local/bundle/gems
– node_modules:/app/node_modules
env_file: .env
environment:
RAILS_ENV: development

Die Dienstdefinition für die Anwendung umfasst folgende Optionen:

– Build: Definiert die Konfigurationsoptionen für das Erstellen des Anwendungsbilds.
– Depends On: Legt die Abhängigkeiten fest, die vor dem Starten des App-Dienstes bereitgestellt werden müssen.
– Ports: Mappt den Port 3000 des Hosts auf den Port 3000 des Containers.
– Volumes: Definiert die Volumenmontagen für den App-Service.
– Env File und Environment: Legt Umgebungsvariablen fest, die an den Container übergeben werden.

Als nächstes fügen Sie den folgenden Code unterhalb der Anwendungsdienstdefinition hinzu, um Ihren Datenbankdienst zu definieren:

 database:
image: postgres:12.1
volumes:
– db_data:/var/lib/postgresql/data
– ./init.sql:/docker-entrypoint-initdb.d/init.sql

Im Gegensatz zum App-Service zieht der Datenbankdienst ein Postgres-Image direkt von Docker Hub und verwendet das Volume `db_data`, um Anwendungsdaten zwischen Containerstarts zu persistieren.

Fügen Sie dann die Redis-Dienstdefinition hinzu:

Schließlich fügen Sie die Sidekiq-Dienstdefinition hinzu:

 sidekiq:
build:
context: .
dockerfile: Dockerfile
depends_on:
– app
– database
– redis
volumes:
– .:/app
– gem_cache:/usr/local/bundle/gems
– node_modules:/app/node_modules
env_file: .env
environment:
RAILS_ENV: development
entrypoint: ./entrypoints/sidekiq-entrypoint.sh

Unser Sidekiq-Dienst ähnelt unserem App-Dienst in einigen Aspekten. Es verwendet denselben Build-Kontext und dasselbe Image, dieselben Umgebungsvariablen und Volumen. Es ist jedoch abhängig von den App-, Redis- und Datenbankdiensten und wird daher als letztes gestartet. Zusätzlich verwendet es einen Entry-Point, der den in der Dockerfile festgelegten Entry-Point überschreibt und den Sidekiq-Dienst startet.

Schritt 5: Volumendefinitionen unterhalb der Sidekiq-Dienstdefinition hinzufügen

volumes:
gem_cache:
db_data:
node_modules:

Unser Top-Level-`volumes`-Schlüssel definiert die Volumina `gem_cache`, `db_data` und `node_modules`. Wenn Docker Volumina erstellt, werden die Inhalte des Volumens in einem Teil des Host-Dateisystems, `/var/lib/docker/volumes/`, gespeichert, das von Docker verwaltet wird. Die Inhalte jedes Volumens werden in einem Verzeichnis unter `/var/lib/docker/volumes/` gespeichert und an jeden Container gemountet, der das Volumen verwendet. Auf diese Weise persistieren die Daten unseres Anwendungsdienstes im `db_data`-Volumen, auch wenn wir den Datenbankdienst entfernen und neu erstellen.

Die fertige Datei sieht folgendermaßen aus:

version: ‚3.4‘

services:
app:
build:
context: .
dockerfile: Dockerfile
depends_on:
– database
– redis
ports:
– „3000:3000“
volumes:
– .:/app
– gem_cache:/usr/local/bundle/gems
– node_modules:/app/node_modules
env_file: .env
environment:
RAILS_ENV: development

database:
image: postgres:12.1
volumes:
– db_data:/var/lib/postgresql/data
– ./init.sql:/docker-entrypoint-initdb.d/init.sql

redis:
image: redis:5.0.7

sidekiq:
build:
context: .
dockerfile: Dockerfile
depends_on:
– app
– database
– redis
volumes:
– .:/app
– gem_cache:/usr/local/bundle/gems
– node_modules:/app/node_modules
env_file: .env
environment:
RAILS_ENV: development
entrypoint: ./entrypoints/sidekiq-entrypoint.sh

volumes:
gem_cache:
db_data:
node_modules:

Speichern und schließen Sie die Datei, wenn Sie mit dem Bearbeiten fertig sind.

Kostenlosen Account erstellen

Registrieren Sie sich jetzt und erhalten Sie Zugang zu unseren Cloud Produkten.

Das könnte Sie auch interessieren: