Docker para Ruby on Rails em um ambiente de desenvolvimento local

Olá, pessoal que desenvolve com Ruby! Se você está procurando uma maneira eficaz de configurar o Docker para Ruby on Rails no seu ambiente de desenvolvimento local, este post é para você. Ele dá continuidade ao nosso artigo anterior sobre como instalar Ruby no macOS para desenvolvimento local.

Quem desenvolve com Ruby frequentemente precisa considerar um banco de dados ao criar um projeto Ruby on Rails, além de outros pré-requisitos do ambiente de desenvolvimento. Mas garantir que tudo isso esteja instalado no sistema operacional da máquina host — e com as versões exatas exigidas — pode ser um desafio.

Sempre que tentava criar um projeto novo, sentia falta de um botão que preparasse um ambiente novo e limpo para ele. Então, decidi criar uma configuração baseada em Docker que pode ser iniciada e interrompida facilmente com o docker-compose.yml do Docker.

O que é o Docker Compose?

O Docker Compose é uma ferramenta de Infraestrutura como Código (IaC) que permite configurar e conectar aplicativos e serviços, como proxies, bancos de dados e montagem de volumes, para provisioná-los de forma reutilizável. Ele é instalado como parte do pacote de software do Docker e definido usando YAML.

Esta configuração do Docker Compose para um ambiente de desenvolvimento local pode ser usada em diferentes tipos de projeto, não apenas em projetos Ruby on Rails. Ela também pode ser usada em projetos paralelos ou projetos de front-end do lado do cliente. Estas são as principais razões pelas quais prefiro usar ambientes Docker em vez de alterar o sistema operacional da minha máquina host:

• fácil de configurar

• fácil de separar a lógica do ambiente

• fácil de usar o mesmo ambiente em diferentes projetos

• fácil de compartilhar o ambiente com quem precisar de ajuda, sem expor código confidencial

• a máquina host permanece limpa

Uma configuração de Docker para Ruby on Rails

Para configurar um ambiente Docker para Ruby on Rails para desenvolvimento local, você precisará de:

• Um sistema operacional semelhante ao Unix (uso o macOS, mas você pode usar Ubuntu ou qualquer outra distribuição Linux. O Windows também deve funcionar)

• Git

• make (3.81 ou posterior)

• Docker (19.03.12 ou posterior)

• docker-compose (1.26.0 ou posterior)

• Seu editor de texto preferido (no meu caso, o Visual Studio Code)

Com tudo isso em mãos, você já pode começar. Se não quiser ler, aqui está o repositório de código aberto com todas as instruções necessárias e o código-fonte completo de todos os trechos que vamos analisar. Mas, como você já está aqui, basta acompanhar este artigo para seguir o passo a passo.

Para começar, vou criar um projeto Ruby on Rails chamado foo_bar_project, para simplificar.

1) Obtenha a configuração do ambiente do Docker Compose e remova o repositório Git. Se quiser manter tudo rastreado em um repositório de código-fonte Git, você poderá criar o seu próprio mais tarde.

1git clone git@github.com:mtereschenko/simple_ror_environment.git && cd simple_ror_environment && rm -rf .git

As próximas etapas devem ser executadas no diretório ./environment. Portanto, vamos garantir que os comandos sejam executados dentro dele:

1cd ./environment

2) Agora, você precisa definir um nome de projeto para esta configuração de ambiente. Por padrão, o nome é test_project. Neste exemplo de código, precisamos alterá-lo para foo_bar_project, como mencionado anteriormente. Para isso, edite o arquivo ./environment/.env.example e atualize a variável PROJECT_NAME. É importante usar valores em Snake Case, com letras minúsculas:

1PROJECT_NAME=foo_bar_project

3) Agora você já pode criar seu projeto executando o seguinte comando:

1make init

Como você pode ver, agora há uma nova pasta chamada application, com o código do Ruby on Rails dentro dela.

4) Agora você precisa criar seu ambiente de desenvolvimento local com o Docker Compose. Esta etapa é obrigatória sempre que houver alterações no Dockerfile ou no Gemfile do seu aplicativo.

1make build

5) Agora você pode iniciar o ambiente de desenvolvimento local do Ruby da seguinte forma:

1make start

Observe que isso ainda não inicia um aplicativo Ruby on Rails. Para isso, precisamos abrir um shell no ambiente Docker e instruí-lo a iniciar o processo rails. Veja como:

1make shell
2rails s -p 3000 –binding=0.0.0.0

Docker para Ruby on Rails em um ambiente de desenvolvimento local. Por fim, se você abrir o navegador e acessar este URL, http://foo_bar_project.localhost/, deverá ver o projeto Ruby on Rails que acabamos de criar.

Então, o que temos disponível agora?

• Temos um projeto com um diretório de ambiente que contém tudo o que precisamos para executá-lo e um diretório de aplicativo com o código da aplicação. Esse diretório é mapeado para o contêiner Docker, dando a você acesso total a partir da imagem Docker do Ruby.

• Temos acesso rápido ao shell do Ruby, sem precisar instalar localmente um ambiente Ruby com Rails, Rake, Bundler ou qualquer outra ferramenta do ecossistema Ruby.

• Os comandos podem ser executados depois do comando make shell.

• Esta configuração do projeto com Docker Compose tem dois estágios predefinidos. Assim, se você precisar implantar seu aplicativo Ruby em algum lugar, poderá criar seu próprio estágio. É simples assim!

Se você quiser entender como funciona o ambiente Docker para Ruby on Rails descrito acima, vamos detalhar a imagem Docker do Ruby, o Makefile e a definição do Docker Compose que faz tudo funcionar em conjunto.

Uma imagem Docker do Ruby

Para começar, a imagem Docker do Ruby é essencial. Criá-la corretamente também é importante para garantir o reaproveitamento eficiente do cache das camadas da imagem Docker e considerar outros aspectos de um ambiente de desenvolvimento local.

Veja a seguir o Dockerfile da imagem Docker do Ruby:

1FROM ruby:2.7.6-alpine3.16 as base_image
2RUN apk add --no-cache git \
3    build-base \
4    libpq-dev \
5    tzdata
6
7FROM base_image as development
8COPY ./artifacts/rails/Gemfile /tmp/Gemfile
9COPY ./artifacts/rails/Gemfile.lock /tmp/Gemfile.lock
10COPY ./containers/ruby/runners/runner.development.sh /rdebug_ide/runner.sh
11RUN cd /tmp && \
12  gem install ruby-debug-ide && \
13  gem install debase && \
14  bundle install && \
15  chmod +x /rdebug_ide/runner.sh && \
16  apk add --no-cache git \
17  nodejs \
18  yarn
19WORKDIR /app
20
21ENTRYPOINT ["tail", "-f", "/dev/null"]
22
23FROM base_image as init
24COPY ./containers/ruby/initializers/runner.init.sh /tmp/runner.sh
25COPY ./containers/ruby/initializers/database.yml /tmp/database.yml
26COPY ./containers/ruby/initializers/.gitignore /tmp/.gitignore
27COPY ./containers/ruby/initializers/development.rb /tmp/development.rb
28RUN chmod +x /tmp/runner.sh
29
30WORKDIR /app
31
32ENTRYPOINT ["/tmp/runner.sh"]

Como você pode ver, ele parte de algumas suposições sobre configurações complementares necessárias para ter um ambiente funcional de aplicativo Ruby on Rails, como:

• arquivo database.yml, com os dados de conexão do Ruby on Rails com o banco de dados

• development.rb, para a configuração do Ruby on Rails em tempo de execução no ambiente de desenvolvimento

Isso é feito usando o script runners.sh no diretório ./environment/containers/ruby/initializers:

1#!/bin/ash
2
3cd /app
4
5gem install rails
6
7rails new . -d=postgresql --skip-git
8
9yes | cp -rf /tmp/database.yml /app/config/database.yml
10yes | cp -rf /tmp/development.rb /app/config/environments/development.rb
11cp /tmp/.gitignore /app/.gitignore

Este Dockerfile também usa builds Docker em múltiplas etapas, permitindo reutilizar partes específicas com eficiência em diferentes ambientes, caso você queira usar a mesma configuração em vários fluxos de trabalho, como testes e homologação.

Docker Compose para Rails

O arquivo Docker Compose em `./environment/docker-compose.development.yml` conecta todos os serviços para que um aplicativo Ruby on Rails funcione no Docker:

• Um servidor HTTP nginx

• Um aplicativo Ruby

• Um servidor de banco de dados PostgreSQL

Veja a seguir o arquivo Docker Compose para Rails usado nesta configuração:

1version: '3.7'
2services:
3  nginx:
4    image: "${PROJECT_NAME}/nginx:development"
5    container_name: ${PROJECT_NAME}-nginx
6    build: 
7      context: ./
8      dockerfile: ./containers/nginx/Dockerfile
9    depends_on:
10      - ruby
11    tty: true
12    ports:
13      - 80:80
14    volumes:
15      - ./`artifacts`/nginx/:/`var`/log/nginx:cached
16   ruby:
17    image: "${PROJECT_NAME}/ruby:development"
18    container_name: ${PROJECT_NAME}-ruby
19    depends_on:
20      - postgres
21    build:
22      context: ./
23      dockerfile: ./containers/ruby/Dockerfile
24      target: development
25    ports:
26      - 13030:13030
27    volumes:
28      - ${APP_PATH}:/app:cached
29    environment:
30      DB_NAME: ${DB_NAME}
31      PROJECT_NAME: ${PROJECT_NAME}
32      DB_USER: ${DB_USER}
33      DB_PASSWORD: ${DB_PASSWORD}
34      DB_PORT: ${DB_PORT}
35      PUMA_WORKERS: 0
36      RAILS_MAX_THREADS: 1
37     postgres:
38    image: "${PROJECT_NAME}/postgres:development"
39    container_name: ${PROJECT_NAME}-postgres
40    environment:
41      POSTGRES_DB: ${DB_NAME}
42      POSTGRES_USER: ${DB_USER}
43      POSTGRES_PASSWORD: ${DB_PASSWORD}
44    build:
45      context: ./
46      dockerfile: ./containers/postgres/Dockerfile
47    ports:
48      - ${DB_PORT}:5432
49    volumes:
50      - postgres_volume:/var/lib/postgresql/data
51
52volumes:
53  postgres_volume:

Makefile para Docker

Por fim, para criar uma interface acessível que facilite a interação de quem desenvolve com este ambiente de desenvolvimento local em Ruby, usamos um Makefile:

1.PHONY: help
2# Make stuff
3
4-include .env
5
6export DOCKER_BUILDKIT=1
7export COMPOSE_DOCKER_CLI_BUILD=1
8
9.DEFAULT_GOAL := help
10
11ARTIFACTS_DIRECTORY := "./artifacts"
12
13CURRENT_PATH :=${abspath .}
14
15SHELL_CONTAINER_NAME := $(if $(c),$(c),ruby)
16BUILD_TARGET := $(if $(t),$(t),development)
17
18help: ## Help.
19@grep -E '^[a-zA-Z-]+:.*?## .*$$' Makefile | awk 'BEGIN {FS = ":.*?## "}; {printf "[32m%-27s[0m %s\n", $$1, $$2}'
20
21init: ## Project installation.
22@rm -f ./.env
23@cp .env.example .env
24@make init_app_directory
25@make create_postgress_volume
26@docker-compose -f docker-compose.init.yml build
27@docker-compose -f docker-compose.init.yml up
28
29build: ## Build images.
30@make create_project_artifacts
31@cp ${APP_PATH}/Gemfile "${ARTIFACTS_DIRECTORY}/rails/Gemfile"
32@cp ${APP_PATH}/Gemfile.lock "${ARTIFACTS_DIRECTORY}/rails/Gemfile.lock"
33@docker-compose -f docker-compose.$(BUILD_TARGET).yml build
34
35shell: ## Internal image bash command line.
36@if [[ -z `docker ps | grep ${SHELL_CONTAINER_NAME}` ]]; then \
37echo "${SHELL_CONTAINER_NAME} is NOT running (make start)."; \
38else \
39docker-compose -f docker-compose.$(BUILD_TARGET).yml exec $(SHELL_CONTAINER_NAME) /bin/ash; \
40fi
41
42start: ## Start previously builded application images.
43@make create_project_artifacts
44@make start_postgres
45@make start_ruby
46@make start_nginx
47
48run: ## Run ruby debugger session.
49@docker-compose -f docker-compose.$(BUILD_TARGET).yml exec ruby /bin/ash /rdebug_ide/runner.sh
50
51start_ruby: ## Start ruby image.
52@if [[ -z `docker ps | grep ruby` ]]; then \
53docker-compose -f docker-compose.$(BUILD_TARGET).yml up -d ruby; \
54else \
55echo "Ruby is running."; \
56fi
57
58start_postgres: ## Start postgres image.
59@if [[ -z `docker ps | grep postgres` ]]; then \
60docker-compose -f docker-compose.$(BUILD_TARGET).yml up -d postgres; \
61else \
62echo "Postgres is running."; \
63fi
64
65start_nginx: ## Start nginx image.
66@if [[ -z `docker ps | grep nginx` ]]; then \
67docker-compose -f docker-compose.$(BUILD_TARGET).yml up -d nginx; \
68else \
69echo "Nginx is running."; \
70fi
71
72stop: ## Stop all images.
73@docker-compose -f docker-compose.$(BUILD_TARGET).yml stop
74
75create_project_artifacts:
76mkdir -p ./artifacts/rails
77mkdir -p ./artifacts/db
78
79init_app_directory:
80@mkdir -p ${APP_PATH}
81
82create_postgress_volume:
83@sed -i '' -r  "s/postgres_volume:/${PROJECT_NAME}_db_volume:/g" docker-compose.development.yml

Executando aplicativos Ruby com eficiência

Esperamos que agora você tenha aprendido a executar aplicativos Ruby, como Ruby on Rails, no seu ambiente local usando uma configuração de contêineres Docker. Outra maneira de executar aplicativos Ruby localmente é usar ambientes virtuais de Ruby, tema que abordamos anteriormente no post sobre como instalar Ruby no macOS.

Agora que seu ambiente de desenvolvimento Ruby está pronto, talvez você também queira aprender a proteger seus aplicativos Ruby. Confira os artigos a seguir para saber mais sobre segurança em Ruby:

• Como analisar gems Ruby com o Snyk

• Guia definitivo do gerenciamento de dependências de gems Ruby