Hogyan állíthatjuk be fájdalommentesen a Ruby on Rails dev környezetét a Dockerrel

Valószínűleg hallott már olyan Docker-kifejezésekről, mint a konténerek, képek, szolgáltatások, kötetek, hálózat, Dockerfile, docker-compose fájl, nem? Vagy néztél néhány videót arról, hogy mi ez, de nem vagy biztos benne, hogyan alkalmazható ez a fejlesztői mindennapi életben?

Erre gondoltam először a Dockerről szóló videók megtekintése után. A Docker nemcsak webalkalmazásokat, szervereket és adatbázisokat futtathat, hanem helyi fejlesztői környezet is lehet! Ezt a cikket nemcsak azért írtam, hogy megtanulhassa, hogyan kell csinálni, hanem nekem is, ezért nem felejtem el. Kezdjük el!

Tartalomjegyzék

  • Miért éppen Docker?
  • A dokkoló és az Ignorefiles telepítése
  • Dockerfile és Docker-Compose
  • A konténer építése és üzemeltetése
  • Új sínek alkalmazás készítése és a szerver indítása
  • Takarítás
  • Következtetés és repo

Miért éppen Docker?

Miért használja a dokkolót? Miért nem telepíti csak a helyi számítógépére, és telepíti a Ruby Version Manager (rvm) vagy a Ruby Environment (rbenv) alkalmazást?

A Ruby On Rails beállítása ezekkel az eszközökkel nagyszerű. Több mint 3 órába került a telepítés, a hibaelhárítás és a dokumentáció keresése, hogy működőképes legyen. De nemrégiben újraformáztam a Mac-et. De nem soroltam fel és nem vettem tudomásul azokat a webhelyeket, amelyeket meglátogattam, hogy működjenek a gépemen. Elfelejtettem, hogyan kell újra telepíteni, és fájdalom megismételni a lépéseket.

Itt ragyog Docker. Telepítse a dokkolót, töltse be a dokkoló fájlokat, futtasson néhány parancsot a terminálon, máris készen áll! És mi van akkor is, ha el akarja távolítani mindazt, amit tett? Nehéz nyomon követni a visszavonható lépéseket. A Docker segítségével ez csak néhány parancs a takarításra.

Amikor a dokkolóval kapcsolatos online oktatóanyagot néztem, Dan Wahlin, a tanár elmondta, hogy a dokkoló egyik előnye, hogy felgyorsítja a fejlesztői fedélzetre kerülést. Dan az oktatóanyagában azt mondta:

"A Docker ebben segíthet, mert egy vagy több képet készíthetünk, amelyeket aztán futó konténerekké alakíthatunk, és ezek a konténerek különböző fejlesztői, sőt tervezői gépeinken is futhatnak."

Tegyük fel, hogy van egy csapat fejlesztője, tervezője és tesztelője, és rendelkezik alkalmazásával háttérszerverrel, adatbázis-kiszolgálóval és gyorsítótárazó szerverrel. 12 tiszta táblagépe van, linuxos és mac számítógépek kombinációjával. Tényleg szeretnél telepíteni, elhárítani és követni a géptől függő különböző telepítési utasításokat? Ezután tegye a darabokat egyenként minden gépre, anélkül, hogy megbizonyosodna róla, hogy nem találkoznak majd különböző hibákkal az út során?

Ezért szántam időt Docker tanulmányozására. Néhány paranccsal és néhány konfigurációs fájl sorával már készen áll. A következő szakaszban bepiszkítjuk a kezünket a dokkoló beállításával.

A Docker telepítése és az Ignorefile-ok beillesztése

1. Telepítse a Dockert

Nem sokat fogok beszélni a dokkoló telepítéséről, sok videó van ott. De általában csak töltse le és nyissa meg a telepítőt, regisztráljon egy fiókot a dockerhub-on, és máris mehet. Nézze meg a Docker telepítési dokumentumait.

2. Készítsen egy .dockerignorefájlt

Mi az a dockerignore fájl? A Dockerignore fájl csak megmondja a Dockernek, mely fájlokat hagyja figyelmen kívül a tárolójában. Példaként említhetjük, ha van egy tömörített eszköz, js, css fájl, amely időről időre megváltozik, amikor megváltoztatja az eredeti kódot. Ez vonatkozik a gitignore fájlokra is. Általában a figyelmen kívül hagyni javasolt fájlok listája általában megtalálható az interneten. Ezt a lényeget egyedül is lemásolhatja .dockerignore.

És ha használja git, hogy ezt a kódrészletet a .gitignore.

A figyelmen kívül hagyott fájlok kissé hosszúak, ezért csak linkeket tettem fel.

Dockerfile és docker-compose fájl

Itt történik a művelet nagy része. Gondoljon erre a két fájlra az utasításkészletként, amelyet a Docker követ a virtuális tároló beállításához. A Dockerfile és a Docker-Compose fájl kéz a kézben működik. Különböző szolgáltatásokhoz több Docker-fájl is rendelkezhet, és egy docker-compose fájl összekapcsolhatja őket.

3. Készítsen egy nevű fájlt Dockerfile

A Dockerfile egy olyan fájl, amely szabályokat tartalmaz, amelyeket a dokkoló követni fog. A Docker hubon előre elkészített szabályok találhatók. Példa erre a MySQL, a PHP vagy a Node.js előre elkészített telepítési utasításai. Miután elkészítette a Dockerfilekódját, tegye ezt a kódot a Dockerfile-ba. Röviden elmagyarázom, mit csinálnak ezek a sorok.

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- ez azt jelenti, hogy a dokkoló rubin segítségével előhúzza az előre elkészített beállítást. Nem kell gondolkodnia azon, hogy frissítse vagy telepítse-e gépére a legújabb rubin verziót. Megjelenik a Docker előre elkészített képeinek listája a Dockerhubon. Gondoljon rá, mint npm.
  • WORKDIR /home/app- Munka könyvtár. A munka könyvtár azt jelenti, hogy ez lesz az alapértelmezett mappa helye, amikor elindítja a fejlesztői környezetet. Nevezheted, amit csak akarsz.
  • ENV PORT 3000- Környezeti változó. Ezzel $PORTa bash terminálon elnevezett változó értéke '3000' lesz.
  • EXPOSE $PORT - Tedd ki a virtuális tároló 3000-es portját (amelyet korábban beállítottunk) a helyi gépednek.
  • RUN- A Futtatási parancsok néhány olyan telepítési utasítás, amelyet a terminál futtatása előtt futtatni kell. Esetünkben a rubint telepítettük a sínekre, a kötegelőre és a node.js-re, mielőtt még a fejlesztői környezetet használnánk, így minden készen áll, amikor használjuk.
  • ENTRYPOINT ["/bin/bash"]- ez a parancs megmondja a dokkolónak, hogy milyen parancsot kell végrehajtania, amikor a tárolót futtatjuk. Esetünkben futnunk kell a bash terminált, hogy hozzáférhessünk a sínekhez.

Vegye figyelembe, hogy ezek a magyarázatok csak rövidek. Láthat további magyarázatokat, vagy elmélyülhet a Dockerfile referenciadokumentumokban.

A Dockerfile segítségével különféle jó dolgokat csinálhat. Esetemben megpróbáltam telepíteni a zsh-t és az oh-my-zsh-t a konténerembe, mert néhány jó automatikus kitöltési funkcióval rendelkezik. De a példánkban nem igazán van rá szükségünk, ez csak növeli a képméretünket, ezért nem vettem fel.

4. Készítsen egy nevű fájlt 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