Redmine no CentOS 8 — Guia de instalação

O que é o Redmine

Redmine é um sistema de gestão de projetos e acompanhamento de problemas (issue tracker) open source escrito em Ruby on Rails. Suporta múltiplos projetos, wiki, fóruns, controle de acesso por função e notificações por e-mail. Definição rápida: Redmine = tracker + gestão de projetos com extensões via plugins.

Intenções deste guia

Instalar Redmine em CentOS 8 com MariaDB, Ruby e Nginx.
Fornecer configuração mínima de produção (systemd + Nginx).
Incluir verificações, segurança básica, backup e alternativas.

Pré-requisitos

Um servidor com CentOS 8 (ou compatível como AlmaLinux/Rocky) com acesso root.
Conexão de rede e acesso ao repositório dnf.
Recomendado: firewall configurado e backup da máquina antes de mudanças.

Dependências básicas

Instale ferramentas de desenvolvimento e bibliotecas necessárias:

dnf group install "Development Tools"
dnf install zlib-devel curl-devel openssl-devel -y

Importante: pacotes de desenvolvimento são usados para compilar gems nativas.

Instalar e configurar o banco MariaDB

Instale o servidor MariaDB:

dnf install mariadb-server mariadb-devel -y

Inicie e habilite o serviço:

systemctl start mariadb
systemctl enable mariadb

Entre no shell do MariaDB para criar a base e o usuário:

mysql

No prompt do MariaDB execute:

MariaDB [(none)]> CREATE DATABASE redmine CHARACTER SET utf8mb4;
MariaDB [(none)]> GRANT ALL PRIVILEGES ON redmine.* TO 'redmine'@'localhost' IDENTIFIED BY 'password';
MariaDB [(none)]> FLUSH PRIVILEGES;
MariaDB [(none)]> EXIT;

Nota: substitua ‘password’ por uma senha forte. utf8mb4 é recomendado para compatibilidade com emojis e caracteres multibyte.

Instalar Ruby e Passenger

Habilite o repositório EPEL e instale Ruby e Passenger:

dnf install epel-release -y
dnf config-manager --enable epel -y

dnf install mod_passenger passenger passenger-devel ruby ruby-devel -y

Observação: em produção é comum usar Passenger (integrado ao Nginx/Apache) ou Puma com um reverse proxy; WEBrick é somente para testes.

Instalar o Redmine (usuário dedicado)

Crie um usuário dedicado e baixe a versão do Redmine:

useradd -m -U -r -d /opt/redmine redmine
su - redmine
wget --no-check-certificate https://www.redmine.org/releases/redmine-4.2.1.zip

Extraia e renomeie:

unzip redmine-4.2.1.zip
mv redmine-4.2.1 redmine
cd redmine
cp config/database.yml.example config/database.yml

Edite config/database.yml e configure a seção production:

production:
  adapter: mysql2
  database: redmine
  host: localhost
  username: redmine
  password: "password"
  encoding: utf8mb4

Salve o arquivo e instale bundler e gems:

gem install bundler --no-rdoc --no-ri
bundle install --without development test postgresql sqlite --path vendor/bundle

Gere o token secreto e execute as migrações em modo production:

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

Inicie temporariamente com WEBrick apenas para verificar:

bundle exec rails server webrick -e production

Saída esperada (exemplo):

/usr/bin/ruby: warning: shebang line ending with \r may cause problems
=> Booting WEBrick
=> Rails 5.2.5 application starting in production on http://0.0.0.0:3000
=> Run `rails server -h` for more startup options
[2021-06-24 00:40:15] INFO  WEBrick 1.4.2
[2021-06-24 00:40:15] INFO  ruby 2.5.5 (2019-03-15) [x86_64-linux]
[2021-06-24 00:40:15] INFO  WEBrick::HTTPServer#start: pid=43076 port=3000

Pressione CTRL+C para parar o servidor de teste.

Em seguida, saia do usuário redmine:

exit

Criar um service systemd para o Redmine

Crie o arquivo /usr/lib/systemd/system/redmine.service:

nano /usr/lib/systemd/system/redmine.service

Conteúdo sugerido:

[Unit]
Description=Redmine server
After=syslog.target
After=network.target

[Service]
Type=simple
User=redmine
Group=redmine
ExecStart=/bin/ruby /opt/redmine/redmine/bin/rails server webrick -e production
TimeoutSec=300
Restart=on-failure

[Install]
WantedBy=multi-user.target

Recarregue systemd, inicie e habilite o serviço:

systemctl daemon-reload
systemctl start redmine
systemctl enable redmine
systemctl status redmine

Verifique se a porta 3000 está escutando:

ss -antpl | grep 3000

Importante: usar WEBrick em systemd para produção não é recomendado; prefira Passenger (integração com Nginx) ou um servidor de aplicação como Puma.

Configurar Nginx como reverse proxy

Instale Nginx:

dnf install nginx -y

Crie /etc/nginx/conf.d/redmine.conf com o conteúdo abaixo (exemplo):

upstream backend {
  server 127.0.0.1:3000;
}

server {
    listen 80;
    server_name redmine.example.com;
    access_log /var/log/nginx/redmine.example.com-access.log;
    error_log /var/log/nginx/redmine.example.com-error.log;

    location / {
        proxy_pass http://backend/;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_set_header Host $http_host;

        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto http;
        proxy_set_header X-Nginx-Proxy true;
        proxy_redirect off;
    }
}

Observação: corrigimos X-Forwarded-For e X-Forwarded-Proto para os cabeçalhos padrão. Para HTTPS, troque proto para https e configure certificados.

Teste a configuração e inicie o serviço:

nginx -t
systemctl start nginx
systemctl enable nginx
systemctl status nginx

Acessar a interface do Redmine

Abra no navegador: http://redmine.example.com

Página inicial do Redmine carregada no navegador com link para login

Clique em Sign in para entrar. Tela de login:

Tela de login do Redmine pedindo usuário e senha

O usuário padrão é admin com senha admin (altere imediatamente). Você será direcionado para alterar a senha:

Tela para alterar a senha do usuário admin após primeiro login

Pós-instalação e dicas de produção

Ajuste permissões: garanta que /opt/redmine e subpastas sejam de propriedade do usuário redmine.
Mova para Passenger ou Puma em produção. Passenger se integra ao Nginx; Puma é usado com systemd ou tools como systemd + socket.
Configure e habilite SSL (Let’s Encrypt certbot) e force HTTPS.
Configure SMTP em config/configuration.yml para envio de e-mails (notificações, recuperação de senha).
Configure tarefas agendadas (cron) para tarefas periódicas do Redmine, como limpeza, backups e envio de e-mails.

Exemplo mínimo de backup do banco e arquivos:

# Dump do banco
mysqldump -u root -p redmine > /root/redmine-db-$(date +%F).sql
# Backup dos arquivos (attachments)
tar -czf /root/redmine-files-$(date +%F).tar.gz /opt/redmine/files

Armazene backups fora do servidor (S3, NFS, outro host) e rotacione.

Segurança e SELinux

Se SELinux estiver Enforcing, configure contextos para /opt/redmine e permita conexões de rede para o processo Ruby/Passenger.
Abra portas no firewall: 80/443 para Nginx e (internamente) 3000 se necessário apenas para debug.

Exemplo firewall-cmd:

firewall-cmd --permanent --add-service=http
firewall-cmd --permanent --add-service=https
firewall-cmd --reload

Logs e solução de problemas

Logs do Redmine: /opt/redmine/log/production.log
Logs do Nginx: /var/log/nginx/redmine.example.com-error.log
systemd: journalctl -u redmine -f

Problemas comuns:

Gems nativas falhando ao compilar: verifique gcc e pacotes-devel instalados.
Erros de conexão com MariaDB: confira usuário/senha e host em database.yml.
Arquivos com CRLF causando “shebang line ending with \r”: normalize com dos2unix ou edite para LF.

Alternativas e abordagens diferentes

Usar Docker: imagens oficiais ou comunitárias do Redmine simplificam isolamento e upgrades.
Usar pacote distribuições (ex.: Redmine via repositório OBS/epel se disponível) para atualizações gerenciadas.
Utilizar MariaDB vs PostgreSQL: ambas são suportadas; PostgreSQL é recomendado para algumas features e escalabilidade.

Playbook de implantação (resumo rápido)

Preparar servidor (firewall, atualizações). 2. Instalar dependências (Development Tools, libs). 3. Instalar MariaDB e criar DB/usuário. 4. Instalar Ruby/Passenger. 5. Baixar e configurar Redmine. 6. Instalar gems e migrar DB. 7. Provisionar systemd e Nginx/SSL. 8. Testar e colocar em produção.

Checklist por função

Administrador de sistema:
- Criar usuário redmine e ajustar permissões.
- Configurar backups e rotação.
- Configurar SSL e firewall.
DBA/Operações:
- Criar banco redmine com utf8mb4.
- Testar restauração de backup.
Desenvolvedor/Integrador:
- Verificar plugins compatíveis com a versão do Redmine.
- Testar em staging antes de instalar em produção.

Critérios de aceitação (KRs práticos)

Redmine responde via HTTPS em redmine.example.com sem erros.
Login com usuário admin padrão funciona e senha foi alterada.
Migrações do banco concluídas sem erros.
Backups do banco e arquivos produzem arquivos recuperáveis.

Testes/aceitação rápidos

Acesse / e verifique HTTP 200.
Faça login como admin e crie um projeto de teste.
Anexe um arquivo (upload) e baixe para confirmar permissões.
Dispare uma notificação por e-mail (configurar SMTP) e confirme chegada.

Migração e upgrade

Para atualizar Redmine, faça backup completo, atualize código fonte, execute bundle install e rake db:migrate, teste em staging.
Ao migrar DB entre MySQL/MariaDB e PostgreSQL, teste conversão e exportação adequada.

Opções de failover e escalabilidade (nível alto)

Para alta disponibilidade, mova DB para cluster/replicação e coloque Nginx em front com múltiplas instâncias de aplicação (Puma/Passenger) atrás de um load balancer.
Use armazenamento de arquivos centralizado (NFS, S3 via plugin) para attachments.

Exemplo de decisão rápida (Mermaid)

flowchart TD
  A[Novo servidor?] -->|Sim| B{Deseja Docker?}
  B -->|Sim| C[Usar imagem Redmine Docker]
  B -->|Não| D[Instalar manualmente 'passenger/puma']
  A -->|Não| E[Atualizar/Manter existente]
  D --> F{Produção?}
  F -->|Sim| G[Configurar SSL e monitoramento]
  F -->|Não| H[Executar WEBrick para testes]

Conclusão

Parabéns — você tem um Redmine funcional no CentOS 8 com MariaDB e Nginx. Para produção, recomendo migrar de WEBrick para Passenger ou Puma, configurar SSL e automatizar backups. Teste atualizações em um ambiente de staging antes de aplicar em produção.

Importante: não invente senhas padrão em produção; utilize senhas fortes e controle de acesso.

Instalar o Redmine no CentOS 8