Manuel de construction de l'environnement de développement stable pour "Rails6" avec "Docker-compose"

Environnement créé dans cet article

Docker-compose

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

Ceux qui veulent l'utiliser pour le moment

Ceux qui souhaitent l'utiliser dès que possible et le construire sont publiés dans le référentiel GitHub ci-dessous. La procédure est décrite dans README, mais veuillez exécuter les commandes suivantes dans l'ordre.

1. Exécutez git clone <Nom du projet> à partir de README sur le site suivant
2. Déplacez le répertoire du projet avec cd <Nom du projet>
3. Exécutez la commande ./qs setup

• Veuillez vous référer au READ ME sur le site suivant et exécuter Rails6-QS

La commande prend environ 20 minutes. Veuillez être patient. (Lol) Lorsque vous avez terminé, appuyez sur localhost: 3000 dans votre navigateur et vous verrez l'écran initial familier de Rails. Le tableau de bord de Docker doit également contenir des conteneurs Web, db dans le nom du projet.

Que créer dans cet article

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

• Le référentiel public est nommé qs (abréviation de démarrage rapide).

• .gitignore
• Gemfile
• database.yml

① Créer Dockerfile

Tout d'abord, créez à partir du Dockerfile. Lors de la création d'un Dockerfile

--Site officiel
Docker Quickstart

• Docker Docs
  Docker Docs

L'explication du site ci-dessus est facile à comprendre.

Les conteneurs créés à l'aide des images définies dans Dockerfile doivent être éphémères si possible. Notre «éphémère» signifie qu'il peut être arrêté et détruit et peut être construit et utilisé avec une configuration clairement minimale.

Comme indiqué sur le site ci-dessus, Dockerfile vise à être construit avec la configuration minimale. Dans ce qui suit, nous expliquerons le Dockerfile créé cette fois pour chaque élément.

Structure des fichiers

Spécification de la version Ruby Version: 2.7

FROM ruby:2.7

Requis pour utiliser le japonais sur la console de rails

ENV LANG C.UTF-8

Avertissement caché / réglage du port d'écoute

1. Paramètres pour éliminer les avertissements DEBCONF
   [Ubuntu manual] http://manpages.ubuntu.com/manpages/bionic/man7/debconf.7.html --Pour éviter les avertissements émis par la commande apt-key --Le fichier généré dans la zone de montage Docker est
   Il y a des cas où vous ne disposez pas des droits d'écriture pour le répertoire de cache et vous générez une erreur.
   XDG_CACHE_HOME spécifie un répertoire avec l'autorisation d'écriture, mais
   Apparemment, cela ne se produit pas lorsque vous utilisez uniquement des rails.
   S'il n'y a pas de problème, vous pouvez le supprimer.

• Le port sur lequel le conteneur écoute les connexions

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

Installation du package de conteneur

1. apt-get et apt-get install-y peuvent utiliser la dernière version du paquet sans être mis en cache. --Installation des outils de construction

• Requis pour la prise en charge de PostgreSQL. --installation de vim *
• Spécifié pour ajouter la commande less (linux). *
• Pour utiliser le package d'outils open source graphviz *

Si vous n'utilisez pas la partie marquée d'un *, vous pouvez la supprimer.

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

Installation de fil

Puisque Webpack est devenu la norme depuis Rails6, une erreur se produira si yanr n'est pas installé.

1. Pour gérer https, le paquet est installé avec ʻapt-transport-https`. --La commande suivante consiste à installer du fil.

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

Créer un répertoire de travail

# setting work directory
RUN mkdir /app
WORKDIR /app

Paramètres des variables d'environnement

• À utiliser lors de la saisie d'un script ou d'un conteneur

ENV HOME /app

Créer Gemfile

COPY Gemfile /app/Gemfile

Si vous décrivez tout ce qui précède, ce sera comme suit. (* Certains commentaires ont été ajoutés.)

# 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

② Créer un fichier Docker-compose.yml

Spécifier la version de docker-compose

La situation actuelle est de 3.

version: '3'

création de service

• image
  Spécifiez la base de données, le Web, etc.
  J'ai spécifié db`` redis`` chrome web: & app spring`` solagraph qui est susceptible d'être utilisé cette fois.
  J'espère que vous pourrez le corriger en le supprimant si nécessaire.
• port
  Paramètres de port (créés avec un contenu de port généralement défini)
• volume
  Paramètres de montage. Il s'agit d'une spécification de la destination de stockage des données qui ne doit pas être supprimée après la suppression du conteneur Docker tel que db.
• build
  Il montre le chemin où se trouve Dockerfile etc., mais fondamentalement c'est . et c'est le répertoire courant.

Questions complémentaires

• shm_size
  Lors de l'utilisation de sélénium-chrome, la mémoire peut s'épuiser, alors je l'ai légèrement augmentée.
• .:
  Il est utilisé pour accélérer le chargement du volume avec la fonction docker-compose.
• <<: *app
  Les paramètres du service Web sont hérités par spring.
• tty: true
  Paramètres pour maintenir le conteneur en marche --À propos de la configuration du port
  Le port du côté gauche est le port du côté de l'hôte et le port du côté droit est le port du côté du conteneur.
  

Ceci est également résumé comme suit en décrivant tout ce qui précède.

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

③ Création de scripts

Résumez le contenu de l'exécution avec un script shell. En faisant cela, vous pouvez réaliser que Dockerfile peut être arrêté / détruit et peut être construit et utilisé avec évidemment la configuration minimale. Les scripts shell sont ceux utilisés pour exécuter les commandes Unix.

Extrait de base du script shell

Bien que ce ne soit pas un article de commentaire sur le charscript, je vais extraire et décrire les bases afin que je puisse comprendre le script shell cible. J'ai fait référence au site suivant lors de la création de l'article et de la compréhension du fonctionnement du shell. [Introduction des commandes de base pour les scripts shell pour les débutants] https://qiita.com/zayarwinttun/items/0dae4cb66d8f4bd2a337 [Référence du script Shell] https://shellscript.sunone.me/

--Déclaration #!/bin/bash Requis pour déclarer un script shell. Il existe également un moyen d'écrire #! / Bin / sh, mais si vous utilisez la fonction unique de bash, sh sera NG. Site référencé: https://sechiro.hatenablog.com/entry/20120806/1344267619 Sauf si vous êtes particulier à ce sujet, vous pouvez utiliser #! / Bin / bash.

--Commenter Ajoutez simplement # au début.

--Production Sortie avec ʻecho`

• si condition
• La manière de base d'écrire ʻif est ʻif [condition] alors la commande fi. --Si la condition est vraie Exécutez la commande suivante de «alors». --Pour différentes conditions, cochez ʻelif [Condition 2] `.
• S'il n'y a pas de condition vraie, exécutez la commande suivante de ʻelse` pour quitter. --S'il n'y en a pas d'autre, cela se terminera tel quel.

--Comment prendre des arguments Lors de l'accès à une variable, mettez «» avant le nom de la variable. Ou mettez `et placez la variable dans{}`.

• -e Texte spécial d'échappement

• $* Tous les arguments sont traités comme un seul. Il y a «$ @» dans un processus similaire. Si vous ne l'enfermez pas en double couche, c'est la même chose que $ @, mais si vous l'entourez, il sera sorti pour chaque argument, Il y a une différence quant à savoir s'il faut sortir tout en même temps avec un seul argument.

• $1 Premier argument

• $0 Nom du script

--Fonction Dans les scripts shell, vous pouvez écrire et citer des fonctions Function () { echo }

• Fin du traitement Pour terminer le script prématurément, donnez un numéro à la commande ʻexit`.

• Swith La méthode de base pour écrire un commutateur est la commande case variable in condition / value) ;; esac. Si la condition / valeur correspond à la variable, exécutez la commande suivante.

Présentation de la configuration du script shell

1. Tout d'abord, spécifiez la commande docker-compose pour dc avec le chemin complet.
2. Si docker n'est pas installé, vous serez invité à l'installer.
3. Stockez la valeur dans chaque variable (rm, app, db, app_name)
4. Exécutez la valeur de commande de $ 1 avec echo
5. $ 1 se présente sous la forme de traitement de la commande donnée en fonction de la valeur donnée par la fonction (développée par la syntaxe de commutation en fonction de la fonction).
6. Le nom du script est écrit en $ 0 afin qu'il puisse être utilisé comme aide.

Si vous créez un fichier de script contenant diverses commandes et paramètres avec le contenu ci-dessus, ce sera comme suit.

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

Autres fichiers créés

Bien qu'il s'agisse d'un autre fichier de paramètres, l'explication est omise car elle est créée par construction générale. En complément, PostgreSQL est sélectionné comme base de données. La raison en est que MySQL peut provoquer une erreur de validation à partir de Rails 6.0 et qu'il est nécessaire d'ajouter des paramètres. Concernant ce point, si vous utilisez MySQL, vous pouvez le paramétrer, Puisque PostgreSQL ne nécessite aucun paramètre, il est utilisé comme base de données. Veuillez consulter le site suivant pour plus de détails. Que faire si vous recevez un avertissement "Le validateur d'unicité n'appliquera plus la comparaison sensible à la casse dans Rails 6.1." Dans 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

Épilogue

Créez un environnement de développement Rails 6 localement tout en utilisant rbenv etc. avec homebrew Il semble que cela n'a pas demandé beaucoup d'efforts, mais créer un environnement de développement dans un conteneur stable est Même sur le site officiel de Docker, cela a été décrit dans Rails 5, et cela semblait difficile à construire dans Rails 6.

Aussi, sur le site officiel Quick Start, la commande d'exécution est décrite dans le Dockerfile, Si vous voulez écrire avec la plus petite configuration possible, il est préférable de le diviser en scripts shell Il est considéré que l'environnement de développement devrait inclure la maintenabilité.

• L'environnement de production inclut la possibilité que le Dockerfile puisse changer

Merci d'avoir lu cet article. J'espère que cela aide à certains développements.

Enfin, nous tenons à vous remercier pour votre coopération et vos conseils lors de la rédaction de cet article. Merci beaucoup.

Site / source de référence

Quickstart Compose and Rails Meilleures pratiques Dockerfile Exemple d'exécution de script Bash Nouveau manuel Linux SB Creative