Créez un environnement pour lire le code source de redmine avec Docker. Le but est le suivant.
La raison de la création de l'environnement d'exploitation est que nous voulons lire le code tout en associant le comportement de l'application réelle au contenu du code dans notre esprit.
Nous croyons que la lecture de code écrit par des humains mènera à de nouvelles découvertes et à de nouveaux apprentissages. Dans mon cas, j'ai souvent des problèmes avec la division des classes, la dénomination, l'écriture de code de test, la gestion des erreurs, etc., donc j'ai une motivation pour augmenter le nombre de retraits autour de cela.
J'ai choisi Redmine pour les raisons suivantes.
Nous allons procéder en faisant référence à ce qui suit.
redminecode_reading)Créez les fichiers suivants directement dans le répertoire redmine.
Le contenu du fichier est le suivant.
Dockerfile
Puisque Gemfile de Redmine fait référence à «config / database.yml», vous devez faire «COPY. / Redmine» puis «bundle install».
En passant, ce que je fais avec référence est de changer le gem à installer en fonction de la base de données à utiliser. Par exemple, si les informations de connexion de postgres sont écrites dans config / database.yml, le gem pour se connecter à postgres sera installé.
Je n'avais pas beaucoup d'idée de changer dynamiquement la gemme spécifiée dans le Gemfile, donc je sens que j'ai déjà appris.
Dockerfile
FROM ruby:2.5
RUN 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
RUN apt-get update -qq && apt-get install -y nodejs postgresql-client yarn
RUN mkdir /redmine
WORKDIR /redmine
COPY Gemfile /redmine/Gemfile
COPY Gemfile.lock /redmine/Gemfile.lock
COPY . /redmine
RUN bundle install
# Add a script to be executed every time the container starts.
COPY entrypoint.sh /usr/bin/
RUN chmod +x /usr/bin/entrypoint.sh
ENTRYPOINT ["entrypoint.sh"]
EXPOSE 3000
# Start the main process.
CMD ["rails", "server", "-b", "0.0.0.0"]
entrypoint.sh
#!/bin/bash
set -e
# Remove a potentially pre-existing server.pid for Rails.
rm -f /redmine/tmp/pids/server.pid
# Then exec the container's main process (what's set as CMD in the Dockerfile).
exec "$@"
docker-compose.yml
Le commentaire est le paramètre pour ruby-debug / ruby-debug-ide. Je l'ai présenté, mais le fonctionnement n'était pas stable dans mon environnement, j'essaie donc de ne pas l'utiliser une seule fois.
docker-compose.yml
version: '3'
services:
db:
image: postgres
volumes:
- ./tmp/db:/var/lib/postgresql/data
ports:
- "5433:5432"
environment:
POSTGRES_PASSWORD: password
web:
build: .
# command: bash -c "rm -f tmp/pids/server.pid && bundle exec rdebug-ide --host 0.0.0.0 --port 1234 -- bin/rails s -p 3000 -b 0.0.0.0"
command: bash -c "rm -f tmp/pids/server.pid && bin/rails s -p 3000 -b 0.0.0.0"
volumes:
- .:/redmine
ports:
- "3003:3000"
# - "1234:1234"
# - "26162:26162"
stdin_open: true
tty: true
depends_on:
- db
Ajoutez ce qui suit à Gemfile. Reportez-vous aux articles tels que.
Gemfile
group :development do
gem "yard" #Ajouter ci-dessous
gem "better_errors"
gem "binding_of_caller"
gem "pry-rails"
gem "pry-byebug"
#Commentez parce que cela n'a pas fonctionné de manière stable
# gem "ruby-debug-ide"
# gem "debase"
end
De plus, pour utiliser better_erros dans l'environnement sur Docker, ajoutez ce qui suit à development.rb.
config/enviroments/development.rb
BetterErrors::Middleware.allow_ip! "0.0.0.0/0"
Créez config / database.yml et faites-le comme suit.
config/database.yml
default: &default
adapter: postgresql
encoding: unicode
host: db
# For details on connection pooling, see Rails configuration guide
# https://guides.rubyonrails.org/configuring.html#database-pooling
pool: <%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
username: postgres
password: password
development:
<<: *default
database: redmine_development
test:
<<: *default
database: redmine_test
production:
<<: *default
database: redmine
Maintenant que les fichiers sont prêts, démarrez le conteneur et exécutez l'application.
#Gemfile vide.Faire une serrure
$ touch Gemfile.lock
#Créer une image de conteneur
$ docker-compose build
#Démarrer le conteneur
$ docker-compose up -d
#Création de DB
$ docker-compose run --rm web rake db:create
#Effectuer la migration
$ docker-compose run --rm web bin/bundle exec rake db:migrate
#Tâche de saisie de données par défaut de Redmine
$ docker-compose run --rm web bin/bundle exec rake redmine:load_default_data
Si le démarrage réussit, le statut sera Up comme indiqué ci-dessous avec docker-compse ps.
$ dcom ps
Name Command State Ports
--------------------------------------------------------------------------------
redmine_db_1 docker-entrypoint.sh postgres Up 0.0.0.0:5433->5432/tcp
redmine_web_1 entrypoint.sh bash -c rm - ... Up 0.0.0.0:3003->3000/tcp
Après cela, si vous accédez à http: // localhost: 3003, l'écran Redmine sera affiché.
De plus, dans un premier temps, vous pouvez vous connecter avec ʻadmin` pour l'identifiant et le mot de passe.
Ceci termine la construction de l'environnement.
Attachez-vous au conteneur pendant que le conteneur est en cours d'exécution avec docker-compose up.
$ docker attach redmine_web_1
Ajoutez binding.pry à la partie appropriée du code que vous souhaitez vérifier. L'exemple suivant est ajouté à wellcome # index qui est exécuté lors de l'accès au chemin racine de Redmine.
app/controllers/welcome_controller.rb
def index
binding.pry #Ajoutez où vous voulez regarder
@news = News.latest User.current
end
Si vous accédez à http: // localhost: 3003 dans cet état, le contenu suivant sera affiché sur le terminal et vous pourrez effectuer des étapes.
From: /redmine/app/controllers/welcome_controller.rb:25 WelcomeController#index:
23: def index
24: binding.pry
=> 25: @news = News.latest User.current
26: end
[1] pry(#<WelcomeController>)> Started GET "/" for 172.18.0.1 at 2020-09-27 07:41:34 +0000
[1] pry(#<WelcomeController>)>
Vous pouvez exécuter des étapes en tapant une commande à [1] pry (# <WelcomeController>)>.
c'est tout