[RUBY] [Umgebungskonstruktion] Rails + MySQL + Docker (Anfänger können es auch in 30 Minuten verwenden!)

Umgebungskonstruktion mit Docker

Ich habe gehört, dass das Erstellen einer Umgebung schwieriger ist als das Schreiben von Code.

Docker ist einfach!

Und warum,,, ** Einfach kopieren und einfügen ** Es kann jedoch einige Zeit dauern, um zu verstehen ... Beginnen wir mit einem kurzen Überblick

Docker Tools zum Erstellen virtueller Umgebungen

Container

Virtuelle Umgebung selbst (Docker führt einen Container über der Docker-Engine aus.)

Bild

Was Sie benötigen, um einen Docker-Container auszuführen.

Bauverfahren für die Umwelt

①. `Erstellen Sie ein Projekt (Verzeichnis) und verschieben Sie es `

$ mkdir App Name $ cd App Name ② . Dockerfile erstellen, docker-compose.yml, Gemfile, Gemfile.lock

$ touch Dockerfile docker-compose.yml Gemfile Gemfile.lock

③. `Öffnen Sie den Editor und kopieren Sie Dockerfile, docker-compose.yml, Gemfile aus dem folgenden` Dockerfile Eine Datei, die automatisch ein Docker-Image generiert

FROM ruby:2.5
RUN apt-get update -qq && apt-get install -y build-essential libpq-dev nodejs

RUN mkdir /myapp
WORKDIR /myapp

COPY Gemfile /myapp/Gemfile
COPY Gemfile.lock /myapp/Gemfile.lock

RUN bundle install
COPY . /myapp

FROM: Zu verwendendes Bild und Befehl RUN: Befehl ausführen WORKDIR: Arbeitsverzeichniseinstellungen KOPIEREN: Geben Sie die Dateien oder Verzeichnisse der Kopierquelle (Hostseite) und des Kopierziels (Seite der virtuellen Umgebung) an

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

docker-compose.yml version: '3'

services:
    db:
        image: mysql:5.7
        environment:
            MYSQL_USER: root
            MYSQL_ROOT_PASSWORD: password
        ports:
            - "3306:3306"
        volumes:
            - ./db/mysql/volumes:/var/lib/mysql

    web:
        build: .
        command: bash -c "rm -f tmp/pids/server.pid && bundle exec rails s -p 3000 -b '0.0.0.0'"
        volumes:
            - .:/myapp
            - gem_data:/usr/local/bundle
        ports:
            - 3000:3000
        depends_on:
            - db 
        tty: true
        stdin_open: true

volumes:
  gem_data:

version: Die Version von Docker-Compose. abhängige_on: Zeigt Abhängigkeiten an und ermöglicht die Steuerung der Startreihenfolge. Beginnen Sie hier mit "db → web".

Was ist Docker komponieren

Docker Compose ist eine Funktion, die das Erstellen und Ausführen eines aus mehreren Containern bestehenden Dienstes automatisiert und die Verwaltung erleichtert. Mit Docker Compose können Sie eine Compose-Datei vorbereiten und den Befehl einmal ausführen, um die Einstellungen aus dieser Datei zu lesen und alle Container zu starten.

Über den Service

In Docker Compose wird jedes Element zum Ausführen einer Anwendung als Dienst bezeichnet. Normalerweise Web (Rails) und DB (MySQL) genannt.

Über `` `rm -f tmp / pids / server.pid```

Die PID ist die Prozess-ID. Die PID wird beim Starten des Entwicklungswebservers in tmp / pids / server.pid geschrieben und beim Beenden gelöscht. Wenn pid in server.pid geschrieben ist, wird der Server als ** startend ** beurteilt.

Über Ports

ports:
  - 3000:3000

Das Obige bedeutet, dass Port 3000 im Container 3000 auf dem Host zugeordnet ist. Auf diese Weise können Sie unter `` `http: // localhost: 3000``` auf den Webserver im Container zugreifen.

Über die Lautstärke

volumes:
   - ./db/mysql/volumes:/var/lib/mysql

Bedeutet, dass ./db/mysql/volumes auf dem Host in / var / lib / mysql im Container bereitgestellt wird. Einfach ausgedrückt, der Docker-Container wird lokal ** synchronisiert **.

volumes :
   - .:/myapp

Bedeutet alle Verzeichnisse des Hosts mit `.``` und hängt es auf` myapp``` im Container ein.

④ .``` Führen Sie den folgenden Befehl aus `` `

$ docker-compose run web rails new . --force --database=mysql

Der Befehl run erledigt alles vom Erstellen eines Images bis zum Erstellen und Starten eines Containers. Service muss im Argument angegeben werden. Da der Datenträger: - .: / Myapp-Teil von docker-compose.yml so eingestellt ist, dass der Docker mit dem lokalen Verzeichnis synchronisiert wird, wird nach Ausführung dieses Befehls gleichzeitig eine ähnliche Datei lokal generiert. ..

⑤. `Ändern Sie in` `config / database.yml `zu (Passwort: Passwort, Host: db)

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

Passwort: Passwort #password hinzugefügt host: db Von #localhost zu db geändert

⑥. `Führen Sie den folgenden Befehl aus `

$ docker-compose build

Führen Sie `` `build``` aus, wenn die Gemfile aktualisiert wird

⑦ .``` Führen Sie den folgenden Befehl aus `` `

$ docker-compose up -d

Der Container startet gemäß docker-compose.yml. Wird auch ausgeführt, wenn Änderungen in docker-compose.yml berücksichtigt werden. Die Option `` `-d``` beginnt im Hintergrund.

⑧. `Führen Sie den folgenden Befehl aus

$ docker-compose run web rails db:create

Erstellen Sie eine Datenbank. Sie können Befehle lokal mit `` `docker-compose run web``` ausführen. (Keine Notwendigkeit, den Container zu betreten)

⑨. `Führen Sie den folgenden Befehl aus und prüfen Sie, ob die beiden Container aktiv sind. `(Abgeschlossen!)

$ docker ps

Ein Befehl zum Anzeigen des aktuell ausgeführten Containers. Wenn Sie auf `` `localhost: 3000``` zugreifen, sehen Sie das übliche Yay! Sie sind auf Schienen!

`Wenn Sie den Container löschen möchten, gehen Sie wie folgt vor`

$ docker-compose down

Überprüfen Sie, ob der Container mit `docker ps``` gelöscht wurde. Um einen Container zu erstellen und zu starten, führen Sie docker-compose up -d`` aus.

Zusammenfassung

Ich denke es war ziemlich einfach! Lassen Sie uns die App damit entwickeln! : Daumen hoch: