Instalar Redmine 2.6 em Linux e integração com Git

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:

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

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

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

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
```

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

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

À 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 https://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
```
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
```

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

Após guardar o ficheiro, executa novamente o bundle

bundle install --without development test sqlite rmagick

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

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
```

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

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 
}

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.
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
```

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>

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.
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.

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.
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
```

Passamos à criação do CSR (Certificate Signing Request)

sudo openssl req -new -key ciserver.key -out ciserver.csr

Removemos a pash phrase da chave

sudo cp ciserver.key ciserver.key.org
sudo openssl rsa -in ciserver.key.org -out ciserver.key

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

Por fim, reiniciamos o Apache
```
sudo service apache2 restart
```
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).
Depois do certificado importado deixa de ser apresentado o aviso de segurança e tens acesso direto à aplicação.

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.

Vamos começar por aceder ao Redmine e entrar como Administrador. Depois do login, vamos aceder à opção Projetos
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.
No ecrã seguinte, acedemos ao separador Repositórios e carregamos em “Novo repositório”
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.
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:
É 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.

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”.
Depois de guardares as definições, cria uma nova tarefa
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
Existem mais opções para as mensagens de commit, que podes ver na documentação do Redmine (em inglês).
Voltando agora à tarefa no Redmine, podemos ver que a percentagem de conclusão está a 100% e o estado da tarefa é Fechado.

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