Konstruktionshandbuch für eine stabile Entwicklungsumgebung für "Rails6" mit "Docker-compose"

In diesem Artikel erstellte Umgebung

Docker-compose

• Web
  • Ruby version:2.7〜
  • Rails version:6.0.3.4〜
• db
  • PostgreSQL version: 12.4〜

Diejenigen, die es vorerst nutzen wollen

Diejenigen, die es so schnell wie möglich verwenden und erstellen möchten, werden im folgenden GitHub-Repository veröffentlicht. Die Vorgehensweise ist in README beschrieben, führen Sie jedoch die folgenden Befehle der Reihe nach aus.

1. Führen Sie git clone <Projektname> von README auf der folgenden Site aus
2. Verschieben Sie das Projektverzeichnis mit cd <Projektname>
3. Führen Sie den Befehl ./qs setup aus

• Bitte lesen Sie READ ME auf der folgenden Seite und führen Sie es aus. Rails6-QS

Es dauert ungefähr 20 Minuten, um den Befehl auszuführen. Bitte haben Sie Geduld. (Lol) Wenn Sie fertig sind, klicken Sie in Ihrem Browser auf localhost: 3000 und Sie sehen den bekannten Rails-Startbildschirm. Das Docker-Dashboard sollte auch Web- und DB-Container im Projektnamen enthalten.

Was in diesem Artikel zu erstellen

• Dockerfile
• Docker-compose.yml --Shell-Skript (sample.bash)
  

• Das öffentliche Repository heißt qs (kurz für Schnellstart).

• .gitignore
• Gemfile
• database.yml

① Docker-Datei erstellen

Erstellen Sie zunächst aus der Docker-Datei. Beim Erstellen einer Docker-Datei

• Offizielle Website
  Docker Quickstart
• Docker Docs
  Docker Docs

Die Erklärung der obigen Seite ist leicht zu verstehen.

Container, die mit den in Dockerfile definierten Bildern erstellt wurden, sollten nach Möglichkeit kurzlebig sein. Unser "kurzlebiges" bedeutet, dass es gestoppt und zerstört werden kann und klar aufgebaut und mit minimalem Setup verwendbar ist.

Wie auf der obigen Website angegeben, soll "Dockerfile" mit minimalem Setup erstellt werden. Im Folgenden erklären wir die diesmal für jedes Element erstellte Docker-Datei.

Dateistruktur

Ruby-Versionsspezifikation Version: 2.7

FROM ruby:2.7

Erforderlich, um Japanisch auf der Schienenkonsole zu verwenden

ENV LANG C.UTF-8

Warnung Hidden / Listen Port-Einstellung

1. Einstellungen zum Entfernen von DEBCONF-Warnungen
   [Ubuntu manual] http://manpages.ubuntu.com/manpages/bionic/man7/debconf.7.html

• Um Warnungen durch den Befehl apt-key zu vermeiden --Die im Docker-Mount-Bereich generierte Datei lautet
  Es gibt Fälle, in denen Sie keine Schreibberechtigung für das Cache-Verzeichnis haben und einen Fehler auslösen.
  XDG_CACHE_HOME gibt ein Verzeichnis mit Schreibberechtigung an, aber
  Anscheinend passiert es nicht, wenn nur Rails verwendet werden.
  Wenn es kein Problem gibt, können Sie es entfernen.
• Der Port, an dem der Container auf Verbindungen wartet

ENV DEBCONF_NOWARNINGS yes
ENV APT_KEY_DONT_WARN_ON_DANGEROUS_USAGE yes
ENV XDG_CACHE_HOME /tmp
EXPOSE 3000

Installation des Containerpakets

1. apt-get und apt-get install-y können die neueste Version des Pakets verwenden, ohne zwischengespeichert zu werden. --Installation von Build-Tools

• Erforderlich für die PostgreSQL-Unterstützung.
• Installation von vim *
• Angegeben, um den Befehl less (Linux) hinzuzufügen. * * --Um das Open Source Toolpaket graphviz * zu verwenden

Wenn Sie das mit * gekennzeichnete Teil nicht verwenden, können Sie es löschen.

RUN apt-get update -qq && apt-get install -y \
    build-essential \
    libpq-dev \
    vim \
    less \
    graphviz

Garnmontage

Da Webpack seit Rails6 zum Standard geworden ist, tritt ein Fehler auf, wenn yanr nicht installiert ist.

1. Das Paket wird mit apt-transport-https installiert, um mit https fertig zu werden. --Der nachfolgende Befehl ist das Einlegen des Garns.

RUN apt-get install apt-transport-https
RUN curl -sS https://dl.yarnpkg.com/debian/pubkey.gpg | apt-key add -
RUN echo "deb https://dl.yarnpkg.com/debian/ stable main" | tee /etc/apt/sources.list.d/yarn.list
RUN apt-get update && apt-get install -y yarn

Arbeitsverzeichnis erstellen

# setting work directory
RUN mkdir /app
WORKDIR /app

Einstellungen für Umgebungsvariablen

• Zur Verwendung bei der Eingabe eines Skripts oder Containers

ENV HOME /app

Gemfile erstellen

COPY Gemfile /app/Gemfile

Wenn Sie alle oben genannten Punkte beschreiben, ist dies wie folgt. (* Einige Kommentare wurden hinzugefügt.)

# use ruby version 2.7
FROM ruby:2.7

# using japanese on rails console
ENV LANG C.UTF-8

# remove warn
ENV DEBCONF_NOWARNINGS yes
ENV APT_KEY_DONT_WARN_ON_DANGEROUS_USAGE yes
ENV XDG_CACHE_HOME /tmp
EXPOSE 3000

# install package to docker container
RUN apt-get update -qq && apt-get install -y \
    build-essential \
    libpq-dev \
    vim \
    less \
    graphviz

# install yarn
RUN apt-get install apt-transport-https
RUN curl -sS https://dl.yarnpkg.com/debian/pubkey.gpg | apt-key add -
RUN echo "deb https://dl.yarnpkg.com/debian/ stable main" | tee /etc/apt/sources.list.d/yarn.list
RUN apt-get update && apt-get install -y yarn

# setting work directory
RUN mkdir /app
WORKDIR /app

# setting environment value
ENV HOME /app

# executing bundle install
COPY Gemfile /app/Gemfile

② Erstellen Sie die Datei Docker-compose.yml

Geben Sie die Version von Docker-Compose an

Die aktuelle Situation ist 3.

version: '3'

Serviceerstellung

• image
  Geben Sie die Datenbank, das Web usw. an.
  Ich habe db`` redis`` chrome`` web: & app spring`` solagraph angegeben, das diesmal wahrscheinlich verwendet wird.
  Ich hoffe, Sie können es korrigieren, indem Sie es bei Bedarf löschen.
• port
  Porteinstellungen (erstellt mit allgemein festgelegten Portinhalten)
• volume
  Einstellungen einhängen. Dies ist eine Angabe des Speicherziels von Daten, die nach dem Löschen des Docker-Containers wie db nicht gelöscht werden sollen.
• build
  Es zeigt den Pfad, in dem sich "Dockerfile" usw. befindet, aber im Grunde ist es "." Und es ist das aktuelle Verzeichnis.

Ergänzende Angelegenheiten

• shm_size
  Bei Verwendung von Selen-Chrom kann der Speicher knapp werden, daher habe ich ihn etwas vergrößert.
• .:
  Es wird verwendet, um das Laden von Volumes mit der Docker-Compose-Funktion zu beschleunigen.
• <<: *app
  Die Webdiensteinstellungen werden bis zum Frühjahr übernommen.
• tty: true
  Einstellungen, um den Container am Laufen zu halten
• Über die Porteinstellung
  Der Port auf der linken Seite ist der Port auf der Hostseite, und der Port auf der rechten Seite ist der Port auf der Containerseite.
  

Dies wird auch im Folgenden zusammengefasst, indem alle oben genannten Punkte beschrieben werden.

version: '3'
services:
  db:
    image: postgres
    ports:
      - "5432:5432"
    volumes:
      - data:/var/lib/postgresql/data:cached
    environment:
      POSTGRES_PASSWORD: postgres
  redis:
    image: redis
    ports:
      - "6379:6379"
    command: redis-server --appendonly yes
    volumes:
       - redis-data:/data:cached
  chrome:
    image: selenium/standalone-chrome
    ports:
      - "4444:4444"
  web: &app
    build: .
    command: bundle exec rails s -p 3000 -b '0.0.0.0'
    volumes:
      - .:/app:cached
      - bundle:/usr/local/bundle:cached
      - /app/.git
    environment:
      HOME: /app
      RAILS_ENV: development
    ports:
      - "3000:3000"
    tty: true
    links:
      - db
  spring:
    <<: *app
    command: bundle exec spring server
    ports: []
  solargraph:
    <<: *app
    command: bundle exec solargraph socket --host=0.0.0.0 --port=7658
    ports:
      - "8091:7658"
    links: []

volumes:
  bundle:
    driver: local
  data:
    driver: local
  redis-data:
    driver: local

③ Skripterstellung

Fassen Sie den Ausführungsinhalt mit einem Shell-Skript zusammen. Auf diese Weise können Sie erkennen, dass "Dockerfile" gestoppt / zerstört werden kann und mit offensichtlich minimalem Setup erstellt und verwendet werden kann. Shell-Skripte werden zum Ausführen von Unix-Befehlen verwendet.

Grundlegender Auszug aus dem Shell-Skript

Obwohl es sich nicht um einen Kommentar zum Charscript handelt, werde ich die Grundlagen extrahieren und beschreiben, damit ich das Ziel-Shell-Skript verstehen kann. Ich habe beim Erstellen des Artikels und beim Verstehen der Shell-Operation auf die folgende Site verwiesen. [Einführung grundlegender Befehle für Shell-Skripte für Anfänger] https://qiita.com/zayarwinttun/items/0dae4cb66d8f4bd2a337 [Shell Script Referenz] https://shellscript.sunone.me/

--Erklärung #!/bin/bash Erforderlich, um ein Shell-Skript zu deklarieren. Es gibt auch eine Möglichkeit, "#! / Bin / sh" zu schreiben. Wenn Sie jedoch die eindeutige Funktion "bash" verwenden, ist "sh" NG. Referenzierte Website: https://sechiro.hatenablog.com/entry/20120806/1344267619 Sofern Sie nicht besonders darauf eingehen, können Sie #! / Bin / bash verwenden.

--Auskommentieren Fügen Sie einfach am Anfang # hinzu.

--Ausgabe Ausgabe mit "Echo"

--wenn Zustand

• Die grundlegende Methode zum Schreiben von "if" ist "if [condition] then command fi". --Wenn die Bedingung erfüllt ist Führen Sie den folgenden Befehl von then aus.

• Für andere Bedingungen "elif [Bedingung 2]" prüfen. --Wenn keine echte Bedingung vorliegt, führen Sie zum Beenden den folgenden Befehl von else aus.

• Wenn es kein "Sonst" gibt, endet es so wie es ist.

• Wie man Argumente nimmt Wenn Sie auf eine Variable zugreifen, setzen Sie $ $ vor den Variablennamen. Oder setzen Sie "$" und schließen Sie die Variable in "{}" ein.

• -e Entkomme speziellem Text

• $* Alle Argumente werden als eins verarbeitet. In einem ähnlichen Prozess gibt es $ @. Wenn Sie es nicht in Doppelbeschichtung einschließen, ist es dasselbe wie $ @, aber wenn Sie es einschließen, wird es für jedes Argument ausgegeben. Es gibt einen Unterschied, ob alle auf einmal mit einem Argument ausgegeben werden sollen.

• $1 Erstes Argument

• $0 Skriptname

--Funktion In Shell-Skripten können Sie Funktionen schreiben und zitieren Function () { echo }

• Verarbeitung beenden Geben Sie dem Befehl exit eine Nummer, um das Skript vorzeitig zu beenden.

• Swith Die grundlegende Methode zum Schreiben eines Schalters ist der Befehl case variable in condition / value) ;; esac. Wenn die Bedingung / der Wert mit der Variablen übereinstimmt, führen Sie den folgenden Befehl aus.

Übersicht über die Konfiguration des Shell-Skripts

1. Geben Sie zunächst den Docker-Compose-Befehl für DC mit dem vollständigen Pfad an.
2. Wenn Docker nicht installiert ist, werden Sie aufgefordert, es zu installieren.
3. Speichern Sie den Wert in jeder Variablen (rm, app, db, app_name).
4. Führen Sie den Befehlswert $ 1 mit echo aus
5. $ 1 besteht in der Verarbeitung des angegebenen Befehls unter Berücksichtigung des von der Funktion angegebenen Werts (erweitert durch die Switch-Syntax je nach Funktion).
6. Der Skriptname wird in $ 0 geschrieben, damit er als Hilfe verwendet werden kann.

Wenn Sie eine Skriptdatei mit verschiedenen Befehlen und Einstellungen mit den oben genannten Inhalten erstellen, sieht dies wie folgt aus.

qs.bash

dc=$(which docker-compose) # docker-compose command with full path

if [[ -x "$dc" ]]; then
  :
else
  echo "Please install Docker before run this command."
  exit 2
fi

rm="--rm" # To destroy a container

app="web" # describe $application service name from docker-compose.yml

db="db" # describe database service name from docker-compose.yml

app_name=$(pwd | awk -F "/" '{ print $NF }') # get project dir name

# define container name
app_container="${app_name}_${app}_1"
db_container="${app_name}_${db}_1"

echoing() {
  echo "========================================================"
  echo "$1"
  echo "========================================================"
}

rm_pids() {
  if [ -f "tmp/pids/server.pid" ]; then
    rm -f tmp/pids/server.pid
  fi
}

create_project() {
  echoing "Exec Bundle Install for executing rails new command"
  compose_build $app
  bundle_cmd install

  echoing "Exec rails new with postgresql and webpack"
  bundle_exec rails new . -f -d=postgresql $*

  echoing "Update config/database.yml"
  mv database.yml config/database.yml

  echoing "Exec db create"
  bundle_exec rails db:create

  echoing "docker-compose up"
  compose_up $app

  echo "You can access to localhost:3000"
}

init_services() {
  echoing "Building containers"
  $dc down -v
  $dc build --no-cache $app

  bundle_cmd install

  if [ "--webpack" == "$1" ]; then
    run_yarn install
  fi

  rails_cmd db:migrate:reset
  rails_cmd db:seed

  rm_pids

  $dc up $app
}

compose_up() {
  echoing "Create and start containers $*"
  rm_pids
  $dc up -d "$1"
}

compose_down() {
  echoing "Stop and remove containers $*"
  $dc down $*
}

compose_build() {
  echoing "Build containers $*"
  $dc build $*
}

compose_start() {
  echoing "Start services $*"
  rm_pids
  $dc start $*
}

compose_stop() {
  echoing "Stop services $*"
  $dc stop $*
}

compose_restart() {
  echoing "Restart services $*"
  $dc restart $*
}

compose_ps() {
  echoing "Showing running containers"
  $dc ps
}

logs() {
  echoing "Logs $*"
  $dc logs -f $1
}

invoke_bash() {
  $dc run $rm -u root $1 bash
}

invoke_run() {
  renv=""
  if [ -n "$RAILS_ENV" ]; then
    renv="-e RAILS_ENV=$RAILS_ENV "
  fi

  if [ -n "$TRUNCATE_LOGS" ]; then
    renv="$renv -e TRUNCATE_LOGS=$TRUNCATE_LOGS "
  fi

  dbenv=""
  if [ -n "$DISABLE_DATABASE_ENVIRONMENT_CHECK" ]; then
    dbenv="-e DISABLE_DATABASE_ENVIRONMENT_CHECK=$DISABLE_DATABASE_ENVIRONMENT_CHECK "
  fi

  $dc run $rm ${renv}${dbenv}$*
}

run_app() {
  invoke_run $app $*
}

run_db() {
  invoke_run $db $*
}

run_spring() {
  $dc exec spring $*
}

run_solargraph() {
  invoke_run solargraph $*
}

rails_server() {
  rm_pids
  # $dc run $rm ${renv}--service-ports $app rails s -p 3000 -b 0.0.0.0
  $dc run $rm --service-ports $app bundle exec foreman start -f Procfile.dev
}

rails_db() {
  case "$1" in
  set)
    rails_cmd db:migrate
    ;;
  up)
    rails_cmd db:migrate:up VERSION="$2"
    ;;
  down)
    rails_cmd db:migrate:down VERSION="$2"
    ;;
  reset)
    rails_cmd db:reset
    ;;
  *)
    rails_cmd db:migrate:status
    ;;
  esac
}

spring_db() {
  case "$1" in
  set)
    spring_cmd rake db:migrate
    ;;
  up)
    spring_cmd rake db:migrate:up VERSION="$2"
    ;;
  down)
    spring_cmd rake db:migrate:down VERSION="$2"
    ;;
  reset)
    spring_cmd rake db:reset
    ;;
  *)
    spring_cmd rake db:migrate:status
    ;;
  esac
}

spring_dive() {
  $dc exec spring bash
}

rails_cmd() {
  bundle_exec rails $*
}

rake_cmd() {
  bundle_exec rake $*
}

rspec_cmd() {
  $dc start chrome
  bundle_exec rspec $*
}

test_cmd() {
  bundle_exec test $*
}

bundle_cmd() {
  run_app bundle $*
}

bundle_exec() {
  run_app bundle exec $*
}

rubocop_cmd() {
  bundle_exec rubocop $*
}

rails_console() {
  bundle_exec rails c $*
}

spring_cmd() {
  run_spring spring $*
}

solargraph_cmd() {
  run_solargraph solargraph $*
}

rake_reset_db() {
  echoing "Running reset db"
  compose_stop $app
  DISABLE_DATABASE_ENVIRONMENT_CHECK=1 rake_cmd "db:reset"
  rake_cmd "db:fdw:setup"
  RAILS_ENV=test rake_cmd "db:fdw:setup"
  compose_up $app
}

db_console() {
  # from config/database.yml
  database="development"
  username="postgres"
  port="5432"

  run_db psql -h $db_container -p $port -U $username $database
}

db_dump() {
  # from config/database.yml
  database="development"
  username="postgres"
  port="5432"

  tm=$(date +\%Y\%m\%d-\%H\%M)
  dump_file=tmp/dbdump-${dbname}-${tm}.dump

  echoing "Dump database $dbname data to $dump_file"

  run_db pg_dump -h $db_container -p $port -U $username --disable-triggers $database >$dump_file
  echo "done"
}

run_yarn() {
  run_app bin/yarn $*
}

run_npm() {
  run_app npm $*
}

run_webpack() {
  run_app webpack $*
}

cmd=$1
shift
case "$cmd" in
setup)
  create_project $* && exit 0
  ;;
init)
  init_services $* && exit 0
  ;;
ps)
  compose_ps && exit 0
  ;;
up)
  compose_up $* && compose_ps && exit 0
  ;;
build)
  compose_build $* && exit 0
  ;;
start)
  compose_start $* && exit 0
  ;;
stop)
  compose_stop $* && exit 0
  ;;
restart)
  compose_restart $* && exit 0
  ;;
down)
  compose_down $* && exit 0
  ;;
logs)
  logs $*
  ;;
bash)
  invoke_bash $*
  ;;
run)
  invoke_run $*
  ;;
server)
  rails_server $*
  ;;
rails)
  rails_cmd $*
  ;;
db)
  rails_db $*
  ;;
cons)
  rails_console $*
  ;;
rake)
  rake_cmd $*
  ;;
rspec)
  rspec_cmd $*
  ;;
test)
  test_cmd $*
  ;;
bundle)
  bundle_cmd $*
  ;;
rubocop)
  rubocop_cmd $*
  ;;
reset-db)
  rake_reset_db
  ;;
psql)
  db_console $*
  ;;
db-dump)
  db_dump $*
  ;;
yarn)
  run_yarn $*
  ;;
npm)
  run_npm $*
  ;;
webpack)
  run_webpack $*
  ;;
spring)
  spring_cmd $*
  ;;
sdb)
  spring_db $*
  ;;
sdive)
  spring_dive $*
  ;;
solargraph)
  solargraph_cmd $*
  ;;
*)
  read -d '' help <<-EOF
Usage: $0 command

Service:
  setup    Create new rails application
  init     Initialize backend services then run
  ps       Show status of services
  up       Create service containers and start backend services
  down     Stop backend services and remove service containers
  start    Start services
  stop     Stop services
  logs     [options] default: none. View output from containers
  bash     [service] invoke bash
  run      [service] [command] run command in given container

App:
  server   Run rails server
  rails    [args] Run rails command in application container
  rake     [args] Run rake command in application container
  db       [args] Run rails db command you can use set(migrate), up, down, reset, other is status
           ex: ./qs db set #running rails db:migrate
               ./qs db up 2019010101 #running rails db:migrate:up VERSION=2019010101
  rspec    [args] Run rspec command in application container
  test     [args] Run Minitest command in application container
  bundle   [args] Run bundle command in application container
  cons     Run rails console
  rubocop  [args] Run rubocop
  yarn      Run yarn command in application container
  npm       Run npm  command in application container
  webpack   Run webpack  command in application container

Spring
  spring    Exec spring command in Spring container
  sdive     Into spring container
  sdb       [args] Run rails db command you can use set(migrate), up, down, reset, other is status
             ex: ./qs db set #running rails db:migrate
                 ./qs db up 2019010101 #running rails db:migrate:up VERSION=2019010101

Solargraph
  solargraph Run solargraph command in Spring container

DB:
  reset-db  reset database in DB container
  psql      launch psql console in DB container
  pg-dump   dump database data as sql file in DB container
EOF
  echo "$help"
  exit 2
  ;;
esac

Andere erstellte Dateien

Obwohl es sich um eine andere Einstellungsdatei handelt, wird die Erklärung weggelassen, da sie durch allgemeine Konstruktion erstellt wird. Als Ergänzung wird PostgreSQL als DB ausgewählt. Der Grund dafür ist, dass MySQL möglicherweise einen Validierungsfehler von Rails 6.0 verursacht und Einstellungen hinzugefügt werden müssen. In Bezug auf diesen Punkt können Sie, wenn Sie MySQL verwenden, Folgendes festlegen: Da für PostgreSQL keine Einstellungen erforderlich sind, wird dies als DB verwendet. Weitere Informationen finden Sie auf der folgenden Website. Was tun, wenn eine Warnung angezeigt wird? "Der Eindeutigkeitsprüfer erzwingt in Rails 6.1 keinen Vergleich zwischen Groß- und Kleinschreibung mehr." In Rails 6.0

database.yml

default: &default
  adapter: postgresql
  encoding: utf8
  min_messages: WARNING
  host: db
  port: 5432
  username: postgres
  password: postgres
  pool: 5
  timeout: 5000
  stats_execution_limit: 10

development:
  <<: *default
  database: development

test:
  <<: *default
  database: test

production:
  <<: *default
  database: production

Gemfile

source 'https://rubygems.org'

gem 'rails', '~> 6.0'

.gitignore

.bash_history
.bundle
.solargraph
.atom
.vscode
.viminfo

Nachwort

Erstellen Sie lokal eine Rails 6-Entwicklungsumgebung, während Sie rbenv usw. mit Homebrew verwenden Es scheint, dass es nicht viel Aufwand gekostet hat, aber das Erstellen einer Entwicklungsumgebung in einem stabilen Container ist es Selbst auf der offiziellen Docker-Website wurde es in Rails 5 beschrieben, und es schien schwierig, Rails 6 zu erstellen.

Auf der offiziellen Website Quick Start wird der Ausführungsbefehl in der Docker-Datei beschrieben. Wenn Sie mit dem kleinstmöglichen Setup schreiben möchten, ist es besser, es in Shell-Skripte zu unterteilen Es wird davon ausgegangen, dass die Entwicklungsumgebung Wartbarkeit beinhalten sollte.

• Die Produktionsumgebung enthält die Möglichkeit, dass sich die Docker-Datei ändert

Vielen Dank für das Lesen dieses Artikels. Ich hoffe es hilft bei einigen Entwicklungen.

Abschließend möchten wir uns bei Ihnen für Ihre Mitarbeit und Ihren Rat bei der Erstellung dieses Artikels bedanken. Vielen Dank.

Referenzseite / Quelle

Quickstart Compose and Rails Best Practices für Dockerfile Beispiel für die Ausführung eines Bash-Skripts Neues Linux Lehrbuch SB Creative