Eine vereinfachte Anleitung zur „Dockerazition“ von Ruby und Rails mit der React Front-End-App

Das Dockerisieren Ihres Ruby on Rails mit einer React-Frontend-Anwendung kann Ihren Entwicklungs-Workflow und Ihren Bereitstellungsprozess erheblich verbessern. Indem Sie eine standardisierte Umgebung für Ihre App erstellen, stellen Sie ein konsistentes Verhalten in verschiedenen Entwicklungs-, Test- und Produktionsphasen und sogar zwischen verschiedenen Systemen sicher. Tatsächlich ist es darauf ausgelegt, Probleme im Zusammenhang mit Systemunterschieden zu minimieren. Diese Anleitung führt Sie durch die wesentlichen Schritte, damit Ihre Rails- und React-App in Docker-Containern reibungslos läuft. Warum eine Anwendung dockerisieren? : Konsistenz über alle Umgebungen hinweg Docker stellt sicher, dass die Anwendung unabhängig davon, wo sie bereitgestellt wird, auf dieselbe Weise ausgeführt wird, sei es auf der Maschine eines Entwicklers, in einer Testumgebung oder auf einem Produktionsserver. Diese Konsistenz wird durch die Containerisierung aller Abhängigkeiten und Konfigurationen erreicht. : Abhängigkeitsverwaltung Docker-Container enthalten alle notwendigen Abhängigkeiten, damit die Anwendung ausgeführt werden kann. Das bedeutet, dass Abweichungen in Systembibliotheken oder fehlende Abhängigkeiten auf verschiedenen Systemen die Funktionalität der Anwendung nicht beeinträchtigen. : Isolierung Docker-Container werden isoliert voneinander und vom Hostsystem ausgeführt. Diese Isolierung verhindert Konflikte zwischen verschiedenen Anwendungen und ihren Abhängigkeiten auf demselben System. : Portabilität Docker-Container können problemlos verschoben und auf jedem System ausgeführt werden, das Docker unterstützt, sei es eine lokale Maschine, ein Cloud-Dienst oder ein dedizierter Server. Dies macht die Anwendung in Bezug auf die Bereitstellung äußerst portabel und flexibel. NB: Kenntnisse der Docker-Syntax sind erforderlich Bei der Dockerisierung geht es um zwei Schlüsselkonzepte: Images und Container. Images dienen als Blaupausen für Container und enthalten alle notwendigen Informationen zum Erstellen eines Containers, einschließlich Abhängigkeiten und Bereitstellungskonfigurationen. Ein Container ist eine Laufzeitinstanz eines Images und besteht aus dem Image selbst, einer Ausführungsumgebung und Laufzeitanweisungen. Docker legt im Allgemeinen einen Standard für die Auslieferung von Software fest. Um Docker mit einer einfachen Analogie zu erklären: Stellen Sie sich Container als die Schiffscontainer auf einem Lagerplatz vor, Bilder als die in diesen Containern platzierten Objekte und das Schiff als das System, auf dem die Container laufen. Wenn Sie Ihre Anwendung einrichten und erstellen, sind bestimmte Umgebungskonfigurationen erforderlich. Sie können beispielsweise keine Rails-Anwendung ausführen, ohne dass auf Ihrem System eine Ruby-Umgebung installiert ist. Ebenso können Sie keine React-Anwendung ohne ausführen und Sie können keine React-Pakete ohne einen Node-Paketmanager wie oder usw. installieren. Node.js npm Yarn Da der Container isoliert vom System des Benutzers läuft, stellen wir alle diese Pakete in unserem Container zur Verfügung, so wie wir es getan hätten, wenn wir ihn direkt auf unserem System erstellt hätten. Der Container fungiert also als eigenständiges System, wie eine virtuelle Maschine. Es gibt Unterschiede zwischen Docker und virtuellen Maschinen, aber dieses Beispiel dient nur der weiteren Erläuterung. Lassen Sie uns nun die Rails-Anwendung dockerisieren. Dazu benötigen wir drei Dateien in unserer Rails-Anwendung: eine , eine und eine . Lassen Sie uns jede dieser Dateien im Detail untersuchen. Dockerfile docker-compose.yml bin/docker-entrypoint NB: Kenntnisse der Docker-Syntax sind erforderlich Docker-Datei Das ist eine Blaupause zum Erstellen eines Docker-Containers. Es enthält eine Reihe von Anweisungen, die Docker zum Erstellen eines Images verwendet, das dann zum Ausführen von Containern verwendet werden kann. Lassen Sie uns ein für eine Ruby on Rails- und React-Anwendung aufschlüsseln: Dockerfile Dockerfile Basisbild ARG RUBY_VERSION=3.1.4 FROM ruby:$RUBY_VERSION : Definiert ein Build-Argument namens mit einem Standardwert von . Dies kann zur Build-Zeit überschrieben werden. ARG RUBY_VERSION=3.1.4 RUBY_VERSION 3.1.4 : Verwendet das Basisimage mit der durch angegebenen Version. Dadurch wird der Container mit der Ruby-Laufzeitumgebung eingerichtet. Wie bereits erwähnt, muss Ruby installiert sein, um eine Rails-Anwendung ausführen zu können. FROM ruby:$RUBY_VERSION ruby RUBY_VERSION 2. Abhängigkeiten installieren RUN apt-get update -qq && \ apt-get install -y build-essential libvips bash bash-completion libffi-dev tzdata postgresql curl && \ apt-get clean && \ rm -rf /var/lib/apt/lists/* /usr/share/doc /usr/share/man : Aktualisiert die Paketliste aus den Repositories, mit für stille Ausgabe. apt-get update -qq -qq : Installiert verschiedene Pakete: apt-get install -y ... : Wichtige Pakete zum Erstellen von Software (wie GCC). build-essential : Bibliothek zur Bildverarbeitung. libvips , : Bash-Shell und ihre automatische Vervollständigung. bash bash-completion : Bibliothek für Fremdfunktionsschnittstellen. libffi-dev : Zeitzonendaten. tzdata : PostgreSQL-Datenbankclient. postgresql : Tool zum Übertragen von Daten von URLs. curl : Bereinigt das lokale Repository der abgerufenen Paketdateien. apt-get clean : Entfernt Paketlisten und Dokumentation, um die Bildgröße zu reduzieren. rm -rf /var/lib/apt/lists/ /usr/share/doc /usr/share/man 3. Installieren Sie Node.js und Yarn RUN curl -fsSL https://deb.nodesource.com/setup_current.x | bash - && \ apt-get install -y nodejs && \ curl -sS https://dl.yarnpkg.com/debian/pubkey.gpg | apt-key add - && \ echo "deb https://dl.yarnpkg.com/debian/ stable main" | tee /etc/apt/sources.list.d/yarn.list && \ apt-get update && \ apt-get install -y yarn : Lädt das NodeSource-Setup-Skript herunter und führt es aus, um Node.js zu installieren. curl -fsSL https://deb.nodesource.com/setup_current.x | bash - : Installiert Node.js. apt-get install -y nodejs : Fügt den Yarn-GPG-Schlüssel hinzu, um seine Pakete zu überprüfen. curl -sS https://dl.yarnpkg.com/debian/pubkey.gpg | apt-key add - : Fügt das Yarn-Repository zur Quellenliste hinzu. echo "deb https://dl.yarnpkg.com/debian/ stable main" | tee /etc/apt/sources.list.d/yarn.list : Aktualisiert die Paketliste und installiert Yarn. apt-get update && apt-get install -y yarn 4. Umgebungsvariablen ENV NODE_OPTIONS=--openssl-legacy-provider : Legt eine Umgebungsvariable fest, um die Legacy-OpenSSL-Unterstützung für Node.js zu aktivieren. ENV NODE_OPTIONS=--openssl-legacy-provider 5. Arbeitsverzeichnis festlegen WORKDIR /rails : Legt das Arbeitsverzeichnis für nachfolgende Anweisungen auf fest. WORKDIR /rails /rails 6. Argumente und Umgebungsvariablen erstellen ARG RAILS_ENV ENV RAILS_ENV=$RAILS_ENV : Definiert ein Build-Argument namens zum Angeben der Rails-Umgebung (wie , , ). ARG RAILS_ENV RAILS_ENV development test production : Setzt die Umgebungsvariable auf den Wert des Build-Arguments. ENV RAILS_ENV=$RAILS_ENV RAILS_ENV 7. Installieren Sie Application Gems COPY Gemfile Gemfile.lock ./ RUN bundle install : Kopiert die und in das Arbeitsverzeichnis. COPY Gemfile Gemfile.lock ./ Gemfile Gemfile.lock : Installiert die im angegebenen Ruby-Gems. RUN bundle install Gemfile 8. Installieren Sie Front-End-Abhängigkeiten COPY package.json yarn.lock ./ RUN yarn install --frozen-lockfile : Kopiert und in das Arbeitsverzeichnis. COPY package.json yarn.lock ./ package.json yarn.lock : Installiert Front-End-Abhängigkeiten mit Yarn und stellt sicher, dass die genauen Versionen in verwendet werden. RUN yarn install --frozen-lockfile yarn.lock 9. Anwendungscode kopieren COPY . . : Kopiert den gesamten Anwendungscode in das Arbeitsverzeichnis. COPY . . 10. Bootsnap-Code vorkompilieren RUN bundle exec bootsnap precompile --gemfile app/ lib/ : Kompiliert den Bootsnap-Cache vorab, um schnellere Startzeiten von Rails-Anwendungen zu ermöglichen. Bootsnap ist ein Gem, das die Startzeiten von Ruby und Rails beschleunigt, indem aufwändige Berechnungen zwischengespeichert werden. RUN bundle exec bootsnap precompile --gemfile app/ lib/ 11. Assets für die Produktion vorkompilieren RUN if [ "$RAILS_ENV" = "production" ]; then \ SECRET_KEY_BASE=1 bin/rails assets:precompile; \ fi : Führt die Asset-Vorkompilierung nur bedingt aus, wenn auf eingestellt ist. Dieser Schritt ist entscheidend für die Vorbereitung von Assets für eine Produktionsumgebung. RUN if [ "$RAILS_ENV" = "production" ]; then ... RAILS_ENV production 12. Entrypoint-Skript COPY bin/docker-entrypoint /rails/bin/ RUN chmod +x /rails/bin/docker-entrypoint : Kopiert ein benutzerdefiniertes Entrypoint-Skript in den Container. COPY bin/docker-entrypoint /rails/bin/ : Macht das Entrypoint-Skript ausführbar. RUN chmod +x /rails/bin/docker-entrypoint 13. Einstiegspunkt und Befehl definieren ENTRYPOINT ["/rails/bin/docker-entrypoint"] EXPOSE 5000 // you can use any port of your choice CMD ["./bin/rails", "server"] : Legt das Entrypoint-Skript fest, das beim Starten des Containers ausgeführt wird. Dieses Skript richtet normalerweise die Umgebung ein, bereitet die Datenbank vor und startet die Anwendung. ENTRYPOINT ["/rails/bin/docker-entrypoint"] : Zeigt an, dass der Container auf Port 5000 lauscht. Dies ist eine Dokumentationsfunktion und veröffentlicht den Port nicht. EXPOSE 5000 : Gibt den Standardbefehl an, der beim Starten des Containers ausgeführt werden soll, nämlich den Rails-Server zu starten. CMD ["./bin/rails", "server"] docker-compose.yml Die Datei wird zum Definieren und Ausführen von Docker-Anwendungen mit mehreren Containern verwendet. Sie ermöglicht Ihnen, die Dienste, Netzwerke und Volumes Ihrer Anwendung in einer einzigen Datei zu konfigurieren. In diesem Fall werden wir zwei Dienste verwenden. Hier ist die Datei für die Rails-Anwendung: docker-compose.yml docker-compose.yml 1. ) Datenbankdienst ( db codedb: image: postgres:14.2-alpine container_name: demo-postgres-14.2 volumes: - postgres_data:/var/lib/postgresql/data command: "postgres -c 'max_connections=500'" environment: POSTGRES_DB: ${POSTGRES_DB} POSTGRES_USER: ${POSTGRES_USER} POSTGRES_PASSWORD: ${POSTGRES_PASSWORD} ports: - "5432:5432" : Gibt das für diesen Dienst zu verwendende Docker-Image an. In diesem Fall ist es das PostgreSQL 14.2-Image, das auf der Alpine Linux-Distribution basiert. Alpine-Images sind für ihre geringe Größe bekannt, die dazu beitragen kann, die Gesamtgröße des Images gering zu halten. image: postgres:14.2-alpine : Benennt den Container . Dieser Name wird verwendet, um in Befehlen und Protokollen auf den Container zu verweisen. container_name: demo-postgres-14.2 demo-postgres-14.2 volumes : Mountet ein benanntes Volume in innerhalb des Containers. In diesem Verzeichnis speichert PostgreSQL seine Daten und stellt sicher, dass die Datenbankdaten zwischen Containerneustarts erhalten bleiben. postgres_data:/var/lib/postgresql/data: postgres_data /var/lib/postgresql/data : Überschreibt den Standardbefehl des PostgreSQL-Images. Es startet PostgreSQL mit einer Konfigurationsoption, um die maximale Anzahl von Verbindungen auf 500 zu erhöhen. command: "postgres -c 'max_connections=500'" environment : : Legt den Namen der zu erstellenden Standarddatenbank unter Verwendung der Umgebungsvariable fest. POSTGRES_DB: ${POSTGRES_DB} POSTGRES_DB : Legt unter Verwendung der Umgebungsvariable den Standardbenutzernamen für den Zugriff auf die PostgreSQL-Datenbank fest. POSTGRES_USER: ${POSTGRES_USER} POSTGRES_USER : Legt unter Verwendung der Umgebungsvariable das Kennwort für den Standardbenutzer fest. POSTGRES_PASSWORD: ${POSTGRES_PASSWORD} POSTGRES_PASSWORD ports : : Ordnet Port 5432 auf dem Host Port 5432 im Container zu. Dies ermöglicht den Zugriff auf PostgreSQL auf dem Hostcomputer über Port 5432. "5432:5432" 2. ) Web-Anwendungsdienst ( demo-web codedemo-web: build: context: . args: - RAILS_ENV=${RAILS_ENV} command: "./bin/rails server -b 0.0.0.0" environment: - RAILS_ENV=${RAILS_ENV} - POSTGRES_HOST=${POSTGRES_HOST} - POSTGRES_DB=${POSTGRES_DB} - POSTGRES_USER=${POSTGRES_USER} - POSTGRES_PASSWORD=${POSTGRES_PASSWORD} - RAILS_MASTER_KEY=${RAILS_MASTER_KEY} volumes: - .:/rails - app-storage:/rails/storage depends_on: - db ports: - "3000:3000" build: : Gibt den Build-Kontext für das Docker-Image an. In diesem Fall bezieht sich auf das aktuelle Verzeichnis. Dies bedeutet, dass Docker die Docker-Datei im aktuellen Verzeichnis verwendet, um das Image zu erstellen. context: . . args : : Übergibt das Build-Argument an den Docker-Build-Prozess und ermöglicht Ihnen, die Rails-Umgebung anzugeben (wie etwa , oder ). RAILS_ENV=${RAILS_ENV} RAILS_ENV development test production : Überschreibt den Standardbefehl des Docker-Images. Startet den Rails-Server und bindet ihn an alle Netzwerkschnittstellen ( ), was notwendig ist, damit der Dienst von außerhalb des Containers erreichbar ist. command: "./bin/rails server -b 0.0.0.0" 0.0.0.0 environment: : Legt die Rails-Umgebung innerhalb des Containers mithilfe der Umgebungsvariable fest. RAILS_ENV=${RAILS_ENV} RAILS_ENV : Legt die PostgreSQL-Hostadresse fest. POSTGRES_HOST=${POSTGRES_HOST} : Legt den Datenbanknamen fest. POSTGRES_DB=${POSTGRES_DB} : Legt den PostgreSQL-Benutzer fest. POSTGRES_USER=${POSTGRES_USER} : Legt das PostgreSQL-Benutzerkennwort fest. POSTGRES_PASSWORD=${POSTGRES_PASSWORD} : Legt den Rails-Hauptschlüssel fest, der zum Verschlüsseln von Anmeldeinformationen und anderen Geheimnissen verwendet wird. RAILS_MASTER_KEY=${RAILS_MASTER_KEY} volumes : : Mountet das aktuelle Verzeichnis (in dem sich die Datei befindet) in innerhalb des Containers. So können Sie Dateien auf Ihrem Host bearbeiten und diese Änderungen im Container widerspiegeln lassen. .:/rails docker-compose.yml /rails : Mountet ein benanntes Volume in innerhalb des Containers. Dies wird normalerweise zum Speichern Rails-spezifischer Dateien wie Protokolle, Uploads und zwischengespeicherte Dateien verwendet. app-storage:/rails/storage app-storage /rails/storage depends_on : : Stellt sicher, dass der wartet, bis der Dienst bereit ist, bevor er gestartet wird. Docker Compose handhabt die Reihenfolge der gestarteten Dienste basierend auf dieser Einstellung. db demo-web db ports: : Ordnet Port 3000 auf dem Host Port 3000 im Container zu. Dadurch können Sie über Port 3000 auf die Rails-Anwendung auf dem Hostcomputer zugreifen. "3000:3000" Bände codevolumes: postgres_data: app-storage: : Definiert ein benanntes Volume das vom zum Speichern von PostgreSQL-Daten verwendet wird. postgres_data postgres_data db : Definiert einen benannten Volume- der vom zum Speichern anwendungsspezifischer Daten wie Uploads und Protokolle verwendet wird. app-storage app-storage demo-web bin/docker-einstiegspunkt Das Skript ist ein wichtiger Teil der Docker-Einrichtung. Es wird beim Start des Containers ausgeführt und übernimmt normalerweise die Einrichtung der Umgebung, die Vorbereitung der Datenbank und andere Initialisierungsaufgaben, die vor dem Start der Hauptanwendung erforderlich sind. Hier ist ein Beispiel für ein Skript und eine detaillierte Erklärung jedes Teils: bin/docker-entrypoint bin/docker-entrypoint Shebang und Beenden bei Fehler bashCopy code#!/bin/bash set -e : Diese Zeile gibt an, dass das Skript mit der Bash-Shell ausgeführt werden soll. #!/bin/bash : Dies weist das Skript an, sofort beendet zu werden, wenn ein Befehl einen Exit-Code ungleich Null zurückgibt. Dadurch wird sichergestellt, dass das Skript die Ausführung stoppt, wenn ein Schritt fehlschlägt. Dadurch kann verhindert werden, dass nachfolgende Schritte in einem ungültigen Zustand ausgeführt werden. set -e Bedingte Datenbankerstellung oder -migration # If running the rails server then create or migrate existing database if [ "${*}" == "./bin/rails server" ]; then ./bin/rails db:create ./bin/rails db:prepare fi : Diese bedingte Anweisung prüft, ob der an das Skript übergebene Befehl ( ) ist. Das ist ein spezieller Parameter, der alle an das Skript übergebenen Positionsparameter enthält. if [ "${*}" == "./bin/rails server" ]; then ... fi "${*}" ./bin/rails server * ./bin/rails db : Wenn die Bedingung erfüllt ist, versucht dieser Befehl, die Datenbank zu erstellen. Dies entspricht dem Ausführen von , wodurch die Datenbank gemäß der Definition in der Datenbankkonfigurationsdatei ( ) eingerichtet wird. rails db:create config/database.yml ./bin/rails db : Dieser Befehl führt aus, wodurch sichergestellt wird, dass die Datenbank eingerichtet und migriert wird. Er erstellt die Datenbank, wenn sie noch nicht existiert, und führt Migrationen aus, wenn die Datenbank bereits erstellt wurde. Dies ist eine Kombination aus und . rails db:prepare rails db:create rails db:migrate Ausführen des Hauptprozesses bashCopy codeexec "${@}" : Dies ersetzt den aktuellen Shell-Prozess durch den Befehl, der als Argumente an das Skript übergeben wurde. Das -Symbol enthält alle Positionsparameter, die an das Skript übergeben werden. Wenn das Skript beispielsweise mit aufgerufen wird, führt diese Zeile effektiv als Hauptprozess des Containers aus. exec "${@}" @ ./bin/rails server ./bin/rails server Abschluss Ein gut gestaltetes ist unerlässlich, um eine zuverlässige und konsistente Umgebung für Ihre Ruby on Rails- und React-Anwendung zu erstellen. Indem Sie das Basisimage definieren, Umgebungsvariablen festlegen und Abhängigkeiten installieren, stellen Sie sicher, dass Ihre Anwendung in verschiedenen Umgebungen reibungslos läuft. Dockerfile Docker rationalisiert nicht nur Ihren Entwicklungsprozess, sondern verbessert auch die Zuverlässigkeit Ihrer Anwendung in der Produktion. Es gibt Optimierungsbereiche, aber dies ist nur ein allgemeiner Überblick darüber, wie die Rails-Anwendung dockerisiert wird. Vollständiges Skript für die resultierende , und Dockerfile docker-compose.yml bin/docker-entrypoint ARG RUBY_VERSION=3.1.4 FROM ruby:$RUBY_VERSION # Install dependencies RUN apt-get update -qq && \ apt-get install -y build-essential libvips bash bash-completion libffi-dev tzdata postgresql curl && \ apt-get clean && \ rm -rf /var/lib/apt/lists/* /usr/share/doc /usr/share/man # Install Node.js and Yarn RUN curl -fsSL https://deb.nodesource.com/setup_current.x | bash - && \ apt-get install -y nodejs && \ curl -sS https://dl.yarnpkg.com/debian/pubkey.gpg | apt-key add - && \ echo "deb https://dl.yarnpkg.com/debian/ stable main" | tee /etc/apt/sources.list.d/yarn.list && \ apt-get update && \ apt-get install -y yarn # Set environment variable to enable legacy OpenSSL support ENV NODE_OPTIONS=--openssl-legacy-provider # Rails app lives here WORKDIR /rails # Set environment variable for the build ARG RAILS_ENV ENV RAILS_ENV=$RAILS_ENV # Install application gems COPY Gemfile Gemfile.lock ./ RUN bundle install # Install frontend dependencies COPY package.json yarn.lock ./ RUN yarn install --frozen-lockfile # Copy application code COPY . . # Precompile bootsnap code for faster boot times RUN bundle exec bootsnap precompile --gemfile app/ lib/ # Precompiling assets for production without requiring secret RAILS_MASTER_KEY RUN if [ "$RAILS_ENV" = "production" ]; then \ SECRET_KEY_BASE=1 bin/rails assets:precompile; \ fi # Entrypoint prepares the database. COPY bin/docker-entrypoint /rails/bin/ RUN chmod +x /rails/bin/docker-entrypoint # Use an absolute path for the entry point script ENTRYPOINT ["/rails/bin/docker-entrypoint"] # Start the server by default, this can be overwritten at runtime EXPOSE 5000 CMD ["./bin/rails", "server"] services: db: image: postgres:14.2-alpine container_name: demo-postgres-14.2 volumes: - postgres_data:/var/lib/postgresql/data command: "postgres -c 'max_connections=500'" environment: POSTGRES_DB: ${POSTGRES_DB} POSTGRES_USER: ${POSTGRES_USER} POSTGRES_PASSWORD: ${POSTGRES_PASSWORD} ports: - "5432:5432" demo-web: build: context: . args: - RAILS_ENV=${RAILS_ENV} command: "./bin/rails server -b 0.0.0.0" environment: - RAILS_ENV=${RAILS_ENV} - POSTGRES_HOST=${POSTGRES_HOST} - POSTGRES_DB=${POSTGRES_DB} - POSTGRES_USER=${POSTGRES_USER} - POSTGRES_PASSWORD=${POSTGRES_PASSWORD} - RAILS_MASTER_KEY=${RAILS_MASTER_KEY} volumes: - .:/rails - app-storage:/rails/storage depends_on: - db ports: - "3000:3000" volumes: postgres_data: app-storage: #!/bin/bash set -e # If running the rails server then create or migrate existing database if [ "${*}" == "./bin/rails server" ]; then ./bin/rails db:create ./bin/rails db:prepare fi exec "${@}"