Comment configurer facilement votre environnement de développement Ruby on Rails avec Docker

Vous avez probablement entendu parler de termes Docker tels que conteneurs, images, services, volumes, réseau, Dockerfile, fichier docker-compose, n'est-ce pas? Ou vous avez regardé des vidéos sur ce que c'est, mais vous ne savez pas comment cela peut s'appliquer à votre vie quotidienne en tant que développeur?

C'est ce que j'ai pensé pour la première fois après avoir regardé des vidéos sur Docker. Docker peut non seulement exécuter des applications Web, des serveurs et des bases de données, mais il peut également être un environnement de développement local! J'ai écrit cet article non seulement pour que vous puissiez apprendre à le faire, mais aussi pour moi, donc je ne l'oublierai pas. Commençons!

Table des matières

  • Pourquoi Docker?
  • Installation de docker et Ignorefiles
  • Dockerfile et Docker-Compose
  • Construction et exécution du conteneur
  • Créer une nouvelle application de rails et démarrer le serveur
  • Nettoyer
  • Conclusion et repo

Pourquoi Docker?

Pourquoi utiliser docker? Pourquoi ne pas simplement l'installer sur votre machine locale et installer Ruby Version Manager (rvm) ou Ruby Environment (rbenv)?

La configuration de Ruby On Rails avec ces outils est excellente. Cela m'a pris plus de 3 heures d'installation, de dépannage et de recherche dans la documentation pour le faire fonctionner. Mais récemment, j'ai reformaté mon Mac. Mais je n'ai pas répertorié ni pris note des sites Web que j'ai visités pour le faire fonctionner sur ma machine. J'ai oublié comment l'installer à nouveau et c'est pénible de répéter les étapes.

C'est là que Docker brille. Installez docker, chargez vos fichiers docker, exécutez quelques commandes dans votre terminal, vous êtes déjà configuré! Et aussi, que faire si vous souhaitez désinstaller tout ce que vous avez fait? Il est difficile de suivre les étapes à annuler. Avec Docker, il ne s'agit que de quelques commandes à nettoyer.

Lorsque je regardais un didacticiel en ligne sur docker, Dan Wahlin, l'enseignant, a déclaré que l'un des avantages de docker était d'accélérer l'intégration des développeurs. Dan a dit dans son tutoriel:

"Docker peut y contribuer car nous pouvons créer une ou plusieurs images qui peuvent ensuite être converties en conteneurs en cours d'exécution, et ces conteneurs peuvent fonctionner sur nos différents développeurs, et même sur des machines de conception."

Supposons que vous ayez une équipe de développeurs, de concepteurs et de testeurs et que vous ayez une application avec un serveur principal, un serveur de base de données et un serveur de mise en cache. Vous disposez de 12 machines propres, avec une combinaison d'ordinateurs Linux et Mac. Voulez-vous vraiment installer, dépanner et suivre différentes instructions d'installation qui dépendent de la machine? Ensuite, faites travailler les pièces, une par une sur chaque machine, sans l'assurance qu'elles ne rencontreront pas d'erreurs variables en cours de route?

C'est pourquoi j'ai pris le temps d'étudier Docker. Avec quelques commandes et quelques lignes d'un fichier de configuration, vous êtes déjà configuré. Dans la section suivante, nous allons nous salir les mains avec la configuration du docker.

Installer Docker et inclure Ignorefiles

1. Installez Docker

Je ne parlerai pas beaucoup de l'installation de docker, il existe de nombreuses vidéos. Mais généralement, il suffit de télécharger et d'ouvrir le programme d'installation, de créer un compte sur dockerhub et vous êtes prêt à partir. Consultez la documentation d'installation de Docker.

2. Créez un .dockerignorefichier

Qu'est-ce qu'un fichier dockerignore? Le fichier Dockerignore indique simplement à Docker les fichiers à ignorer dans son conteneur. Un exemple est lorsque vous avez des actifs minifiés, js, des fichiers css, qui sont modifiés de temps en temps chaque fois que vous modifiez le code d'origine. Cela s'applique également aux fichiers gitignore. Habituellement, la liste des fichiers recommandés à ignorer se trouve généralement sur Internet. Vous pouvez copier cet essentiel vous-même .dockerignore.

Et si vous utilisez git, mettez cet extrait de code dans votre fichier .gitignore.

Les ignorerfiles sont un peu longs c'est pourquoi je mets simplement des liens.

Dockerfile et fichier docker-compose

C'est là que se déroule l'essentiel de l'opération. Considérez ces deux fichiers comme un ensemble d'instructions que Docker suit pour configurer votre conteneur virtuel. Dockerfile et le fichier docker-compose fonctionnent main dans la main. Vous pouvez avoir plusieurs fichiers Docker pour différents services et un fichier docker-compose pour les lier ensemble.

3. Créez un fichier nommé Dockerfile

Un Dockerfile est un fichier avec un ensemble de règles que vous définirez que le docker suivra. Il existe un ensemble de règles prédéfinies sur le hub Docker. Un exemple est les instructions d'installation prédéfinies pour MySQL, ou PHP ou Node.js. Après avoir Dockerfilecréé votre , mettez ce code sur votre Dockerfile. Et je vais passer par une brève explication sur ce que font ces lignes.

FROM ruby WORKDIR /home/app ENV PORT 3000 EXPOSE $PORT RUN gem install rails bundler RUN gem install rails RUN apt-get update -qq && apt-get install -y nodejs ENTRYPOINT [ "/bin/bash" ] 
  • FROM ruby- cela signifie que docker tirera une configuration pré-construite par ruby. Vous n'avez pas besoin de penser à mettre à jour ou à installer sur votre machine la dernière version de ruby. Vous verrez la liste des images prédéfinies de Docker sur leur Dockerhub. Pensez-y comme npm.
  • WORKDIR /home/app- Répertoire de travail. Le répertoire de travail signifie qu'il s'agit de votre emplacement de dossier par défaut lorsque vous démarrez votre environnement de développement. Vous pouvez le nommer comme vous le souhaitez.
  • ENV PORT 3000- Variable d'environnement. Cela définira une variable nommée $PORTsur votre terminal bash à «3000».
  • EXPOSE $PORT - exposez le port 3000 (que nous avons défini précédemment) du conteneur virtuel à votre machine locale.
  • RUN- Les commandes d'exécution sont des instructions de configuration que vous souhaitez que le terminal exécute avant de l'utiliser. Dans notre cas, nous avons installé ruby ​​sur rails, bundler et node.js avant même d'utiliser l'environnement de développement, donc tout est prêt lorsque nous l'utilisons.
  • ENTRYPOINT ["/bin/bash"]- cette commande indique à docker quelle commande exécuter lorsque nous exécutons le conteneur. Dans notre cas, nous devons exécuter le terminal bash pour pouvoir accéder aux rails.

Notez que ces explications ne sont que brèves. Vous pouvez voir plus d'explications ou vous pouvez faire votre plongée approfondie sur les documents de référence Dockerfile.

Vous pouvez faire des trucs sympas avec Dockerfile. Dans mon cas, j'ai essayé d'installer zsh et oh-my-zsh sur mon conteneur car il dispose de fonctionnalités de complétion automatique intéressantes. Mais dans notre exemple, nous n'en avons pas vraiment besoin, cela ne fera qu'augmenter la taille de notre image, donc je ne l'ai pas inclus.

4. Créez un fichier nommé docker-compose.yml

Docker compose file is a file that ties up different services together. A good example is when you're wiring up your rails app to different servers like MySQL database server, or redis caching server. You can easily make them work with this file. But for our case, we'll stick to the minimum setup for clarity purposes. A YAML file is a type of markdown file with different rules on how to format your file. Just think of it as a JSON file, without the braces. Put this in your docker-compose.yml file.

version: "3.7" services: ruby_dev: build: . container_name: ruby_container ports: - "3000:3000" volumes: - ./:/home/app 

As you can see, it kinda looks like the Dockerfile, but with a little bit of indentation. Let's go through the lines.

  • version - Through time, docker-compose file went through changes. That's why in docker-compose files, they need to specify which version they are using. In our case we just use the latest version as of this time.
  • services - Specify list of services. As I said earlier, you can have many services like a rails server, and a MySQL server on your project. You can name your services any name you want. I named it ruby_dev.
  • build: . - The dot here means a file path where to find the Dockerfile, which is the build instructions.
  • container_name - The name of the container.
  • ports: - these are the ports to expose from the docker container to our host local machine. The pattern here is HOST:CONTAINER. In our case it's "3000:3000". Which means we are letting the default Rails server port (3000) be available in our local machine's "localhost:3000".
  • volumes: - volume means even if we quit or delete Docker, we can specify which files we can keep in our local machine. We put ./:/home/app there because we named in our Dockerfile earlier the workdir to be /home/app.

You can see more explanations on Docker Compose reference docs.

Building and running the container

With all our config files setup, let's build and run the container! After the loads of terms we encountered, building and running the container is way simpler. It will only involve few commands.

5. In your terminal, run docker-compose build

Running this command will get Dockerfile and install all the necessary things to make a rails development environment. Note that the installation may take a while because docker will need to download the necessary packages.

6. In your terminal, run docker-compose run --rm --service-ports ruby_dev

This command will start a bash terminal that will be your rails development environment where the rails commands are available. With only these two commands, and two config files, you already have a rails environment without even going through a log of troubleshooting! Notice that our command has some flags, --rm means remove the container after using it, and --service-ports means use port 3000 in our container so we can see our rails server in action. The name ruby_dev also came from services found at our docker-compose.yml.

Test-run a rails app

Now that we've successfully made our rails development environment, we'll test a sample rails app.

1. Run rails new myapp && cd myapp

This command will create a new rails app in a folder named myapp. After that the terminal will go the folder. You can name it whatever you want.

2. Update and install gems. Run bundle update && bundle install

Just make sure you're in the right folder, in myapp, which contains the rails app files. This command will update and install your dependencies.

3. Test the server by running rails server -p $PORT -b 0.0.0.0

Remember the port we specified in our Dockerfile before? This is where we can use it. In our case, rails will use port 3000 to start the server. Don't forget to put -b 0.0.0.0 because you won't see the app on your local machine without this.

4. Stop the server by pressing ctrl-d on your keyboard.

Cleaning Up

After you're done with everything, you can exit on your container by running exit on your container's bash terminal. The --rm flag you typed before will remove the container, but will you get to keep your ruby on rails files.

Run docker-compose down to cleanup

Cleaning up is when you're done with the project, and you want to remove your dev environment so you can save space. If you're really done, you can use this command. Docker will remove all your setup, and the images you downloaded. This so powerful, because, imagine you followed a lot of steps and a lot of installation on your mac. The only way to remove that setup is to uninstall them one by one. With docker on our side, it's just one command. Aww yeah!

Conclusion

Glad you made this far! Let's look at the big picture. Setting up a dev environment in Docker can be broken down in 2 steps:

  1. List the instructions you need on your Dockerfile and docker-compose file.
  2. Start or stop or cleanup your dev environment with the docker-compose command.

This is a big win for us. You just need to keep the Dockerfile and compose file and whenever you switch machines, you just run two commands! Setup once, and forget.

Repository

You can see the repository on how the setup looks like, and additional commands that you need here by checking out the full github repo here.

If you find the article helpful, or if you have some additional questions, throw it in the comments. I'll be glad to help!

This article was written by Jonathan Cunanan on freeCodeCamp News.

? Twitter - ? freeCodeCamp -  ? Portfolio - ⚛️ Github