Docker ist ein Open-Source-Projekt, das Entwicklern und Systemadministratoren eine offene Plattform bietet, um Anwendungen überall als leichtgewichtigen Container zu erstellen, zu verpacken und auszuführen. Docker automatisiert die Bereitstellung von Anwendungen in Softwarecontainern.
Ruby on Rails (RoR) ist ein Open-Source-Framework für Webanwendungen, veröffentlicht unter der MIT-Lizenz. Es ist ein serverseitiges Webanwendungs-Framework, das dem MVC-Konzept (Model-View-Controller) folgt.
In diesem Tutorial zeige ich Ihnen, wie Sie mit Docker und Docker Compose eine Entwicklungsumgebung für Ruby on Rails-Anwendungen einrichten. Wir werden Ubuntu 18.04 als Host-Betriebssystem und die PostgreSQL-Datenbank für unser Rails-Projekt verwenden.
Was wir tun werden:
- Installieren Sie Docker und Docker Compose
- Erstellen Sie das Rails-Projekt
- Richten Sie das Rails-Projekt ein
- Docker Compose-Skript erstellen
- Erstellen Sie das Projekt
- Erstellen Sie Basic CRUD auf Rails testen
Schritt 1 – Docker und Docker Compose installieren
Der erste Schritt, den wir tun müssen, ist die Installation von Docker und Docker Compose selbst. Wir werden Docker aus dem offiziellen Docker-Repository installieren und Docker-Compose aus dem offiziellen Docker-GitHub-Projekt installieren.
Führen Sie vor der Installation der Docker-Pakete den folgenden apt-Befehl aus, um Paketabhängigkeiten zu installieren.
sudo apt install -y \
apt-transport-https \
ca-certificates \
curl \
software-properties-common
Fügen Sie nun den Docker-Schlüssel und das Docker-Repository hinzu.
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
sudo add-apt-repository \
"deb [arch=amd64] https://download.docker.com/linux/ubuntu \
$(lsb_release -cs) \
stable"
Der Befehl aktualisiert automatisch alle Repositories auf dem System. Wenn es fertig ist, installieren Sie die docker-ce-Pakete.
sudo apt install -y docker-ce
Warten Sie auf die Docker-ce-Installation und starten Sie dann den Docker-Dienst und fügen Sie ihn der Startzeit hinzu.
sudo systemctl start docker
sudo systemctl enable docker
Docker läuft auf dem System.
Installieren Sie als Nächstes Docker-Compose, indem Sie die Binärdatei direkt aus dem Docker-GitHub-Repository herunterladen.
Laden Sie die Docker-Compose-Binärdatei in das Verzeichnis „/usr/local/bin/“ herunter und machen Sie sie zu einer ausführbaren Datei.
sudo curl -L https://github.com/docker/compose/releases/download/1.21.0/docker-compose-$(uname -s)-$(uname -m) -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose
Docker und Docker-Compose wurden auf dem System installiert, überprüfen Sie die Version mit den folgenden Befehlen.
docker version
docker-compose version
Unten ist das Ergebnis.
Schritt 2 – Ruby on Rails-Projekt generieren
Nachdem wir die Kernpakete docker und docker-compose auf dem System installiert haben, wollen wir einen neuen Benutzer erstellen und dann das Rails-Projekt mit den Docker-Images generieren.
Fügen Sie einen Benutzer namens „hakase“ hinzu und geben Sie dem Benutzer ein Passwort.
useradd -m -s /bin/bash hakase
passwd hakase
Fügen Sie den Benutzer der Gruppe „sudo“ und „docker“ hinzu und melden Sie sich bei der Benutzer-Shell „hakase“ an.
usermod -a -G sudo hakase
usermod -a -G docker hakase
su - hakase
Jetzt kann der ‚hakase‘-Benutzer den Docker-Befehl ausführen und ausführen.
Als Nächstes erstellen wir ein neues Verzeichnis „rails“ für unser Ruby on Rails-Projekt.
Erstellen Sie das Verzeichnis ‚rails‘ und gehen Sie dorthin.
mkdir -p ~/rails
cd ~/rails/
Führen Sie nun den untenstehenden Befehl „docker run“ aus.
docker run --rm -v ${PWD}:/usr/src -w /usr/src -ti ruby:alpine sh ; cd app Der Befehl führt den temporären Container basierend auf dem ruby:alpine-Image aus, hängt das lokale Verzeichnis in das Verzeichnis „/usr/src“ innerhalb des Containers ein und führt dann den Shell-Befehl „sh“ aus und wechselt zum Verzeichnis „app“.
Installieren Sie im Container die 'build-base'-Pakete.
apk add build-base
Installieren Sie nun Ruby on Rails im temporären Container.
gem install -N rails
Und generieren Sie das neue Rails-Projekt mit dem Namen „app“ mit PostgreSQL als Datenbank und beenden/melden Sie sich dann vom Container ab.
rails new app --database=postgresql --skip-bundle
exit
Und Sie befinden sich im Rails-Projektverzeichnis ‚app‘.
Ändern Sie nun den Eigentümer des Projektverzeichnisses „app“ in den Benutzer „hakase“.
sudo chown -R hakase:hakase ~/rails/app/
ls -lah
Und das Ruby on Rails-Projekt wurde über den temporären Docker-Container generiert.
Schritt 3 - Richten Sie das Rails-Projekt ein
In diesem Schritt erstellen wir ein neues Dockerfile für unsere Rails-Anwendungen.
Erstellen Sie im Verzeichnis ‚rails‘ eine neue Docker-Datei mit vim.
vim Dockerfile
Konfiguration unten einfügen.
FROM ruby:alpine RUN apk update RUN apk add build-base nodejs postgresql-dev tzdata RUN gem install -N rails RUN mkdir -p /app WORKDIR /app COPY ./app/Gemfile /app COPY ./app/Gemfile.lock /app RUN bundle install --binstubs
Speichern und beenden.
Wir erstellen ein neues Docker-Image basierend auf Ruby Alpine Linux. Wir installieren neue Pakete für die Rails-Installation, erstellen ein neues /app-Verzeichnis, kopieren die Gemfile und Gemfile.lock aus dem lokalen App-Verzeichnis und installieren alle Pakete basierend auf der Gemfile.
Als nächstes gehen Sie in das 'app'-Verzeichnis und erstellen eine neue Datei Gemfile.lock.
cd app/
touch Gemfile.lock
Bearbeiten Sie die Datei „database.yml“.
vim config/database.yml
Ändern Sie die Standarddatenbankkonfiguration und die Details wie unten beschrieben.
default: &default
adapter: postgresql
encoding: unicode
host: db
username: postgres
pool: <%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
timeout: 5000 Speichern und beenden.
Die Konfiguration des Rails-Projekts ist abgeschlossen.
Schritt 4 – Docker-Compose-Datei erstellen
In diesem Schritt erstellen wir eine neue Docker-Compose-Datei für unsere Rails-Anwendung. Wir werden nur zwei Dienste erstellen:db database PostgreSQL und web ist die Rails-Anwendung selbst.
Erstellen Sie eine neue Datei „docker-compose.yml“ im Verzeichnis „rails“.
vim docker-compose.yml
Und fügen Sie die Konfiguration unten ein.
version: '3.6'
services:
db:
image: postgres:alpine
volumes:
- ./postgresql:/var/lib/postgresql/data
web:
build: .
volumes:
- ./app:/app
working_dir: /app
command: bundle exec rails s -p 3000 -b '0.0.0.0'
ports:
- 80:3000
depends_on:
- db Speichern und beenden.
Erstellen Sie nun das Verzeichnis „postgresql“ im Projekt „rails“.
mkdir -p ~/rails/postgresql
Und wir sind bereit, unser Rails-Projekt aufzubauen.
Schritt 5 – Erstellen Sie das Projekt
Erstellen Sie das Rails-Docker-Image mit dem Befehl docker-compose unten.
docker-compose build
Der Befehl lädt das Ruby Alpine Linux-Image herunter und erstellt das benutzerdefinierte Image nach Bedarf basierend auf unserer Dockerfile.
Generieren Sie die PostgreSQL-Datenbank für das Projekt.
docker-compose run web rake db:create
Rufen Sie nun die Dienste „db“ und „web“ auf.
docker-compose up -d
Und die Rails-Dienste laufen, überprüfen Sie dies mit dem Docker-Compose-Befehl unten.
docker-compose ps
Sie können sehen, dass der Dienst „web“ auf Port „80“ auf dem Host ausgeführt wird.
Überprüfen Sie jetzt die Docker-Images auf unserem System.
docker-compose images
Und Sie erhalten das Ergebnis wie folgt.
Öffnen Sie nun Ihren Webbrowser und geben Sie die Server-IP-Adresse oder den Domänennamen ein. Meine ist:
http://rails.hakase-labs.io/
Und Sie erhalten die Standard-Rails-Seitenanwendung darauf.
Jetzt sind wir bereit, unser Rails-Projekt zu entwickeln.
Schritt 6 – Testen Sie das Erstellen von Basic CRUD auf Rails
Generieren Sie einfache CRUD auf Schienen, indem Sie den Befehl rails innerhalb des Containerdienstes „web“ ausführen.
docker-compose exec web rails g scaffold Post title:string body:text
Generieren Sie nun die Datenbank.
docker-compose exec web rake db:migrate
Öffnen Sie nun Ihren Webbrowser und geben Sie die Server-IP-Adresse in die Adressleiste mit dem Pfad „/posts“ ein. Meine ist:
http://rails.hakase-labs.io/posts
Und Sie erhalten die einfache CRUD-Seite wie unten.
Geben Sie den Beitrag ein und klicken Sie auf die Schaltfläche „Beitrag erstellen“.
Und Sie erhalten das Ergebnis wie folgt.
Die Einrichtung der Entwicklungsumgebung für Ruby on Rails mit Docker und Docker Compose wurde erfolgreich abgeschlossen.