Um guia simplificado para o "Dockerazition" de Ruby e Rails com o aplicativo React Front-End

Dockerizar seu Ruby on Rails com um aplicativo front-end React pode melhorar drasticamente seu fluxo de trabalho de desenvolvimento e processo de implantação. Ao criar um ambiente padronizado para seu aplicativo, você garante um comportamento consistente em diferentes estágios de desenvolvimento, teste, produção e até mesmo em diferentes sistemas. Na verdade, ele foi projetado para minimizar problemas relacionados às diferenças do sistema. Este guia orientará você nas etapas essenciais para que seu aplicativo Rails e React funcione perfeitamente em contêineres Docker. Por que Dockerizar um aplicativo? : Consistência entre ambientes O Docker garante que o aplicativo seja executado da mesma maneira, independentemente de onde for implantado, seja na máquina de um desenvolvedor, em um ambiente de teste ou em um servidor de produção. Essa consistência é alcançada pela conteinerização de todas as dependências e configurações. : Gerenciamento de Dependências Os contêineres Docker incluem todas as dependências necessárias para a execução do aplicativo. Isso significa que variações nas bibliotecas do sistema ou falta de dependências em sistemas diferentes não afetam a funcionalidade do aplicativo. : Isolamento Os contêineres Docker são executados isoladamente uns dos outros e do sistema host. Este isolamento evita conflitos entre diferentes aplicações e suas dependências no mesmo sistema. : Portabilidade Os contêineres Docker podem ser facilmente movidos e executados em qualquer sistema que suporte Docker, seja uma máquina local, um serviço em nuvem ou um servidor dedicado. Isso torna o aplicativo altamente portátil e flexível em termos de implantação. NB: É necessário conhecimento da sintaxe do Docker Dockerização envolve dois conceitos principais: imagens e contêineres. As imagens servem como modelos para contêineres, contendo todas as informações necessárias para criar um contêiner, incluindo dependências e configurações de implantação. Um contêiner é uma instância de tempo de execução de uma imagem, compreendendo a própria imagem, um ambiente de execução e instruções de tempo de execução. O Docker em geral estabelece um padrão para envio de software. Para explicar o Docker com uma analogia simples: pense nos contêineres como os contêineres de transporte em um pátio, nas imagens como os itens colocados dentro desses contêineres e no navio de transporte como o sistema no qual os contêineres funcionam. Sempre que você configura e cria seu aplicativo, determinadas configurações de ambiente são necessárias. Por exemplo, você não pode executar uma aplicação Rails sem um ambiente Ruby instalado em seu sistema. Da mesma forma, você não pode executar um aplicativo React sem e não pode instalar pacotes React sem um gerenciador de pacotes Node como ou etc. Node.js npm Yarn Como o contêiner roda de forma isolada do sistema do usuário, vamos disponibilizar todos esses pacotes em nosso contêiner, assim como faríamos caso o construíssemos diretamente em nosso sistema, assim, o contêiner atuará como um sistema nele próprio, como uma máquina virtual. Existem diferenças entre o docker e a máquina virtual, mas este exemplo é apenas para explicar melhor. Agora, vamos dockerizar a aplicação Rails. Para fazer isso, precisaremos de três arquivos em nossa aplicação Rails: um , um e um . Vamos examinar cada um desses arquivos detalhadamente. Dockerfile docker-compose.yml bin/docker-entrypoint NB: É necessário conhecimento da sintaxe do Docker Dockerfile O é um modelo para criar um contêiner Docker. Ele contém uma série de instruções que o Docker usa para construir uma imagem, que pode então ser usada para executar contêineres. Vamos detalhar um para um aplicativo Ruby on Rails e React: Dockerfile Dockerfile . Imagem base ARG RUBY_VERSION=3.1.4 FROM ruby:$RUBY_VERSION : Define um argumento de construção denominado com um valor padrão de . Isso pode ser substituído no momento da construção. ARG RUBY_VERSION=3.1.4 RUBY_VERSION 3.1.4 : Usa a imagem base com a versão especificada por . Isso configura o contêiner com o tempo de execução Ruby. Assim como mencionei anteriormente, para executar uma aplicação Rails, você precisa ter o Ruby instalado. FROM ruby:$RUBY_VERSION ruby RUBY_VERSION 2. Instale dependências RUN apt-get update -qq && \ apt-get install -y build-essential libvips bash bash-completion libffi-dev tzdata postgresql curl && \ apt-get clean && \ rm -rf /var/lib/apt/lists/* /usr/share/doc /usr/share/man : Atualiza a lista de pacotes dos repositórios, com para saída silenciosa. apt-get update -qq -qq : Instala vários pacotes: apt-get install -y ... : Pacotes essenciais para construção de software (como GCC). build-essential : Biblioteca para processamento de imagens. libvips , : shell Bash e seu preenchimento automático. bash bash-completion : biblioteca de interface de funções estrangeiras. libffi-dev : dados de fuso horário. tzdata : cliente de banco de dados PostgreSQL. postgresql : Ferramenta para transferir dados de URLs. curl : Limpa o repositório local de arquivos de pacotes recuperados. apt-get clean : Remove listas de pacotes e documentação para reduzir o tamanho da imagem. rm -rf /var/lib/apt/lists/ /usr/share/doc /usr/share/man 3. Instale Node.js e Yarn RUN curl -fsSL https://deb.nodesource.com/setup_current.x | bash - && \ apt-get install -y nodejs && \ curl -sS https://dl.yarnpkg.com/debian/pubkey.gpg | apt-key add - && \ echo "deb https://dl.yarnpkg.com/debian/ stable main" | tee /etc/apt/sources.list.d/yarn.list && \ apt-get update && \ apt-get install -y yarn : baixa e executa o script de configuração do NodeSource para instalar o Node.js. curl -fsSL https://deb.nodesource.com/setup_current.x | bash - : instala o Node.js. apt-get install -y nodejs : Adiciona a chave Yarn GPG para verificar seus pacotes. curl -sS https://dl.yarnpkg.com/debian/pubkey.gpg | apt-key add - : Adiciona o repositório do Yarn à lista de fontes. echo "deb https://dl.yarnpkg.com/debian/ stable main" | tee /etc/apt/sources.list.d/yarn.list : Atualiza a lista de pacotes e instala o Yarn. apt-get update && apt-get install -y yarn 4. Variáveis de ambiente ENV NODE_OPTIONS=--openssl-legacy-provider : Define uma variável de ambiente para ativar o suporte OpenSSL legado para Node.js. ENV NODE_OPTIONS=--openssl-legacy-provider 5. Definir diretório de trabalho WORKDIR /rails : Define o diretório de trabalho para instruções subsequentes para . WORKDIR /rails /rails 6. Construa argumentos e variáveis de ambiente ARG RAILS_ENV ENV RAILS_ENV=$RAILS_ENV : Define um argumento de construção chamado para especificar o ambiente Rails (como , , ). ARG RAILS_ENV RAILS_ENV development test production : Define a variável de ambiente para o valor do argumento de construção. ENV RAILS_ENV=$RAILS_ENV RAILS_ENV 7. Instale gemas de aplicativos COPY Gemfile Gemfile.lock ./ RUN bundle install : Copia o e para o diretório de trabalho. COPY Gemfile Gemfile.lock ./ Gemfile Gemfile.lock : Instala gems Ruby especificadas no . RUN bundle install Gemfile 8. Instale dependências de front-end COPY package.json yarn.lock ./ RUN yarn install --frozen-lockfile : Copia e para o diretório de trabalho. COPY package.json yarn.lock ./ package.json yarn.lock : Instala dependências de front-end usando Yarn, garantindo que ele use as versões exatas em . RUN yarn install --frozen-lockfile yarn.lock 9. Copie o código do aplicativo COPY . . : Copia todo o código do aplicativo para o diretório de trabalho. COPY . . 10. Pré-compilar código Bootsnap RUN bundle exec bootsnap precompile --gemfile app/ lib/ : pré-compila o cache do Bootsnap para tempos de inicialização mais rápidos do aplicativo Rails. Bootsnap é uma joia que acelera o tempo de inicialização do Ruby e do Rails armazenando em cache cálculos caros. RUN bundle exec bootsnap precompile --gemfile app/ lib/ 11. Pré-compilar ativos para produção RUN if [ "$RAILS_ENV" = "production" ]; then \ SECRET_KEY_BASE=1 bin/rails assets:precompile; \ fi : executa condicionalmente a pré-compilação do ativo somente se estiver definido como . Esta etapa é crucial para preparar ativos para um ambiente de produção. RUN if [ "$RAILS_ENV" = "production" ]; then ... RAILS_ENV production 12. Script de ponto de entrada COPY bin/docker-entrypoint /rails/bin/ RUN chmod +x /rails/bin/docker-entrypoint : copia um script de ponto de entrada personalizado para o contêiner. COPY bin/docker-entrypoint /rails/bin/ : Torna o script do ponto de entrada executável. RUN chmod +x /rails/bin/docker-entrypoint 13. Defina ponto de entrada e comando ENTRYPOINT ["/rails/bin/docker-entrypoint"] EXPOSE 5000 // you can use any port of your choice CMD ["./bin/rails", "server"] : Define o script do ponto de entrada que será executado quando o contêiner for iniciado. Esse script normalmente configura o ambiente, prepara o banco de dados e inicia o aplicativo. ENTRYPOINT ["/rails/bin/docker-entrypoint"] : Indica que o contêiner escuta na porta 5000. Este é um recurso de documentação e não publica a porta. EXPOSE 5000 : Especifica o comando padrão a ser executado quando o contêiner for iniciado, que é iniciar o servidor Rails. CMD ["./bin/rails", "server"] docker-compose.yml O arquivo é usado para definir e executar aplicativos Docker com vários contêineres. Ele permite que você configure os serviços, redes e volumes do seu aplicativo em um único arquivo. Neste caso, usaremos dois serviços. Aqui está o arquivo para o aplicativo Rails: docker-compose.yml docker-compose.yml 1. ) Serviço de banco de dados ( db codedb: image: postgres:14.2-alpine container_name: demo-postgres-14.2 volumes: - postgres_data:/var/lib/postgresql/data command: "postgres -c 'max_connections=500'" environment: POSTGRES_DB: ${POSTGRES_DB} POSTGRES_USER: ${POSTGRES_USER} POSTGRES_PASSWORD: ${POSTGRES_PASSWORD} ports: - "5432:5432" : especifica a imagem do Docker a ser usada para este serviço. Neste caso, é a imagem PostgreSQL 14.2 baseada na distribuição Alpine Linux. As imagens alpinas são conhecidas por seu tamanho pequeno, o que pode ajudar a manter o tamanho geral da imagem baixo. image: postgres:14.2-alpine : Nomeia o contêiner . Este nome é usado para fazer referência ao contêiner em comandos e logs. container_name: demo-postgres-14.2 demo-postgres-14.2 volumes : Monta um volume nomeado em dentro do contêiner. Este diretório é onde o PostgreSQL armazena seus dados, garantindo que os dados do banco de dados persistam entre as reinicializações do contêiner. postgres_data:/var/lib/postgresql/data: postgres_data /var/lib/postgresql/data : Substitui o comando padrão da imagem PostgreSQL. Inicia o PostgreSQL com uma opção de configuração para aumentar o número máximo de conexões para 500. command: "postgres -c 'max_connections=500'" environment : : Define o nome do banco de dados padrão a ser criado, usando uma variável de ambiente . POSTGRES_DB: ${POSTGRES_DB} POSTGRES_DB : Define o nome de usuário padrão para acessar o banco de dados PostgreSQL, usando a variável de ambiente . POSTGRES_USER: ${POSTGRES_USER} POSTGRES_USER : Define a senha para o usuário padrão, usando a variável de ambiente . POSTGRES_PASSWORD: ${POSTGRES_PASSWORD} POSTGRES_PASSWORD ports : : mapeia a porta 5432 no host para a porta 5432 no contêiner. Isto permite o acesso ao PostgreSQL na máquina host através da porta 5432. "5432:5432" 2. ) Serviço de aplicação web ( demo-web codedemo-web: build: context: . args: - RAILS_ENV=${RAILS_ENV} command: "./bin/rails server -b 0.0.0.0" environment: - RAILS_ENV=${RAILS_ENV} - POSTGRES_HOST=${POSTGRES_HOST} - POSTGRES_DB=${POSTGRES_DB} - POSTGRES_USER=${POSTGRES_USER} - POSTGRES_PASSWORD=${POSTGRES_PASSWORD} - RAILS_MASTER_KEY=${RAILS_MASTER_KEY} volumes: - .:/rails - app-storage:/rails/storage depends_on: - db ports: - "3000:3000" build: : especifica o contexto de construção da imagem Docker. Nesse caso, refere-se ao diretório atual. Isso significa que o Docker usará o Dockerfile no diretório atual para construir a imagem. context: . . args : : passa o argumento de construção para o processo de construção do Docker, permitindo que você especifique o ambiente Rails (como , ou ). RAILS_ENV=${RAILS_ENV} RAILS_ENV development test production : substitui o comando padrão da imagem Docker. Inicia o servidor Rails e vincula-o a todas as interfaces de rede ( ), o que é necessário para que o serviço seja acessível de fora do contêiner. command: "./bin/rails server -b 0.0.0.0" 0.0.0.0 environment: : Define o ambiente Rails dentro do contêiner usando a variável de ambiente . RAILS_ENV=${RAILS_ENV} RAILS_ENV : Define o endereço do host PostgreSQL. POSTGRES_HOST=${POSTGRES_HOST} : Define o nome do banco de dados. POSTGRES_DB=${POSTGRES_DB} : Define o usuário do PostgreSQL. POSTGRES_USER=${POSTGRES_USER} : Define a senha do usuário PostgreSQL. POSTGRES_PASSWORD=${POSTGRES_PASSWORD} : Define a chave mestra Rails, que é usada para criptografar credenciais e outros segredos. RAILS_MASTER_KEY=${RAILS_MASTER_KEY} volumes : : monta o diretório atual (onde o arquivo está localizado) em dentro do contêiner. Isso permite que você edite arquivos em seu host e tenha essas alterações refletidas dentro do contêiner. .:/rails docker-compose.yml /rails : monta um volume nomeado em dentro do contêiner. Isso normalmente é usado para armazenar arquivos específicos do Rails, como logs, uploads e arquivos em cache. app-storage:/rails/storage app-storage /rails/storage depends_on : : garante que o serviço aguarde até que o serviço esteja pronto antes de iniciar. Docker Compose lida com a ordem de início dos serviços com base nesta configuração. db demo-web db ports: : mapeia a porta 3000 no host para a porta 3000 no contêiner. Isso permite que você acesse o aplicativo Rails na máquina host através da porta 3000. "3000:3000" Volumes codevolumes: postgres_data: app-storage: : define um volume nomeado usado pelo serviço para persistir dados do PostgreSQL. postgres_data postgres_data db : define um volume nomeado usado pelo serviço para persistir dados específicos do aplicativo, como uploads e logs. app-storage app-storage demo-web bin/docker-ponto de entrada O script é uma parte crucial da configuração do Docker. Ele é executado quando o contêiner é iniciado e normalmente lida com a configuração do ambiente, a preparação do banco de dados e outras tarefas de inicialização necessárias antes de iniciar o aplicativo principal. Aqui está um exemplo de script e uma explicação detalhada de cada parte: bin/docker-entrypoint bin/docker-entrypoint Shebang e saída em caso de erro bashCopy code#!/bin/bash set -e : Esta linha especifica que o script deve ser executado usando o shell Bash. #!/bin/bash : instrui o script a sair imediatamente se algum comando retornar um código de saída diferente de zero. Isso ajuda a garantir que, se alguma etapa falhar, o script interromperá a execução, o que pode impedir que etapas subsequentes sejam executadas em um estado inválido. set -e Criação ou migração condicional de banco de dados # If running the rails server then create or migrate existing database if [ "${*}" == "./bin/rails server" ]; then ./bin/rails db:create ./bin/rails db:prepare fi : Esta instrução condicional verifica se o comando passado para o script ( ) é . O é um parâmetro especial que contém todos os parâmetros posicionais passados ao script. if [ "${*}" == "./bin/rails servidor"]; then ... fi "${*}" ./bin/rails server * ./bin/rails banco de dados : Se a condição for atendida, este comando tentará criar o banco de dados. É equivalente a executar que configura o banco de dados conforme definido no arquivo de configuração do banco de dados ( ). rails db:create config/database.yml ./bin/rails banco de dados : Este comando executará , o que garante que o banco de dados seja configurado e migrado. Ele criará o banco de dados se ele não existir e executará migrações se o banco de dados já estiver criado. Esta é uma combinação de e . rails db:prepare rails db:create rails db:migrate Executando o Processo Principal bashCopy codeexec "${@}" : substitui o processo shell atual pelo comando passado como argumentos para o script. O símbolo contém todos os parâmetros posicionais passados para o script. Por exemplo, se o script for chamado com , esta linha efetivamente executa como o processo principal do contêiner. exec "${@}" @ ./bin/rails server ./bin/rails server Conclusão Um bem elaborado é essencial para criar um ambiente confiável e consistente para sua aplicação Ruby on Rails e React. Ao definir a imagem base, definir variáveis de ambiente e instalar dependências, você garante que seu aplicativo seja executado sem problemas em vários ambientes. Dockerfile O Docker não apenas agiliza seu processo de desenvolvimento, mas também aumenta a confiabilidade de seu aplicativo em produção. Existem áreas de otimizações, mas esta é apenas uma visão geral de como dockerizar a aplicação Rails. Script completo para o resultante, e Dockerfile docker-compose.yml bin/docker-entrypoint ARG RUBY_VERSION=3.1.4 FROM ruby:$RUBY_VERSION # Install dependencies RUN apt-get update -qq && \ apt-get install -y build-essential libvips bash bash-completion libffi-dev tzdata postgresql curl && \ apt-get clean && \ rm -rf /var/lib/apt/lists/* /usr/share/doc /usr/share/man # Install Node.js and Yarn RUN curl -fsSL https://deb.nodesource.com/setup_current.x | bash - && \ apt-get install -y nodejs && \ curl -sS https://dl.yarnpkg.com/debian/pubkey.gpg | apt-key add - && \ echo "deb https://dl.yarnpkg.com/debian/ stable main" | tee /etc/apt/sources.list.d/yarn.list && \ apt-get update && \ apt-get install -y yarn # Set environment variable to enable legacy OpenSSL support ENV NODE_OPTIONS=--openssl-legacy-provider # Rails app lives here WORKDIR /rails # Set environment variable for the build ARG RAILS_ENV ENV RAILS_ENV=$RAILS_ENV # Install application gems COPY Gemfile Gemfile.lock ./ RUN bundle install # Install frontend dependencies COPY package.json yarn.lock ./ RUN yarn install --frozen-lockfile # Copy application code COPY . . # Precompile bootsnap code for faster boot times RUN bundle exec bootsnap precompile --gemfile app/ lib/ # Precompiling assets for production without requiring secret RAILS_MASTER_KEY RUN if [ "$RAILS_ENV" = "production" ]; then \ SECRET_KEY_BASE=1 bin/rails assets:precompile; \ fi # Entrypoint prepares the database. COPY bin/docker-entrypoint /rails/bin/ RUN chmod +x /rails/bin/docker-entrypoint # Use an absolute path for the entry point script ENTRYPOINT ["/rails/bin/docker-entrypoint"] # Start the server by default, this can be overwritten at runtime EXPOSE 5000 CMD ["./bin/rails", "server"] services: db: image: postgres:14.2-alpine container_name: demo-postgres-14.2 volumes: - postgres_data:/var/lib/postgresql/data command: "postgres -c 'max_connections=500'" environment: POSTGRES_DB: ${POSTGRES_DB} POSTGRES_USER: ${POSTGRES_USER} POSTGRES_PASSWORD: ${POSTGRES_PASSWORD} ports: - "5432:5432" demo-web: build: context: . args: - RAILS_ENV=${RAILS_ENV} command: "./bin/rails server -b 0.0.0.0" environment: - RAILS_ENV=${RAILS_ENV} - POSTGRES_HOST=${POSTGRES_HOST} - POSTGRES_DB=${POSTGRES_DB} - POSTGRES_USER=${POSTGRES_USER} - POSTGRES_PASSWORD=${POSTGRES_PASSWORD} - RAILS_MASTER_KEY=${RAILS_MASTER_KEY} volumes: - .:/rails - app-storage:/rails/storage depends_on: - db ports: - "3000:3000" volumes: postgres_data: app-storage: #!/bin/bash set -e # If running the rails server then create or migrate existing database if [ "${*}" == "./bin/rails server" ]; then ./bin/rails db:create ./bin/rails db:prepare fi exec "${@}"