[RUBY] Rails 6 (API-Modus) + MySQL Docker-Umgebungserstellung durch Docker-Compose (für Mac)

Einführung

Es war die Rede davon, die Umgebung zum Hafenarbeiter zu machen, um die komplette Renovierung in Teilzeit fortzusetzen. Ich habe beschlossen, es mit der Konfiguration von Front-End Nuxt.js und Back-End-Rails 6 zu machen, und ich werde für den Back-End-Teil verantwortlich sein, also lasst uns viel eine Docker-Datei schreiben! Daher werde ich die fertige Konfiguration vorstellen, indem ich sie für das Studium implementiere. Wie man einen Rails-Container erstellt, wird kurz auf der offiziellen Docker-Seite beschrieben, diesmal jedoch in der Docker-Datei unter Berücksichtigung von Rails 6 Ich werde auch vorstellen, wie man schreibt und wie man einen MySQL-Container erstellt.

Eigene Fähigkeiten

Vor ungefähr anderthalb Jahren habe ich als Einzelperson angefangen, Schienen zu berühren, und meine praktische Entwicklungserfahrung als Webingenieur beträgt etwas mehr als ein Jahr, was keine lange Zeitspanne ist. Ich wachse jedoch schnell, indem ich das breite Spektrum an Grundkenntnissen, die ich an der Universität erworben habe, und die Einstellung, verschiedene Herausforderungen anzunehmen, nutze. Schon im vorherigen Projekt habe ich Docker berührt, den Datenbankcontainer (MarinaDB-> MySQL) geändert, ein Shell-Skript für die Grundeinstellungen erstellt und so weiter. Ich hatte keine Chance, einen Docker von Grund auf neu zu erstellen, also habe ich es diesmal versucht.

Docker-Umgebungserstellung

Von hier an werden wir tatsächlich eine Umgebung mit Docker erstellen.

Dateiorganisation

Zunächst werde ich kurz die Dateistruktur vorstellen. Unter der Annahme, dass der Name der zu erstellenden Anwendung "sample" lautet, haben die diesmal zugehörigen Dateien die folgende Dateistruktur.

sample 
|- backend --- app
|           |- bin
|           |- config --- ...
|           |          |- database.yml
|           |          |- ...
|           |- ...
|           |- Dockerfile
|           |- Gemfile
|           |- Gemfile.lock
|           |- ...
|- db --- data --- ...
|      |- my.cnf
|- docker-compose.yml

Eigentlich werden mehr Dateien (erstellt), aber dies sind die einzigen Dateien, die dieses Mal bearbeitet werden.

Erforderliche Dateien erstellen

Als nächstes werde ich die Dateien beschreiben, die sich auf Docker beziehen. backend/Dockerfile Dies ist eine Datei mit Anweisungen zum Erstellen eines Rails-Containers. Der Inhalt ist unten aufgeführt und die Kommentare erklären, was jeder Prozess tut.

backend/Dockerfile

#Bild und Version zu verwenden
FROM ruby:2.7.1

#Installieren Sie die erforderlichen Bibliotheken
RUN apt-get update -qq && \
    apt-get install -y build-essential \ 
                       libpq-dev \        
                       nodejs

#Das Folgende ist Schienen 6 oder höher(API-Modus ausschließen)Benötigt in
RUN apt-get update && apt-get install -y curl apt-transport-https wget && \
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

#Erstellen Sie im Container einen Ordner namens app
#* Ordner werden nicht auf dem lokalen PC erstellt
RUN mkdir /app
#Ändern Sie root in das App-Verzeichnis
ENV APP_ROOT /app
WORKDIR $APP_ROOT

#Gemfile auf dem lokalen PC(.lock)In den Container
ADD ./Gemfile $APP_ROOT/Gemfile
ADD ./Gemfile.lock $APP_ROOT/Gemfile.lock

#Führen Sie die Bundle-Installation aus, um die Dateien auf dem lokalen PC in den Container zu kopieren
RUN bundle install
ADD . $APP_ROOT

#Portnummer, die der Container abhört
EXPOSE 3000

#Auszuführender Befehl
CMD ["rails", "server", "-b", "0.0.0.0"]

Da Rails6 der Standard ist, ist Webpacker die Standardeinstellung. Wenn also "Garn" nicht installiert ist, tritt ein Fehler auf, wenn "Rails New" ausgeführt wird. Es ist jedoch nicht erforderlich, "Garn" zu installieren, wenn im später beschriebenen API-Modus erstellt wird.

backend/Gemfile Schreiben Sie "Gemfile" im Voraus, um Rails zu installieren. Diese Datei wird später neu geschrieben, wenn Sie "Rails New" ausführen. Hier wird die Version 6 oder höher angegeben.

backend/Gemfile

source 'https://rubygems.org'
gem 'rails', '~> 6'

backend/Gemfile.lock Wenn Sie die Bundle-Installation durchführen, wird so etwas wie eine Bibliotheksentwurfszeichnung basierend auf den Abhängigkeiten erstellt. Erstellen Sie eine leere. Später bekam ich eine Fehlermeldung, wenn die Datei nicht existierte.

backend/Gemfile.lock

db/data/ Bereiten wir nur das Verzeichnis vor

db/my.cnf Dies ist eine Datei, die sich auf MySQL-Einstellungen bezieht.

my.cnf

[mysqld]
character-set-server=utf8mb4
collation-server=utf8mb4_unicode_ci
sql_mode=''

[client]
default-character-set=utf8mb4

Zeichencode-Einstellungen und sql_mode-Einstellungen werden vorgenommen. Insbesondere denke ich, dass es besser ist, "sql_mode" zu setzen. Dies liegt daran, dass sich der Standardwert "sql_mode" gegenüber MySQL 5.7 geändert hat und häufig ein Fehler auftritt, insbesondere in Modi wie "only_full_group_by". Daher ist explizit angegeben, welcher "sql_mode" verwendet werden soll. Schreiben wir es auf. Dieses Mal wird keine Einstellung (Standard für MySQL 5.6.5 oder früher) explizit angegeben. (Ich möchte hier mehr Artikel schreiben)

docker-compose.yml Zum Schluss schreibe Docker-Compose. Eine kurze Erklärung finden Sie in den Kommentaren.

docker-compose.yml

version: "3"
services:
  # MySQL
  db:
    #Bild zu bauen
    image: mysql:5.7
    #Umgebungsvariablen angeben
    environment:
      MYSQL_ROOT_PASSWORD: root
      MYSQL_DATABASE: spportunity
      MYSQL_USER: root
      MYSQL_PASSWORD: root
      TZ: 'Asia/Tokyo'
    #Setzen Sie den Zeichencode auf utf8mb4
    command: mysqld --character-set-server=utf8mb4 --collation-server=utf8mb4_unicode_ci
    volumes:
      # db/Hängen Sie das Datenverzeichnis in das MySQL-Verzeichnis des Containers ein
      - ./db/data/:/var/lib/mysql
      # /db/my.cnf datei my in container.Mounten in der cnf-Konfigurationsdatei
      - ./db/my.cnf:/etc/mysql/conf.d/my.cnf
    ports:
      - 3306:3306

  #Rails  
  backend:
    #Geben Sie die Build-Quelle an
    build:
      context: ./backend
      dockerfile: Dockerfile
    #Angabe des Containernamens
    container_name: "sample-backend"
    #Angabe eines Befehls beim Start Rails s wird ausgeführt, nachdem der vorherige Prozess beendet wurde.
    command: bash -c "rm -f tmp/pids/server.pid && rails s -p 3000 -b '0.0.0.0'"
    #Hängen Sie die Dateien im Backend-Ordner in das App-Verzeichnis im Container ein
    volumes:
      - ./backend/:/app
    ports:
      - "3000:3000"
    #Beginnen Sie nach dem DB-Container
    depends_on:
      - db

Nachdem die Datei fertig ist, erstellen wir die Rails-Anwendung.

Erstellen einer Rails-Anwendung

Erstellen Sie eine Rails-Anwendung mit dem Befehl docker-compose. Stellen Sie sicher, dass das aktuelle Verzeichnis "sample" ist.

Erstellen Sie Schienen im normalen Modus (Garn muss in Dockerfile installiert werden)

% docker-compose run backend rails new . --force --no-deps --database=mysql --skip-bundle

--Rewrite --force ... Gemfile ---- database = mysql ... Geben Sie MySQL für die Datenbank an --Skip --skip-bundle ... bundle (Gemfile.lock wurde noch nicht geändert)

Erstellen Sie Schienen im API-Modus

% docker-compose run backend rails new . --force --no-deps --database=mysql --skip-bundle --api

---- api ... Erstellungsoptionen im API-Modus

Wenn Sie fertig sind, haben Sie eine große Anzahl von Rails-bezogenen Ordnern und Dateien im Ordner "Backend /". Ich werde über den Unterschied zwischen API-Modus und Normalmodus und den Unterschied zwischen Dateien schreiben.

Bauen Sie den Container

% docker-compose build

Durch Ausführen dieses Befehls wird ein MySQL-Container erstellt und im Rails-Container eine Bundle-Installation durchgeführt. Wenn Sie sich die Konsole ansehen, können Sie sehen, dass der Inhalt der Docker-Datei der Reihe nach ausgeführt wird.

Schienenverbindungseinstellungen an db

backend/config/database.yml

default: &default
  adapter: mysql2
  encoding: utf8mb4
  pool: <%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
  username: root
  password: root
  host: db

development:
  <<: *default
  database: sample


test:
  <<: *default
  database: sample_test

production:
  <<: *default
  database: sample_production
  username: <%= ENV['APP_DATABASE_USER'] %>
  password: <%= ENV['APP_DATABASE_PASSWORD'] %>

Ändern Sie die Verbindungsinformationen in das Image des zuvor für den Host erstellten MySQL-Containers und die Umgebungsvariablen für den zuvor für Ihren Benutzernamen und Ihr Kennwort erstellten Container.

Installieren Sie Webpacker (außer im API-Modus).

% docker-compose run backend rails webpacker:install

Datenbank erstellen

% docker-compose run backend rails db:create

Starten Sie Docker

Wenn Sie zu diesem Punkt kommen, ist die Einstellung abgeschlossen. Alles was Sie tun müssen, ist Docker zu starten!

% docker-compose up

Stellen Sie sicher, dass Rails in Ihrem Browser aktiv ist

Wenn ich mit einem Browser auf http: // localhost: 3000 / zugreife, wird Rails erfolgreich gestartet.

Skalierbarkeit

Ich habe es diesmal nicht erwähnt, aber durch Hinzufügen eines Frontend-Containers usw. wird es möglich sein, eine Umgebung zu erstellen, die sowohl eine Frontend-Anwendung als auch einen API-Server auf einmal enthält. In diesem Fall müssen Sie eine Docker-Datei erstellen und einen Container zum Docker-Compose hinzufügen. Ich bin immer noch ein Front-End-Anfänger, daher möchte ich irgendwann auch einen Front-Container bauen.

Impressionen

Immerhin ist Docker bequem. Ich habe Docker in meiner persönlichen Entwicklung nicht verwendet, aber ich denke darüber nach, es von nun an positiv zu nutzen. In diesem Fall möchte ich einen Artikel schreiben.

Es war mein erstes Mal, dass ich einen Artikel über Qiita schrieb, und als ich mich fragte, wie viel ich schreiben sollte, wurde es ziemlich lang. Es gibt jedoch viele Leute, die viele sehr reiche Artikel schreiben, und ich habe das Gefühl, dass ich noch viel zu tun habe. Ich bin vielleicht nicht in der Lage, etwas zu schreiben, das noch oft Inhalte enthält, aber ich möchte mein Wissen nach und nach veröffentlichen.

Referenziert

Ich bezog mich auf den folgenden Qiita-Artikel. Ich habe auch den Schreibstil nachgeahmt, was sehr hilfreich war. Vielen Dank.

https://qiita.com/azul915/items/5b7063cbc80192343fc0 https://qiita.com/kodai_0122/items/795438d738386c2c1966

Zusätzlich zu dem obigen Artikel enthält der Inhalt den API-Modus, das Mounten und Einstellen des MySQL-Containers usw. Verzeihen Sie daher bitte die ähnliche Schreibmethode.