Sådan opretter du smertefrit dit Ruby on Rails-udviklingsmiljø med Docker

Du har sandsynligvis hørt om Docker-udtryk som containere, billeder, tjenester, diskenheder, netværk, Dockerfile, docker-compose-fil, ikke? Eller du har set nogle videoer om, hvad det er, men du er ikke sikker på, hvordan det kan gælde for dit daglige liv som udvikler?

Det tænkte jeg først efter at have set videoer om Docker. Ikke kun kan Docker køre web-apps, servere og databaser, men det kan også være et lokalt udviklingsmiljø! Jeg skrev denne artikel ikke kun, så du kan lære at gøre det, men også for mig, så jeg glemmer det ikke. Lad os komme igang!

Indholdsfortegnelse

  • Hvorfor Docker?
  • Installation af docker og Ignorefiles
  • Dockerfil og Docker-Compose
  • Opbygning og drift af containeren
  • Oprettelse af nye rails-app og start af serveren
  • Gøre rent
  • Konklusion og repo

Hvorfor Docker?

Hvorfor bruge docker? Hvorfor ikke bare installere det på din lokale maskine og installere Ruby Version Manager (rvm) eller Ruby Environment (rbenv)?

Opsætning af Ruby On Rails med disse værktøjer er fantastisk. Det tog mig over 3 timer med installation, fejlfinding og søgning i dokumentationen for at få det til at fungere. Men for nylig fik jeg min mac omformateret. Men jeg listede ikke eller noterede mig de websteder, jeg har besøgt, for at få det til at fungere på min maskine. Jeg har glemt, hvordan man installerer det igen, og det er smertefuldt at gentage trinene.

Det er her, Docker skinner. Installer docker, indlæs dine dockerfiler, kør et par kommandoer i din terminal, du er allerede klar! Og også, hvad hvis du vil afinstallere alt det, du gjorde? Det er svært at spore, hvilke trin der skal fortrydes. Med Docker er det kun et par kommandoer til oprydning.

Da jeg så en online tutorial om docker, sagde Dan Wahlin, læreren, at en af ​​fordelene ved docker er at fremskynde udviklerens on-boarding. Dan sagde i sin tutorial:

"Docker kan hjælpe der, fordi vi kan lave et eller flere billeder, der derefter kan konverteres til kørende containere, og disse containere kan køre på vores forskellige udviklere og endda designermaskiner."

Lad os sige, at du har et team af udviklere, designere og testere og har en app med en back-end-server, databaseserver og caching-server. Du har 12 rene skifermaskiner med en kombination af linux- og mac-computere. Ønsker du virkelig at installere, foretage fejlfinding og følge forskellige installationsinstruktioner, der afhænger af maskinen? Lad så stykkerne arbejde en efter en på hver maskine uden sikkerhed for, at de ikke støder på forskellige fejl undervejs?

Derfor tog jeg mig tid til at studere Docker. Med et par kommandoer og et par linjer i en konfigurationsfil er du allerede opsat. I det næste afsnit får vi vores hænder beskidte med dockeropsætning.

Installation af Docker og inklusive Ignorefiles

1. Installer Docker

Jeg vil ikke tale meget om installation af docker, der er mange videoer derude. Men normalt er det bare at downloade og åbne installationsprogrammet, registrere en konto på dockerhub, så er du klar. Tjek Docker-installationsdokumenter.

2. Opret en .dockerignorefil

Hvad er en dockerignore-fil? Dockerignore-fil fortæller bare Docker, hvilke filer der skal ignoreres i sin container. Et eksempel er, når du har en minificeret aktiver, js, css-filer, der ændres fra tid til anden, når du ændrer den oprindelige kode. Dette gælder også for gitignore-filer. Normalt findes listen over anbefalede filer, der skal ignoreres, på Internettet. Du kan kopiere denne kerne alene .dockerignore.

Og hvis du bruger git, skal du sætte dette kodestykke i din .gitignore.

Ukendte filer er lidt lange, det er derfor, jeg bare lægger links.

Dockerfile og docker-compose-fil

Det er her, det meste af operationen sker. Tænk på disse to filer som et sæt instruktioner, som Docker følger om, hvordan du konfigurerer din virtuelle container. Dockerfile og docker-compose-fil fungerer hånd i hånd. Du kan have flere Dockerfiles til forskellige tjenester og en docker-compose-fil for at binde dem sammen.

3. Lav en fil med navnet Dockerfile

En Dockerfile er en fil med et sæt regler, du vil indstille, som docker skal følge. Der findes forudbyggede sæt regler på Docker-hub. Et eksempel er forudbyggede installationsinstruktioner til MySQL eller PHP eller Node.js. Når du har lavet din Dockerfile, skal du sætte denne kode på din Dockerfile. Og jeg gennemgår en kort forklaring på, hvad disse linjer gør.

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- det betyder, at docker vil trække en forudbygget opsætning af rubin. Du behøver ikke tænke på at opdatere eller installere den nyeste rubinversion på din maskine. Du kan se listen over Dockers forudbyggede billeder på deres Dockerhub. Tænk på det som npm.
  • WORKDIR /home/app- Arbejdsmappe. Arbejdsmappe betyder, at dette er din standardmappeplacering, når du starter dit udviklingsmiljø. Du kan navngive det, hvad du vil.
  • ENV PORT 3000- Miljøvariabel. Dette indstiller en variabel, der er navngivet $PORTpå din bash-terminal, til at være '3000'.
  • EXPOSE $PORT - udsæt port 3000 (som vi har indstillet tidligere) af den virtuelle container for din lokale maskine.
  • RUN- Kør kommandoer er nogle installationsinstruktioner, som du vil have terminalen til at køre, før du bruger den. I vores tilfælde installerede vi rubin på skinner, bundler og node.js, før vi endda bruger udviklingsmiljøet, så det hele er klar, når vi bruger det.
  • ENTRYPOINT ["/bin/bash"]- denne kommando fortæller docker, hvilken kommando der skal udføres, når vi kører containeren. I vores tilfælde er vi nødt til at køre bash terminal, så vi kan få adgang til skinner.

Bemærk, at disse forklaringer kun er korte. Du kan se flere forklaringer, eller du kan gøre dit dybdyk i Dockerfile-referencedokumenter.

Du kan lave slags seje ting med Dockerfile. I mit tilfælde har jeg forsøgt at installere zsh og oh-my-zsh på min container, fordi den har nogle seje funktioner til automatisk udfyldelse. Men i vores eksempel har vi ikke rigtig brug for det, det øger kun vores billedstørrelse, så jeg inkluderede det ikke.

4. Lav en fil med navnet docker-compose.yml

Docker-komponentfil er en fil, der binder forskellige tjenester sammen. Et godt eksempel er, når du kabler din rails-app til forskellige servere som MySQL-databaseserver eller redis-caching-server. Du kan let få dem til at arbejde med denne fil. Men for vores sag holder vi os til minimumsopsætningen af ​​hensyn til klarheden. En YAML-fil er en type markdown-fil med forskellige regler for, hvordan du formaterer din fil. Tænk bare på det som en JSON-fil uden seler. Læg dette i din docker-compose.ymlfil.

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

Som du kan se, ligner det lidt Dockerfilen, men med en lille smule indrykning. Lad os gå gennem linjerne.

  • version- Gennem tiden gennemgik docker-compose-filen ændringer. Derfor skal de i docker-compose-filer angive, hvilken version de bruger. I vores tilfælde bruger vi bare den nyeste version på dette tidspunkt.
  • 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.

Dette er en stor gevinst for os. Du skal bare beholde Dockerfile og komponere filen, og når du skifter maskine, kører du bare to kommandoer! Opsæt en gang, og glem det.

Datalager

Du kan se lageret om, hvordan opsætningen ser ud, og yderligere kommandoer, du har brug for her, ved at tjekke den fulde github-repo her.

Hvis du finder artiklen nyttig, eller hvis du har nogle yderligere spørgsmål, skal du smide den i kommentarerne. Jeg hjælper gerne!

Denne artikel blev skrevet af Jonathan Cunanan på freeCodeCamp News.

? Twitter -? freeCodeCamp -? Portefølje - ⚛️ Github