Instalar e configurar TeamCity 9 em Linux

O TeamCity é um servidor de Integração Contínua, desenvolvido pela JetBrains, que suporta várias linguagens (entre as quais Java, .Net e PHP). Embora seja uma ferramenta comercial, existe uma versão Freemium que permite usar até 20 configurações de builds e 3 agentes. Quem desenvolve projetos open source pode candidatar-se a uma licença gratuita da ferramenta. Para conhecer as opções de licenciamento acede à página oficial.

Antes de começarmos a detalhar o processo de instalação, importa perceber para que serve um servidor de integração continua. Uma explicação mais extensa (e talvez teórica) está disponível na Wikipedia (em inglês) e num artigo do Martin Fowler (também em inglês). A minha explicação é simples: um servidor de integração contínua é usado para desencadear processos de forma automática. Isto quer dizer que para o processo de desenvolvimento de uma aplicação Web, o CI pode ser usado para comprimir as versões de Javascript e CSS para ambientes de produção. Ou pode executar os testes em ambientes de QA (Quality Assurance). Ou pode até publicar os artefactos (um exe, msi, jar, etc) num determinado servidor.

Acima de tudo, é importante pensar num servidor de integração continua numa ferramenta que permite executar processos ou aplicações de uma forma automática que não têm de estar obrigatóriamente relacionados com o desenvolvimento de software. Com um CI podes conseguir executar scripts em máquinas remotas, por exemplo.

Posto isto, e na esperança que tenhas percebido o objetivo de um CI, passamos à parte interessante do artigo, que está dividido nas seguintes secções.

Preparação
Instalar TeamCity
Configurar TeamCity

Preparação

Instalar as dependências necessárias para o TeamCity e as dependências PHP, caso não as tenhas ainda instalado.
```
sudo apt-get install build-essential libtcnative-1 php-pear php5 php5-cli php5-curl php5-dev
```

Instalar TeamCity

Descarrega a última versão disponível no site.
Depois de descarregares o ficheiro, acede ao diretório de destino e descompacta-o. À data de escrita do artigo, a versão disponível é a 9.0.4.
```
cd ~/Downloads
tar -xvf TeamCity-9.0.4.tar.gz
```
Depois de descompactado, move o diretório para o destino final. No meu caso, irei colocar o TeamCity em /opt/
```
sudo mv TeamCity /opt/TeamCity
cd /opt/TeamCity
```
Uma vez que o TeamCity é uma aplicação web, é necessário atribuir permissões ao utilizador responsável pelo servidor web. No nosso caso o www-data
```
sudo chown -R www-data /opt/TeamCity
```

Vamos agora criar um script que permita iniciar ou terminar o processo do TeamCity. Para o efeito vamos criar um novo script:

sudo gedit /etc/init.d/teamcity

Após ser apresentado o editor, introduz o seguinte conteúdo no script:

#!/bin/sh
# /etc/init.d/teamcity - startup script for teamcity
export TEAMCITY_DATA_PATH="/opt/TeamCity/.BuildServer"

case $1 in
start)
start-stop-daemon --start -c www-data --exec /opt/TeamCity/bin/teamcity-server.sh start
;;

stop)
start-stop-daemon --start -c www-data --exec /opt/TeamCity/bin/teamcity-server.sh stop
;;

esac

exit 0

O script foi retirado deste blog que, por sua vez, o retirou deste blog

Para conseguirmos executar o script temos de atribuir permissão de execução através do comando:
```
sudo chmod  +x /etc/init.d/teamcity
```
Resta adicionar o script ao startup, para que seja executado sempre que o servidor é iniciado:
```
sudo update-rc.d teamcity defaults
```
Vamos executar o script manualmente neste momento, para conseguirmos aceder à aplicação:
```
sudo /etc/init.d/teamcity
```
Se tudo correu bem, deves conseguir aceder ao TeamCity através do endereço http://localhost:8111 e visualizar a página:

Antes do TeamCity 8, não era possível usar o OpenJDK que vem instalado por defeito no Linux Mint. Nesse caso era necessário desinstalar o OpenJDK e instalar o SDK da Oracle. A partir do TeamCity 8, o OpenJDK é suportado desde que a versão instalada seja a 7 (ver requisitos).

Configurar TeamCity

Neste momento deves configurar o TeamCity, nomeadamente a ligação à base de dados onde a aplicação possa guardar dados.

Acede ao endereço http://localhost:8111 e carrega no botão Proceed
Vais ter várias opções para escolher qual o sistema de base de dados a usar. Uma vez que já configurámos o MySQL no momento de instalação do Redmine vamos usar esse DBMS
O TeamCity é desenvolvido em Java. Para conseguirmos aceder ao MySQL através de uma aplicação Java, tens de instalar o MySQL JDBC connector. Para isso, acede à página de download e seleciona a opção Platform Independent. Depois, basta descarregares o ficheiro .tar

Não é necessário registares-te para descarregares as aplicações do site MySQL. Após clicares no ficheiro que pretendes descarregar, tens uma hiperligação no final da página com a descrição No thanks, just start my download. e basta clicares aí.

Descompacta o ficheiro

cd ~/Downloads
sudo tar -xvf mysql-connector-java-5.1.35.tar.gz

Agora move o ficheiro .jar para o diretório correto no TeamCity

sudo mv mysql-connector-java-5.1.35/mysql-connector-java-5.1.35-bin.jar /opt/TeamCity/.BuildServer/lib/jdbc/

Volta à página de configuração do TeamCity e carrega em Refresh JDBC Drivers.
Resta criar uma base de dados e um utilizador para a aplicação. Para isso deves aceder ao terminal e executares os seguintes comandos.
```
mysql –uroot –p
CREATE DATABASE teamcity CHARACTER SET UTF8;
CREATE USER 'teamcity'@'localhost' IDENTIFIED BY 'T34mC1tY';
GRANT ALL PRIVILEGES ON teamcity.* TO 'teamcity'@'localhost';
exit
```
Acabaste de criar uma base de dados com nome teamcity e um utilizador também denominado teamcity com a password T34mC1tY.
Volta novamente à página de configuração e introduz os dados e carrega em Proceed
Depois de aceitares o licenciamento (não tiveste este trabalho todo para não aceitar, pois não? ) deves criar uma conta de administrador.
E, com isto, está concluída a instalação do TeamCity.

No próximo artigo vemos como instalar e configurar um Agente do TeamCity. Vamos ver o que é uma Configuração e como é que a definimos. No final, ficaremos com o processo integrado ao repositório Git de forma a que a execução da Build seja feita a cada commit.

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