Como configurar sem dor seu ambiente de desenvolvimento Ruby on Rails com Docker

Você provavelmente já ouviu falar sobre termos do Docker como contêineres, imagens, serviços, volumes, rede, Dockerfile, arquivo docker-compose, certo? Ou você assistiu a alguns vídeos sobre o que é, mas não tem certeza de como isso pode se aplicar à sua vida diária como desenvolvedor?

Foi o que pensei pela primeira vez depois de assistir a vídeos sobre o Docker. O Docker pode não apenas executar aplicativos da web, servidores e bancos de dados, mas também pode ser um ambiente de desenvolvimento local! Escrevi este artigo não só para você aprender a fazer, mas também para mim, então não vou me esquecer. Vamos começar!

Índice

  • Por que Docker?
  • Instalando docker e Ignorefiles
  • Dockerfile e Docker-Compose
  • Construindo e operando o contêiner
  • Fazendo um novo aplicativo Rails e iniciando o servidor
  • Limpando
  • Conclusão e repo

Por que Docker?

Por que usar o docker? Por que não apenas instalá-lo em sua máquina local e instalar o Ruby Version Manager (rvm) ou o Ruby Environment (rbenv)?

Configurar Ruby On Rails com essas ferramentas é ótimo. Levei mais de 3 horas para instalar, solucionar problemas e pesquisar a documentação para fazê-lo funcionar. Mas recentemente, eu tenho meu mac reformatado. Mas eu não listei ou tomei nota dos sites que visitei para fazê-lo funcionar na minha máquina. Esqueci como instalá-lo novamente e é uma dor repetir os passos.

É aqui que o Docker brilha. Instale docker, carregue seus dockerfiles, execute alguns comandos em seu terminal, você já está configurado! E também, e se você quiser desinstalar tudo o que fez? É difícil rastrear quais etapas desfazer. Com o Docker, bastam alguns comandos para limpar.

Quando eu estava assistindo a um tutorial online sobre o docker, Dan Wahlin, o professor, disse que um dos benefícios do docker é acelerar a integração do desenvolvedor. Dan disse em seu tutorial:

"Docker pode ajudar nisso porque podemos fazer uma ou mais imagens que podem ser convertidas em contêineres em execução, e esses contêineres podem rodar em nossos diferentes desenvolvedores e até mesmo em máquinas de designer.

Digamos que você tenha uma equipe de desenvolvedores, designers e testadores e tenha um aplicativo com um servidor back-end, servidor de banco de dados e servidor de cache. Você tem 12 máquinas de ardósia limpa, com uma combinação de computadores Linux e Mac. Você realmente deseja instalar, solucionar problemas e seguir as várias instruções de instalação que dependem da máquina? Em seguida, faça as peças funcionarem, uma a uma em cada máquina, sem a garantia de que não encontrarão erros variados ao longo do caminho?

É por isso que reservei tempo para estudar Docker. Com alguns comandos e algumas linhas de um arquivo de configuração, você já está configurado. Na próxima seção, vamos sujar as mãos com a configuração do docker.

Instalando Docker e incluindo Ignorefiles

1. Instale o Docker

Não vou falar muito sobre a instalação do docker, existem muitos vídeos por aí. Mas normalmente é só baixar e abrir o instalador, registrar uma conta no dockerhub e pronto. Confira os documentos de instalação do Docker.

2. Faça um .dockerignorearquivo

O que é um arquivo dockerignore? O arquivo Dockerignore apenas informa ao Docker quais arquivos ignorar em seu contêiner. Um exemplo é quando você tem ativos minimizados, arquivos js, css, que são alterados de tempos em tempos sempre que você altera o código original. Isso também se aplica a arquivos gitignore. Normalmente, a lista de arquivos recomendados para ignorar geralmente é encontrada na Internet. Você pode copiar esta essência por conta própria .dockerignore.

E se você usa git, coloque este trecho de código em seu .gitignore.

Os ignorefiles são um pouco longos, é por isso que acabei de colocar links.

Dockerfile e arquivo docker-compose

É aqui que acontece a maior parte da operação. Pense nesses dois arquivos como um conjunto de instruções que o Docker segue sobre como configurar seu contêiner virtual. Dockerfile e docker-compose file funcionam em conjunto. Você pode ter vários Dockerfiles para serviços diferentes e um arquivo docker-compose para uni-los.

3. Faça um arquivo chamado Dockerfile

Um Dockerfile é um arquivo com um conjunto de regras que você definirá e que o docker seguirá. Existem conjuntos de regras predefinidos encontrados no hub Docker. Um exemplo são as instruções de instalação pré-construídas para MySQL, PHP ou Node.js. Depois de fazer seu Dockerfile, coloque este código em seu Dockerfile. E farei uma breve explicação sobre o que essas linhas fazem.

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- isso significa que o docker puxará uma configuração pré-construída por ruby. Você não precisa se preocupar em atualizar ou instalar em sua máquina a versão mais recente do Ruby. Você verá a lista de imagens pré-construídas do Docker em seu Dockerhub. Pense nisso como npm.
  • WORKDIR /home/app- Diretório de trabalho. Diretório de trabalho significa que este é o local da pasta padrão quando você inicia o ambiente de desenvolvimento. Você pode nomeá-lo como quiser.
  • ENV PORT 3000- Variável de ambiente. Isso definirá uma variável nomeada $PORTem seu terminal bash como '3000'.
  • EXPOSE $PORT - expor a porta 3000 (que definimos anteriormente) do contêiner virtual para sua máquina local.
  • RUN- Os comandos de execução são algumas instruções de configuração que você deseja que o terminal execute antes de usá-lo. Em nosso caso, instalamos ruby ​​on rails, bundler e node.js antes mesmo de usar o ambiente de desenvolvimento, então está tudo pronto quando o usarmos.
  • ENTRYPOINT ["/bin/bash"]- este comando informa ao docker qual comando executar quando executamos o contêiner. Em nosso caso, precisamos executar o terminal bash para que possamos ter acesso aos trilhos.

Observe que essas explicações são apenas breves. Você pode ver mais explicações ou se aprofundar nos documentos de referência do Dockerfile.

Você pode fazer coisas legais com o Dockerfile. No meu caso, tentei instalar zsh e oh-my-zsh no meu contêiner porque ele tem alguns recursos de preenchimento automático interessantes. Mas em nosso exemplo, não precisamos realmente disso, apenas aumentará o tamanho da imagem, então não incluí.

4. Faça um arquivo chamado 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.

Esta é uma grande vitória para nós. Você só precisa manter o Dockerfile e o arquivo de composição e sempre que trocar de máquina, você apenas executa dois comandos! Configure uma vez e esqueça.

Repositório

Você pode ver o repositório sobre como a configuração se parece e comandos adicionais que você precisa aqui, verificando o repositório github completo aqui.

Se você achar o artigo útil, ou se você tiver algumas perguntas adicionais, jogue-o nos comentários. Terei todo o gosto em ajudar!

Este artigo foi escrito por Jonathan Cunanan no freeCodeCamp News.

? Twitter - ? freeCodeCamp -? Portfólio - ⚛️ Github