Cómo configurar sin problemas su entorno de desarrollo de Ruby on Rails con Docker

Es probable que haya oído hablar de términos de Docker como contenedores, imágenes, servicios, volúmenes, red, Dockerfile, docker-compose file, ¿verdad? ¿O ha visto algunos videos sobre lo que es, pero no está seguro de cómo se puede aplicar a su vida diaria como desarrollador?

Eso es lo que pensé por primera vez después de ver videos sobre Docker. Docker no solo puede ejecutar aplicaciones web, servidores y bases de datos, sino que también puede ser un entorno de desarrollo local. Escribí este artículo no solo para que aprendas a hacerlo, sino también para mí, para que no lo olvide. ¡Empecemos!

Tabla de contenido

  • ¿Por qué Docker?
  • Instalación de Docker e Ignorefiles
  • Dockerfile y Docker-Compose
  • Construyendo y ejecutando el contenedor
  • Crear una nueva aplicación de rieles e iniciar el servidor
  • Limpiar
  • Conclusión y repo

¿Por qué Docker?

¿Por qué usar Docker? ¿Por qué no simplemente instalarlo en su máquina local e instalar Ruby Version Manager (rvm) o Ruby Environment (rbenv)?

Configurar Ruby On Rails con estas herramientas es genial. Me tomó más de 3 horas instalar, solucionar problemas y buscar la documentación para que funcionara. Pero recientemente, volví a formatear mi mac. Pero no enumeré ni tomé nota de los sitios web que he visitado para que funcione en mi máquina. Olvidé cómo instalarlo nuevamente y es un fastidio repetir los pasos.

Aquí es donde brilla Docker. Instale Docker, cargue sus archivos de Docker, ejecute algunos comandos en su terminal, ¡ya está configurado! Y también, ¿qué pasa si quieres desinstalar todo lo que hiciste? Es difícil rastrear qué pasos deshacer. Con Docker, son solo unos pocos comandos para limpiar.

Cuando estaba viendo un tutorial en línea sobre Docker, Dan Wahlin, el profesor, dijo que uno de los beneficios de Docker es acelerar la incorporación de desarrolladores. Dan dijo en su tutorial:

"Docker puede ayudar allí porque podemos crear una o más imágenes que luego se pueden convertir en contenedores en ejecución, y esos contenedores se pueden ejecutar en nuestros diferentes desarrolladores e incluso en máquinas de diseño".

Supongamos que tiene un equipo de desarrolladores, diseñadores y probadores, y tiene una aplicación con un servidor back-end, un servidor de base de datos y un servidor de almacenamiento en caché. Tiene 12 máquinas de pizarra limpia, con una combinación de computadoras Linux y Mac. ¿Realmente desea instalar, solucionar problemas y seguir las distintas instrucciones de instalación que dependen de la máquina? Entonces, ¿hacer que las piezas funcionen, una por una en cada máquina, sin la seguridad de que no encontrarán errores variables en el camino?

Por eso me tomé el tiempo para estudiar Docker. Con algunos comandos y algunas líneas de un archivo de configuración, ya está configurado. En la siguiente sección, nos ensuciaremos las manos con la configuración de la ventana acoplable.

Instalación de Docker e inclusión de Ignorefiles

1. Instale Docker

No voy a hablar mucho sobre la instalación de Docker, hay muchos videos por ahí. Pero, por lo general, es solo descargar y abrir el instalador, registrar una cuenta en dockerhub y listo. Consulte los documentos de instalación de Docker.

2.Haz un .dockerignorearchivo

¿Qué es un archivo dockerignore? El archivo Dockerignore simplemente le dice a Docker qué archivos ignorar en su contenedor. Un ejemplo es cuando tiene activos minificados, archivos js, css, que se cambian de vez en cuando cada vez que cambia el código original. Esto también se aplica a los archivos gitignore. Por lo general, la lista de archivos recomendados para ignorar generalmente se encuentra en Internet. Puede copiar esta esencia por su cuenta .dockerignore.

Y si usa git, coloque este fragmento de código en su .gitignore.

Los archivos ignorados son un poco largos, por eso solo pongo enlaces.

Dockerfile y docker-compose file

Aquí es donde ocurre la mayor parte de la operación. Piense en estos dos archivos como un conjunto de instrucciones que Docker sigue sobre cómo configurar su contenedor virtual. Dockerfile y docker-compose file funcionan de la mano. Puede tener varios Dockerfiles para diferentes servicios y un archivo de composición de Docker para unirlos.

3.Haga un archivo llamado Dockerfile

Un Dockerfile es un archivo con un conjunto de reglas que establecerá y que la ventana acoplable seguirá. Hay un conjunto de reglas predefinidas que se encuentran en Docker Hub. Un ejemplo son las instrucciones de instalación predefinidas para MySQL, PHP o Node.js. Después de hacer su Dockerfile, coloque este código en su Dockerfile. Y pasaré por una breve explicación sobre qué hacen estas líneas.

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- esto significa que la ventana acoplable extraerá una configuración prediseñada por ruby. No necesita pensar en actualizar o instalar en su máquina la última versión de ruby. Verá la lista de imágenes prediseñadas de Docker en su Dockerhub. Piense en ello como npm.
  • WORKDIR /home/app- Directorio de trabajo. El directorio de trabajo significa que esta es su ubicación de carpeta predeterminada cuando inicia su entorno de desarrollo. Puedes nombrarlo como quieras.
  • ENV PORT 3000- Variable ambiental. Esto establecerá una variable nombrada $PORTen su terminal bash como '3000'.
  • EXPOSE $PORT - exponer el puerto 3000 (que hemos configurado anteriormente) del contenedor virtual a su máquina local.
  • RUN- Los comandos de ejecución son algunas instrucciones de configuración que desea que ejecute el terminal antes de usarlo. En nuestro caso, instalamos ruby ​​on rails, bundler y node.js incluso antes de usar el entorno de desarrollo para que esté todo listo cuando lo usemos.
  • ENTRYPOINT ["/bin/bash"]: este comando le dice a Docker qué comando ejecutar cuando ejecutamos el contenedor. En nuestro caso, necesitamos ejecutar bash terminal para que podamos tener acceso a los rieles.

Tenga en cuenta que estas explicaciones son solo breves. Puede ver más explicaciones o puede profundizar en los documentos de referencia de Dockerfile.

Puedes hacer cosas interesantes con Dockerfile. En mi caso, intenté instalar zsh y oh-my-zsh en mi contenedor porque tiene algunas características interesantes de autocompletado. Pero en nuestro ejemplo realmente no lo necesitamos, solo aumentará el tamaño de nuestra imagen, así que no lo incluí.

4.Haga un archivo llamado 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