O Redmine é um software de gestão de projetos, desenvolvido em Ruby on Rails e multiplataforma. Com a maturação da aplicação, tem ganho cada vez mais adeptos e tem-se tornado mais flexível.

Neste artigo, que faz parte da série “Como criar um servidor de integração contínua”, vamos apresentar como instalar o Redmine 2.6.1 numa máquina com Linux Mint 17.1 e como integrar o Redmine com Git, de forma a ser possível ver o histórico do projeto e fechar tarefas através dos commits.

Sendo o Redmine uma aplicação web, será necessário instalar o Apache e MySQL para base de dados. Nesta instalação, iremos configurar o servidor para executar o Redmine em HTTPS, com um certificado auto-assinado. O artigo está dividido nas seguintes secções:

  1. Preparação - Instalar Apache, MySQL e dependências
  2. Instalação do Redmine
  3. Configuração de SSL
  4. Conclusão da instalação do Redmine
  5. Criar projeto e integrar Redmine com Git

Preparação - Instalar Apache, MySQL e dependências

  1. O primeiro passo é a instalação do serviço Apache e do Phusion Passenger.

    sudo apt-get install --no-install-recommends apache2 libapache2-mod-passenger
    
  2. O Redmine necessita de uma base de dados que pode ser MySQL, PostgreSQL ou SQL Server. Neste artigo iremos usar MySQL. Caso queiras usar outro sistema lê esta secção da documentação.

    No momento da instalação será solicitada a password do utilizador root. Caso estejas a preparar um servidor de produção, coloca uma password complexa.

    sudo apt-get install mysql-server mysql-client
    
  3. Com o MySQL instalado, vamos criar a base de dados e o utilizador. À base de dados chamei redminedb e ao utilizador redmineusr, que tem a password Redmine@usr.

    mysql -u root –p
    create database redminedb character set utf8;
    create user 'redmineusr'@'localhost' identified by 'Redmine@usr';
    GRANT ALL PRIVILEGES ON redminedb.* TO 'redmineusr'@'localhost';
    exit
    
  4. Terminamos a fase de preparação com a instalação do Ruby, Rake e outras bibliotecas necessárias

    sudo apt-get install --no-install-recommends git rubygems-integration ruby1.9.1-dev ruby-rmagick rake make gcc libmysqlclient-dev bundler
    

Instalação do Redmine

  1. À data de escrita deste artigo, a versão mais recente do Redmine é 2.6.1, que vamos agora instalar.

    Nota: caso estejas a instalar o Redmine com objetivo de usar plugins, convém garantir que os plugins são compatíveis com a versão que estás a instalar. Para isso deves aceder à página de plugins e verificar as versões suportadas por cada um.

    cd /var/www
    sudo wget http://www.redmine.org/releases/redmine-2.6.1.tar.gz -O redmine-2.6.1.tar.gz
    sudo tar xvfz redmine-2.6.1.tar.gz
    sudo rm redmine-2.6.1.tar.gz
    sudo mv redmine-2.6.1 redmine
    cd /var/www/redmine
    
  2. Instalação do Bundler, que gere todas as dependências de gemas do Redmine. Depois instalamos todas as gemas necessárias.

    sudo gem install bundler
    bundle install --without development test sqlite rmagick
    
  3. Criação do ficheiro de configurações do Redmine, atribuição de permissões e preenchimento das configurações

    touch config/database.yml
    chmod 640 config/database.yml
    sudo chgrp www-data /var/www/redmine/config/database.yml
    chmod ugo+r /var/www/redmine/config/database.yml
    gedit config/database.yml
    

    No editor aberto, deves introduzir a seguinte configuração (altera a informação da base de dados e utilizador caso seja necessário)

    production:   
        adapter: mysql2
        database: redminedb
        socket: /var/run/mysqld/mysqld.sock
        username: redmineusr
        password: "Redmine@usr"
        encoding: utf8
    
  4. Após guardar o ficheiro, executa novamente o bundle

    bundle install --without development test sqlite rmagick
    
  5. Cria um token aleatório usado pelo Rails para codificar os dados transmitidos

    rake generate_secret_token
    chmod 0640 config/initializers/secret_token.rb
    sudo chgrp www-data config/initializers/secret_token.rb
    chmod ugo+r /var/www/redmine/config/initializers/secret_token.rb
    
  6. Criação da base de dados e executar migrations (scripts) para carregar a base de dados com os valores por defeito

    RAILS_ENV=production rake db:migrate
    RAILS_ENV=production REDMINE_LANG=en rake redmine:load_default_data
    
  7. Criar e definir permissões de pastas

    mkdir -p tmp tmp/pdf public/plugin_assets
    sudo chown -R www-data: files log tmp public/plugin_assets
    sudo chmod -R 0755 files log tmp public/plugin_assets
    sudo chmod -x log/*.log
    
  8. Alterar as definições de logs, para não ficarem com tamanho excessivo

    sudo gedit /etc/logrotate.d/redmine
    

    No editor, introduzir a informação apresentada abaixo e guardar.

    /var/www/redmine/log/*.log {
        daily
        missingok
        rotate 7
        compress
        notifempty
        copytruncate 
    }
    
  9. Para testarmos o funcionamento, antes de alterar as definições do Apache, vamos usar o servidor web WEBrick através do comando

    sudo ruby script/rails server webrick -e production
    

    Se tudo correu bem, deves ver um output semelhante a

    => Booting WEBrick
    => Rails 3.2.21 application starting in production on http://0.0.0.0:3000
    => Call with -d to detach
    => Ctrl-C to shutdown server
    

    Se acederes ao endereço indicado (http://0.0.0.0:3000), será apresentada a página do Redmine. Caso queiras fazer login, o utilizador é admin e a password admin.

    Instalar Redmine 2.6 em Linux e integração com Git images/10-install-redmine-2-6-1-linux-mint-integrate-with-git-ci-server/205-redmine-test-with-webrick.png
  10. Já verificámos que a instalação foi feita com sucesso e podemos terminar o WEBrick e sair da pasta do Redmine

    CTRL+C
    cd
    
  11. Agora vamos configurar o Apache e o Passenger e vamos criar o vhost para o Redmine. O nome que dei ao servidor foi ciserver, caso atribuas outro nome, altera o “ciserver” pelo nome do teu servidor (em letras minúsculas).

    sudo gedit /etc/apache2/sites-available/ciserver-ssl.conf
    

    No editor apresentado, introduz a seguinte configuração

    PassengerMaxPoolSize 2 
    PassengerMaxRequests 1000 
    PassengerUploadBufferDir /tmp/ 
    PassengerHighPerformance on 
    PassengerUser www-data
    ServerTokens Prod 
    ServerSignature Off 
    <VirtualHost _default_:443> 
        ServerName ciserver 
        SSLEngine On 
        SSLCertificateFile    /etc/apache2/ssl/ciserver.crt 
        SSLCertificateKeyFile /etc/apache2/ssl/ciserver.key 
        <FilesMatch ".(cgi|shtml|phtml|php)$"> 
            SSLOptions +StdEnvVars 
        </FilesMatch> 
        <Directory /usr/lib/cgi-bin> 
            SSLOptions +StdEnvVars 
        </Directory> 
        DocumentRoot /var/www/redmine/public 
        <Directory /var/www/redmine/public> 
            Options FollowSymLinks 
            AllowOverride None 
            Require all granted 
        </Directory>
    </VirtualHost>
    
  12. Vamos adicionar o vhost ao Apache

    sudo a2dissite default 000-default
    a2dissite default-ssl
    sudo service apache2 restart
    sudo a2ensite ciserver-ssl
    sudo service apache2 reload
    

    Nota: ao executar estes comandos podem ser apresentados alguns erros, como a falta do SSLEngine ou a falta dos ficheiros ciserver.crt e ciserver.key. Ignora estas mensagens, uma vez que o certificado será criado de seguida.

  13. Convém definir o nome do servidor na configuração global do Apache. Para isso, deves executar o comando

    sudo gedit /etc/apache2/apache2.conf
    

    e adicionar, caso não exista, a diretiva ServerName com o nome do teu servidor. No meu caso

    ServerName ciserver
    

Configuração de SSL

Na configuração do virtual host indicámos a existência do ciserver.crt e ciserver.key, que ainda não criámos. Neste passo vamos criar um certificado SSL auto-assinado (self-signed). Se quiseres um certificado assinado por uma empresa certificada visita o nosso guia para criação de certificado SSL gratuito e importação no cPanel.

  1. Vamos criar a pasta /etc/apache2/ssl, onde serão armazenados os certificados. Vamos também instalar o modulo SSL e criar um certificado temporário

    sudo mkdir /etc/apache2/ssl
    sudo /usr/sbin/make-ssl-cert /usr/share/ssl-cert/ssleay.cnf /etc/apache2/ssl/ciserver.crt
    cd /etc/apache2/ssl
    sudo cp ciserver.crt ciserver.key
    sudo chmod 600 /etc/apache2/ssl/ciserver.key
    a2enmod ssl
    sudo apache2ctl -S 
    sudo service apache2 restart
    

    Se tudo correu bem, neste momento é possível aceder ao Redmine via HTTPS. Uma vez que o certificado é auto-assinado, será apresentada uma mensagem a indicar que o site não é seguro.

    Instalar Redmine 2.6 em Linux e integração com Git images/10-install-redmine-2-6-1-linux-mint-integrate-with-git-ci-server/204-redmine-temporary-self-signed-certificate-https-warning.png
  2. Vamos agora criar um certificado auto-assinado. Começamos pela criação da chave privada

    cd /etc/apache2/ssl
    sudo openssl genrsa -des3 -out ciserver.key 1024
    
  3. Passamos à criação do CSR (Certificate Signing Request)

    sudo openssl req -new -key ciserver.key -out ciserver.csr
    
  4. Removemos a pash phrase da chave

    sudo cp ciserver.key ciserver.key.org
    sudo openssl rsa -in ciserver.key.org -out ciserver.key
    
  5. E criamos o certificado

    sudo openssl x509 -req -days 365 -in ciserver.csr -signkey ciserver.key -out ciserver.crt
    sudo cp ciserver.crt ciserver.key /etc/apache2/ssl
    
  6. Por fim, reiniciamos o Apache

    sudo service apache2 restart
    
  7. Se o Apache foi iniciado, o certificado foi aplicado com sucesso. No entanto, os browsers vão continuar a indicar uma ligação de HTTPS insegura. Para resolver esta situação, uma vez que o certificado é auto-assinado, é necessário importar o certificado para o browser.

    Para importar o certificado no Firefox (Linux), basta seguir os passos

    1. Aceder ao menu Editar » Preferências
    2. Selecionar o separador Avançado
    3. Clicar no botão Ver certificados
    4. No separador Autoridades, carregar no botão Importar…
    5. Selecionar o ficheiro ciserver.crt e importar
    6. Reiniciar o browser

    Para importar o certificado noutros browsers, lê este post do StackOverflow (em inglês).

  8. Depois do certificado importado deixa de ser apresentado o aviso de segurança e tens acesso direto à aplicação.

    Instalar Redmine 2.6 em Linux e integração com Git images/10-install-redmine-2-6-1-linux-mint-integrate-with-git-ci-server/199-redmine-https-with-imported-self-signed-certificate.png

Conclusão da instalação do Redmine

Para finalizar a instalação do Redmine, convém instalar a biblioteca ImageMagick, que permite a criação de imagens e é usada por alguns plugins

sudo apt-get update
sudo apt-get install imagemagick --fix-missing

Lembra-te também de alterar a password do utilizador admin e dar uma vista de olhos pela página de plugins. Existem alguns interessantes, como por exemplo, Lightbox Plugin 2, CKEditor, Attach image from clipboard e Advanced Roadmap v2.

Et voilá! O Redmine está instalado e a funcionar de forma segura com HTTPS.

Instalar Redmine 2.6 em Linux e integração com Git images/10-install-redmine-2-6-1-linux-mint-integrate-with-git-ci-server/195-redmine-admin-info-with-imagemagick.png

Criar projeto e integrar Redmine com Git

No segundo artigo desta série, instalámos o Git e fizemos o primeiro commit. Agora que temos o Redmine instalado, vamos ver como integrar as duas ferramentas e como podemos fechar tarefas através das mensagens dos commits.

  1. Vamos começar por aceder ao Redmine e entrar como Administrador. Depois do login, vamos aceder à opção Projetos

    Instalar Redmine 2.6 em Linux e integração com Git images/10-install-redmine-2-6-1-linux-mint-integrate-with-git-ci-server/201-redmine-projects-page.png
  2. Agora clicamos em “Novo projeto” e preenchemos os dados necessários. Seleciona as ferramentas que queres usar e carrega em “Criar”. Tudo, à exceção do identificador, pode ser alterado depois de criado o projeto.

    Instalar Redmine 2.6 em Linux e integração com Git images/10-install-redmine-2-6-1-linux-mint-integrate-with-git-ci-server/197-redmine-create-new-project.png
  3. No ecrã seguinte, acedemos ao separador Repositórios e carregamos em “Novo repositório”

    Instalar Redmine 2.6 em Linux e integração com Git images/10-install-redmine-2-6-1-linux-mint-integrate-with-git-ci-server/202-redmine-repositories-tab.png
  4. Seleciona o Git como SCM, coloca o identificador do repositório e introduz o caminho para o repositório. Como o Redmine e o Git estão instalados na mesma máquina, apenas é necessário introduzir o caminho real (/home/user/git/testproject.git) do diretório que criámos no segundo artigo.

    Se tiveres o repositório do Git e o Redmine em servidores diferentes, será necessário partilhar a pasta do repositório e colocar neste caminho o caminho para a partilha.

    Instalar Redmine 2.6 em Linux e integração com Git images/10-install-redmine-2-6-1-linux-mint-integrate-with-git-ci-server/200-redmine-project-create-git-repository.png
  5. No segundo artigo, quando instalámos o Git, fizemos um push para o repositório do servidor. Assim, se acederem novamente ao separador “Repositórios”, vais ver todos os ficheiros enviados no commit:

    Instalar Redmine 2.6 em Linux e integração com Git images/10-install-redmine-2-6-1-linux-mint-integrate-with-git-ci-server/203-redmine-repository-view-git-changes.png
  6. É engraçado ver as alterações no Redmine, não é? Agora vamos alterar as definições do Redmine, para que as tarefas existentes sejam automaticamente fechadas com as mensagens dos commits do Git.

    Para isso, acedemos à opção Administração » Configurações » Separador Repositórios. No final da página, existe uma espécie de tabela onde é possível configurar as palavras-chave o a função dessas palavras chave.

    Instalar Redmine 2.6 em Linux e integração com Git images/10-install-redmine-2-6-1-linux-mint-integrate-with-git-ci-server/196-redmine-configure-close-issues.png

    Nomeadamente:

    • Tipo: Indica se pretendes aplicar esta regra a todos os tipos de tarefa ou a tarefas específicas. Desta forma é possível usar as mesmas palavras-chave para tipos de tarefa diferentes
    • Palavras-chave de fecho: Qual a palavra ou palavras-chave que devem despoletar alguma ação.
    • Estado: Indica o estado a aplicar à tarefa
    • % Completo: Indica se deve ser alterada a percentagem de conclusão da tarefa

    Se quiseres registar o tempo gasto em cada tarefa através das mensagens de commit precisas de

    • Selecionar a opção Ativar registo de tempo
    • Alterar a opção Atividade para tempo registado para outro valor que não o “Padrão”.
  7. Depois de guardares as definições, cria uma nova tarefa

    Instalar Redmine 2.6 em Linux e integração com Git images/10-install-redmine-2-6-1-linux-mint-integrate-with-git-ci-server/198-redmine-create-new-task.png
  8. Agora fazemos a tarefa (código) e fazemos commit com a mensagem Fix #1, onde:

    • Fix é uma das palavras que definimos anteriormente
    • #1 é a referência ao número da tarefa
    Instalar Redmine 2.6 em Linux e integração com Git images/10-install-redmine-2-6-1-linux-mint-integrate-with-git-ci-server/192-git-push-new-commit.png

    Existem mais opções para as mensagens de commit, que podes ver na documentação do Redmine (em inglês).

  9. Voltando agora à tarefa no Redmine, podemos ver que a percentagem de conclusão está a 100% e o estado da tarefa é Fechado.

    Instalar Redmine 2.6 em Linux e integração com Git images/10-install-redmine-2-6-1-linux-mint-integrate-with-git-ci-server/194-issue-closed-redmine-with-git-message.png

    Neste momento conseguimos manipular determinados aspetos das tarefas que estão colocadas no Redmine e, ao fazermos estas referências, conseguimos relacionar tarefas com commits. Nunca te questionaste de onde é que apareceu uma alteração? Eu já. Por isso é útil conseguires relacionar tarefas com commits, especialmente quando tens umas centenas de milhares de linhas de código.

Se tiveres alguma dificuldade que não esteja prevista neste guia, podes aceder ao guia genérico de instalação (em inglês) ou partilhá-la connosco através dos comentários. Existe também um guia detalhado para instalação em CentOS (em inglês).

Este artigo faz parte da série Como criar um servidor de integração contínua