[RUBY] Rails 6 (mode API) + création d'environnement MySQL Docker par docker-compose (pour Mac)
introduction
On parlait de rendre l'environnement docker afin de procéder à la rénovation complète à l'emploi à temps partiel. J'ai décidé de le faire avec la configuration du front-end Nuxt.js et du back-end Rails 6, et je serai en charge de la partie back-end, alors écrivons beaucoup un Dockerfile! Je vais donc présenter la configuration terminée en l'implémentant pour l'étude. Comment créer un conteneur Rails est brièvement décrit sur la page officielle Docker , mais cette fois le Dockerfile considérant Rails 6 Je vais également vous présenter comment écrire et comment créer un conteneur MySQL.
Propre compétence
Il y a environ un an et demi, j'ai commencé à toucher les rails en tant qu'individu, et mon expérience de développement pratique en tant qu'ingénieur Web dure un peu plus d'un an, ce qui n'est pas une longue période. Cependant, je grandis rapidement en profitant du large éventail de connaissances préalables que j'ai acquises à l'université et de mon attitude face à divers défis. Même dans le projet précédent, je touchais à docker, en changeant le conteneur de base de données (MarinaDB-> MySQL), en créant un script shell pour les paramètres initiaux, etc. Je n'ai pas eu la chance de créer un docker à partir de zéro, alors j'ai essayé cette fois.
création d'environnement Docker
À partir de là, nous allons créer un environnement à l'aide de docker.
organisation des fichiers
Tout d'abord, je présenterai brièvement la structure des fichiers. En supposant que le nom de l'application à créer est «sample», les fichiers associés cette fois ont la structure de fichiers suivante.
sample
|- backend --- app
| |- bin
| |- config --- ...
| | |- database.yml
| | |- ...
| |- ...
| |- Dockerfile
| |- Gemfile
| |- Gemfile.lock
| |- ...
|- db --- data --- ...
| |- my.cnf
|- docker-compose.yml
En fait, il y aura plus de fichiers (créés), mais ce sont les seuls fichiers à manipuler cette fois.
Création des fichiers requis
Ensuite, je décrirai les fichiers liés à docker. backend/Dockerfile Ce sera un fichier avec des instructions pour construire un conteneur Rails. Le contenu est répertorié ci-dessous et les commentaires expliquent ce que fait chaque processus.
backend/Dockerfile
#Image et version à utiliser
FROM ruby:2.7.1
#Installez les bibliothèques requises
RUN apt-get update -qq && \
apt-get install -y build-essential \
libpq-dev \
nodejs
#Ce qui suit est les rails 6 ou version ultérieure(Hors mode API)Nécessaire dans
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
#Créez un dossier appelé app dans le conteneur
#* Les dossiers ne sont pas créés sur le PC local
RUN mkdir /app
#Changer la racine en répertoire de l'application
ENV APP_ROOT /app
WORKDIR $APP_ROOT
#Gemfile sur le PC local(.lock)Dans le conteneur
ADD ./Gemfile $APP_ROOT/Gemfile
ADD ./Gemfile.lock $APP_ROOT/Gemfile.lock
#Exécutez l'installation du bundle pour copier les fichiers sur le PC local dans le conteneur
RUN bundle install
ADD . $APP_ROOT
#Numéro de port que le conteneur écoute
EXPOSE 3000
#Commande à exécuter
CMD ["rails", "server", "-b", "0.0.0.0"]
Depuis rails6, Webpacker est la valeur par défaut, donc si yarn n'est pas installé, une erreur se produira lors de la création de rails new.
Cependant, il n'est pas nécessaire d'installer yarn lors de la création en mode API décrit plus loin.
backend/Gemfile
Ecrivez Gemfile à l'avance pour installer Rails.
Ce fichier sera réécrit plus tard lorsque vous ferez de «rails new».
Ici, les rails 6 ou version ultérieure sont spécifiés.
backend/Gemfile
source 'https://rubygems.org'
gem 'rails', '~> 6'
backend/Gemfile.lock Lorsque vous effectuez une `` installation groupée '', cela créera quelque chose comme un dessin de conception de bibliothèque basé sur les dépendances. Créez-en un vide. Plus tard, j'ai eu une erreur si le fichier n'existait pas.
backend/Gemfile.lock
db/data/ Préparons uniquement le répertoire
db/my.cnf Il s'agit d'un fichier lié aux paramètres MySQL.
my.cnf
[mysqld]
character-set-server=utf8mb4
collation-server=utf8mb4_unicode_ci
sql_mode=''
[client]
default-character-set=utf8mb4
Les paramètres de code de caractère et les paramètres sql_mode sont définis.
Surtout, je pense qu'il vaut mieux définir sql_mode.
C'est parce que le sql_mode par défaut a changé depuis MySQL 5.7, et vous pouvez souvent obtenir une erreur, en particulier dans des modes tels que ʻonly_full_group_by, donc il est explicite quel sql_mode` utiliser. Écrivons-le. Cette fois, aucun paramètre (par défaut pour MySQL 5.6.5 ou version antérieure) n'est explicitement spécifié.
(Je veux écrire plus d'articles ici)
docker-compose.yml Enfin, écrivez docker-compose. Une brève explication est donnée dans les commentaires.
docker-compose.yml
version: "3"
services:
# MySQL
db:
#Image à construire
image: mysql:5.7
#Spécification des variables d'environnement
environment:
MYSQL_ROOT_PASSWORD: root
MYSQL_DATABASE: spportunity
MYSQL_USER: root
MYSQL_PASSWORD: root
TZ: 'Asia/Tokyo'
#Définir le code de caractère sur utf8mb4
command: mysqld --character-set-server=utf8mb4 --collation-server=utf8mb4_unicode_ci
volumes:
# db/Montez le répertoire data sur le répertoire mysql du conteneur
- ./db/data/:/var/lib/mysql
# /db/my.cnf fichier mon dans le conteneur.Monter sur le fichier de configuration cnf
- ./db/my.cnf:/etc/mysql/conf.d/my.cnf
ports:
- 3306:3306
#Rails
backend:
#Spécifier la source de construction
build:
context: ./backend
dockerfile: Dockerfile
#Spécifier le nom du conteneur
container_name: "sample-backend"
#La spécification d'une commande au démarrage Rails s est exécutée après la fin du processus précédent.
command: bash -c "rm -f tmp/pids/server.pid && rails s -p 3000 -b '0.0.0.0'"
#Montez les fichiers dans le dossier backend dans le répertoire de l'application dans le conteneur
volumes:
- ./backend/:/app
ports:
- "3000:3000"
#Commencer après le conteneur DB
depends_on:
- db
Maintenant que le fichier est prêt, créons l'application rails.
Créer une application de rails
Créez une application de rails à l'aide de la commande docker-compose.
Assurez-vous que le répertoire actuel est «sample».
Créer des rails en mode normal (besoin d'installer du fil dans dockerfile)
% docker-compose run backend rails new . --force --no-deps --database=mysql --skip-bundle
--Récrire --force ... Gemfile
---- database = mysql ... Spécifiez MySQL pour la base de données
--Skip --skip-bundle ... bundle (Gemfile.lock n'est pas encore modifié)
Créer des rails en mode API
% docker-compose run backend rails new . --force --no-deps --database=mysql --skip-bundle --api
---- api ... Options de création en mode API
Une fois terminé, vous aurez un grand nombre de dossiers et de fichiers liés aux rails dans le dossier backend /.
J'écrirai sur la différence entre le mode API et le mode normal et la différence entre les fichiers.
Construisez le conteneur
% docker-compose build
L'exécution de cette commande créera un conteneur MySQL et une installation groupée dans le conteneur rails. Si vous regardez la console, vous pouvez voir que le contenu du Dockerfile est exécuté dans l'ordre.
Paramètres de connexion des rails à la base de données
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'] %>
Remplacez les informations de connexion par l'image du conteneur MySQL que vous avez créée précédemment pour l'hôte et les variables d'environnement du conteneur que vous avez créé précédemment pour votre nom d'utilisateur et votre mot de passe.
Installez Webpacker (sauf en mode API)
% docker-compose run backend rails webpacker:install
Créer une base de données
% docker-compose run backend rails db:create
Démarrer le docker
Si vous arrivez à ce point, le réglage est terminé. Tout ce que vous avez à faire est de démarrer docker!
% docker-compose up
Assurez-vous que Rails est activé dans votre navigateur
Lorsque j'accède à http: // localhost: 3000 / avec un navigateur, Rails est lancé avec succès.
Évolutivité
Je ne l'ai pas mentionné cette fois, mais en ajoutant un conteneur frontal, etc., il sera possible de créer un environnement qui a à la fois une application frontale et un serveur API en un seul coup. Dans ce cas, vous devrez créer un Dockerfile et ajouter un conteneur à docker-compose dans la même procédure. Je suis toujours un débutant en front-end, donc j'aimerais aussi éventuellement créer un conteneur frontal.
Impressions
Après tout, docker est pratique. Je n'ai pas utilisé docker dans mon développement personnel, mais je pense l'utiliser de manière positive à partir de maintenant. Dans ce cas, j'aimerais écrire un article.
C'était la première fois que j'écrivais un article sur la qiita, et quand je me demandais combien je devais écrire, cela devenait assez long. Cependant, il y a beaucoup de gens qui écrivent beaucoup d'articles très riches, et je sens que j'ai encore beaucoup à faire. Je ne peux peut-être pas écrire quelque chose qui a encore souvent du contenu, mais j'aimerais publier mes connaissances petit à petit.
Référencé
Je me suis référé à l'article de qiita suivant. J'ai également imité le style d'écriture, ce qui a été très utile. Merci beaucoup.
https://qiita.com/azul915/items/5b7063cbc80192343fc0 https://qiita.com/kodai_0122/items/795438d738386c2c1966
En plus de l'article ci-dessus, il comprend également le mode API, le montage et les paramètres du conteneur MySQL, etc.
Recommended Posts