Instalar Redmine no Rocky Linux com PostgreSQL

Important: leia as seções de segurança, solução de problemas e critérios de aceitação antes de colocar a instância em produção.

O que é o Redmine

Redmine é um sistema livre e open source para gerenciamento de projetos e rastreamento de issues, escrito principalmente em Ruby on Rails. É multiplataforma, suporta vários bancos de dados e oferece recursos como wiki por projeto, fóruns, controle de versões e gestão de permissões.

Fact box: redmine 4.2.3, ruby 2.7, bancos suportados: PostgreSQL, MySQL, SQLite; idiomas: cerca de 49.

Principais funcionalidades do Redmine

• Suporte a múltiplos projetos
• Wiki e fóruns por projeto
• Gerenciamento de documentos e arquivos
• Notícias, feeds e notificações por e-mail
• Controle de tempo (time tracking)
• Integração com vários SCM (SVN, Git, CVS, Mercurial, Bazaar)
• Suporte a LDAP

Pré-requisitos do ambiente de exemplo

• Sistema operacional: Rocky Linux 8.4 (Green Obsidian)
• IP: 192.168.1.10
• Privilégios de root
• Domínio: redmine.example.com

Objetivos deste guia:

• Instalar Ruby via RVM
• Configurar banco PostgreSQL para Redmine
• Instalar e integrar Passenger
• Configurar virtual host Apache (com/sem SSL)
• Instalar e configurar Redmine

Antes de começar: recomenda-se ter o PostgreSQL já instalado e funcionando. Consulte: Como instalar PostgreSQL no Rocky Linux.

Imagens de referência

Instalar dependências

Execute os comandos com sudo ou como root. Todos os pacotes listados são necessários para compilar, instalar gemas nativas e integrar Passenger.

1. Adicione o repositório EPEL:

sudo dnf install epel-release -y

2. Instale pacotes de compilação e bibliotecas necessárias:

sudo dnf install curl gpg gnupg2 gcc gcc-c++ make patch autoconf automake bison ImageMagick libffi-devel libtool patch redhat-rpm-config readline-devel postgresql-devel zlib-devel openssl-devel -y

3. Instale pacotes necessários para integrar Passenger/Apache:

sudo dnf install libcurl-devel httpd-devel httpd apr-devel apr-util-devel -y

Após instalar httpd, habilite e inicie o serviço:

sudo systemctl enable --now httpd

Verifique o status do serviço:

sudo systemctl status httpd

Se tudo estiver ok, prossiga para instalar RVM e Ruby.

Instalar RVM e Ruby

A versão do Redmine usada aqui requer Ruby 2.7. Usaremos RVM (Ruby Version Manager) para instalar e gerenciar a versão do Ruby.

1. Importe as chaves GPG dos desenvolvedores do RVM:

curl -sSL https://rvm.io/mpapis.asc | gpg2 --import -  
curl -sSL https://rvm.io/pkuczynski.asc | gpg2 --import -

2. Instale o RVM e carregue o ambiente:

curl -L get.rvm.io | bash -s stable  
source /etc/profile.d/rvm.sh

Recarregue e instale requisitos do sistema:

rvm reload  
rvm requirements run

3. Instale Ruby 2.7:

rvm install 2.7

Aguarde a conclusão. Em seguida, verifique as versões instaladas:

rvm list  
ruby --version

Você deverá ver algo semelhante a ruby 2.7.2 sendo usada.

Configurar o banco de dados PostgreSQL para Redmine

Antes: confirme que o PostgreSQL já foi instalado e está ativo.

1. Entre no shell do PostgreSQL:

sudo -u postgres psql

2. Crie usuário e base para o Redmine (substitua a senha pela sua):

CREATE ROLE redmine LOGIN ENCRYPTED PASSWORD 'StrongPasswordRedmine' NOINHERIT VALID UNTIL 'infinity';  
CREATE DATABASE redminedb WITH ENCODING='UTF8' OWNER=redmine;

Saia do psql com:

\q

Notas importantes:

• Use uma senha forte e guarde-a em um cofre de senhas.
• Se o PostgreSQL estiver em outro host, ajuste host e firewall (port 5432).

Instalar e configurar o Redmine

Este guia instala Redmine 4.2.3 em /var/www/redmine.

1. Baixe a release e extraia:

cd /var/www/  
wget https://www.redmine.org/releases/redmine-4.2.3.tar.gz

Extraia e renomeie:

tar -xzvf redmine-4.2.3.tar.gz  
mv redmine-*/ redmine

2. Crie o arquivo de configuração do banco: no diretório do Redmine crie config/database.yml

export REDMINE=/var/www/redmine  
cd $REDMINE

nano config/database.yml

Cole e ajuste conforme suas credenciais:

production:  
  adapter: postgresql  
  database: redminedb  
  host: localhost  
  username: redmine  
  password: "StrongPasswordRedmine"  
  encoding: utf8

3. Instale dependências Ruby com bundler:

gem install bundler

bundle config set --local path 'vendor/bundle'  
bundle config set --local without 'development test'

bundle install

4. Gere token secreto e migre o banco:

bundle exec rake generate_secret_token  
RAILS_ENV=production bundle exec rake db:migrate

5. Ajuste permissões (usuario apache):

sudo chown -R apache:apache $REDMINE

Observação: dependendo da política da sua distribuição, o usuário do serviço Apache pode ser httpd, www-data ou apache. Ajuste conforme necessário.

Instalar e configurar Phusion Passenger

Passenger é um módulo de aplicação web para Ruby/Phusion frequentemente usado em produção com Apache ou Nginx.

1. Instale o gem passenger globalmente:

gem install passenger

2. Instale o módulo Apache do Passenger:

passenger-install-apache2-module

Siga as instruções do instalador (pressione Enter quando solicitado). Escolha “Ruby” como tipo de aplicação quando perguntado.

O instalador mostrará blocos de configuração a serem adicionados ao Apache.

Crie o arquivo /etc/httpd/conf.d/passenger.conf e cole o trecho recomendado. Exemplo do instalador:

   LoadModule passenger_module /usr/local/rvm/gems/ruby-2.7.2/gems/passenger-6.0.12/buildout/apache2/mod_passenger.so  
     
     PassengerRoot /usr/local/rvm/gems/ruby-2.7.2/gems/passenger-6.0.12  
     PassengerDefaultRuby /usr/local/rvm/gems/ruby-2.7.2/wrappers/ruby  
   

Salve e reinicie o httpd:

sudo systemctl restart httpd

Se o instalador não reportar erros, o Passenger está pronto.

Configurar virtual host Apache para Redmine

1. Crie /etc/httpd/conf.d/redmine.conf com a configuração HTTP (ajuste ServerName):

PassengerRuby /usr/local/rvm/gems/ruby-2.7.2/wrappers/ruby  
  
  
    ServerName redmine.example.io  
    DocumentRoot "/var/www/redmine/public"   
  
    ErrorLog logs/redmine_error_log  
    LogLevel warn  
  
      
        Options Indexes ExecCGI FollowSymLinks  
        Require all granted  
        AllowOverride all  
      
 

2. Exemplo para habilitar HTTPS (ajuste caminhos de certificados):

PassengerRuby /usr/local/rvm/gems/ruby-2.7.2/wrappers/ruby  
  
  
  ServerName redmine.example.io  
  Redirect permanent / https://redmine.example.io/  
  
  
  
  
  ServerName redmine.example.io  
  
  Protocols h2 http/1.1  
  
    
    Redirect permanent / https://redmine.example.io/  
    
  
  DocumentRoot "/var/www/redmine/public"   
   
  ErrorLog /var/log/httpd/redmine.example.io-error.log  
  CustomLog /var/log/httpd/redmine.example.io-access.log combined  
  
  SSLEngine On  
  SSLCertificateFile /etc/letsencrypt/live/redmine.example.io/fullchain.pem  
  SSLCertificateKeyFile /etc/letsencrypt/live/redmine.example.io/privkey.pem  
  
    
    Options Indexes ExecCGI FollowSymLinks  
    Require all granted  
    AllowOverride all  
    
  

Habilite mod_ssl se necessário (instale/ative openssl/letsencrypt conforme política da sua infra).

Verifique a configuração e reinicie:

apachectl configtest  
sudo systemctl restart httpd

Verificar instalação do Redmine

Abra no navegador:

https://redmine.example.io/login

1. Login inicial: usuário admin / senha admin. Após entrar, o Redmine solicitará alteração da senha admin.

2. Altere a senha padrão admin para uma senha forte.

3. Verifique os detalhes da conta e o painel de administração.

4. Carregue a configuração padrão de idioma e verifique usuários.

5. Confira a lista de usuários e as informações de instalação:

Se tudo corresponder ao esperado, a instalação básica foi concluída.

Critérios de aceitação (Kriterien de aceitação)

• A página /login abre via HTTPS sem erros de certificado.
• Login com admin/admin funciona e é possível alterar a senha.
• Criação de projeto e issue funciona (criar > salvar sem erro).
• Migração do banco (db:migrate) foi concluída sem erros.
• Logs do Apache e Redmine não apresentam erros críticos nas primeiras 10 minutos após o deploy.

Testes e casos de aceitação

• Teste 1: Acessar /login e obter 200 OK (SSL válido).
• Teste 2: Criar projeto, adicionar membro e criar uma issue; verificar que a issue aparece na listagem.
• Teste 3: Enviar notificação por e-mail ao criar uma issue (requer SMTP configurado).
• Teste 4: Reiniciar httpd e confirmar que o serviço volta sem erros.

Checklist de funções por papel

Administrador sistema:

• Atualizar sistema e pacotes
• Configurar firewall (abrir 80/443)
• Configurar backups regulares do DB e do diretório files
• Configurar monitoramento e alertas

Administrador Redmine:

• Criar projetos e definir roles/permissões
• Instalar plugins testados em ambiente de staging
• Gerenciar usuários e autenticação (LDAP/SSO)

Desenvolvedor / DevOps:

• Testar atualizações em staging
• Automatizar deploys e migrações
• Validar compatibilidade das gemas com a versão do Ruby

Gerente de projeto:

• Criar trackers, workflows e campos personalizados
• Validar notificações e templates de email

Segurança e boas práticas

• Sempre habilite HTTPS (Let’s Encrypt ou certificados comerciais).
• Não use a conta admin padrão em produção; crie contas com MFA se possível.
• Limite acesso ao banco de dados via firewall e, preferencialmente, mantenha o banco em rede privada.
• Faça backup diário do banco e dos diretórios: config, files, plugins e public/system.
• Considere rodar SELinux em modo enforcing; documente e ajuste políticas para Passenger/Apache.
• Use usuários e permissões mínimas (principle of least privilege).
• Atualize o Ruby/Gems/Passenger com testes em staging antes de aplicar em produção.

GDPR e privacidade

• Revise quais dados pessoais são armazenados (usuários, e-mails, históricos de tickets).
• Documente retenção de dados e procedimentos para exclusão de dados pessoais sob solicitação.
• Use conexões seguras (TLS) para proteger dados em trânsito.
• Controle acesso administrativo e registre auditorias quando possível.

Troubleshooting comum

Problema: Passenger falha ao carregar mod_passenger.so

• Verifique se o caminho em passenger.conf corresponde ao instalado pelo RVM.
• Execute passenger-config validate-install para verificar problemas.

Problema: Erros de permissão 500

• Confira ownership: sudo chown -R apache:apache /var/www/redmine
• Verifique SELinux: sudo ausearch -m avc -ts recent ou temporariamente setenforce 0 para testar (não deixar assim em produção).

Problema: Erros de gemas durante bundle install

• Verifique versões do Ruby e gemset; rvm use 2.7
• Instale dependências nativas (postgresql-devel, imagemagick, libxml2-devel etc.)

Comandos úteis para depuração:

systemctl status httpd
journalctl -u httpd -e
tail -n 200 /var/www/redmine/log/production.log
passenger-status
passenger-config validate-install

Alternativas e quando escolher outra abordagem

• Docker: se prefere containerização, há imagens oficiais e não oficiais do Redmine. Ideal para ambientes isolados e deploys reproducíveis.
• Nginx + Passenger: alternativa ao Apache com melhor desempenho em alguns cenários.
• Puma/Unicorn: servidores de aplicação Ruby que podem ser usados em vez do Passenger; requer configuração de reverse proxy (Nginx/Apache).
• Sistema Ruby do OS ou rbenv: em vez de RVM, use rbenv ou Ruby distribuído pelo sistema se preferir não instalar gestores de versões em /usr/local/rvm.

Contraexemplo (quando NÃO usar esta configuração):

• Pequenos ambientes de teste com baixo tráfego e simplicidade desejada: usar SQLite para testes locais é mais rápido.
• Ambientes com políticas corporativas que proíbem instalação via RVM: prefira pacotes gerenciados pela distribuição ou rbenv.

Migração e atualização

• Para atualizar Redmine: faça backup do banco e dos diretórios (files, plugins), atualize o código, execute bundle install e RAILS_ENV=production bundle exec rake db:migrate.
• Teste atualizações em um ambiente de staging idêntico ao de produção antes de aplicar.

Mini metodologia de atualização (playbook):

1. Fazer backup completo (DB + arquivos) e verificar integridade.
2. Reproduzir update em staging, executar migrações e testes automatizados.
3. Agendar janela de manutenção.
4. Aplicar update em produção e executar migrações.
5. Validar funcionalidades críticas e monitorar logs por 30–60 minutos.
6. Se falha grave: executar rollback (restaurar DB e arquivos a partir do backup) e reverter código.

Rollback / runbook rápido:

• Parar httpd: sudo systemctl stop httpd
• Restaurar banco: psql -U postgres -d redminedb -f backup.sql (ajuste conforme arquivo)
• Restaurar diretório public/files e plugins
• Reiniciar httpd

Cheat sheet / comandos rápidos

• Reiniciar Apache: sudo systemctl restart httpd
• Ver logs Apache: tail -f /var/log/httpd/error_log
• Ver logs Redmine: tail -f /var/www/redmine/log/production.log
• Executar migração: RAILS_ENV=production bundle exec rake db:migrate
• Gerar token: bundle exec rake generate_secret_token

Comparação curta: Apache+Passenger vs Nginx+Passenger vs Docker

• Apache+Passenger: integração direta, boa para administradores confortáveis com httpd.
• Nginx+Passenger: melhor desempenho em alguns workloads estáticos e proxy; recomendado em infra orientada a Nginx.
• Docker: maior isolamento e portabilidade; requer pipelines CI/CD e orquestração para produção.

Glossário (1 linha)

• Passenger: módulo servidor de aplicação para Ruby/Rails que integra com Apache/Nginx.
• RVM: gerenciador de versões do Ruby (Ruby Version Manager).
• Bundle: gerenciador de dependências Ruby (Bundler).
• db:migrate: comando Rails para aplicar migrações de banco de dados.

Galeria de edge-cases

• Erros relacionados a encoding do banco: confirme ENCODING=’UTF8’ no database.yml.
• Incompatibilidade de versões de gemas: use a versão de Ruby exigida pelo Redmine e faça bundle update com cautela.
• SELinux bloqueando escrita em public/system: ajuste contexts com semanage fcontext e restorecon.

Boas práticas de operação

• Automatize backups e testes de restauração (restore drills) mensalmente.
• Monitore logs e métricas: tempo de resposta, uso de memória, filas de e-mail.
• Aplique atualizações de segurança no SO e no Ruby/Gems regularmente.

Conclusão

Parabéns — você instalou o Redmine 4.2.3 com Ruby 2.7 e PostgreSQL, integrado ao Apache via Passenger no Rocky Linux. Próximos passos recomendados: configurar SMTP (para notificações), instalar plugins necessários em ambiente de teste, e criar um pipeline de backup e atualizações controladas.

Resumo das ações imediatas pós-instalação:

• Configurar SMTP
• Habilitar HTTPS com certificados válidos
• Agendar backups e testes de restauração
• Migrar plugins e customizações via staging

Extras:

• Se preferir containerização, avalie uma imagem Docker oficial ou personalizada.
• Para alto tráfego, considere escalabilidade horizontal e balanceadores de carga.