Docker + Maven + SpringMVC + Tomcat

Prólogo

Desde que conheci o Docker e comecei a me aprofundar no assunto, procurei identificar como poderia aproveitar essa tecnologia interessantíssima para tornar o meu dia-a-dia como desenvolvedor ainda mais produtivo.

Se você não sabe o que é Docker, aqui vai uma breve explicação:

Docker é uma ferramenta que possibilita a criação e administração de containers, que são ambientes parecidos com uma máquina virtual. Uma das diferenças é que a instalação do Sistema Operacional (SO) pode ser reaproveitado utilizando a mesma instalação de SO para mais de um container, compartilhando os recursos do kernel entre os containers e máquina host.

Nesses containers podemos encapsular nossa aplicação e o ambiente, incluindo configurações, como variáveis de ambiente necessárias para a execução do projeto, arquivos de configuração personalizados, bibliotecas e dependências. Desta forma, seu ambiente estará configurado, empacotado e pronto para ser portável para qualquer outro ambiente (homologação ou produção).

Por que devo utilizar o Docker?

Um dos argumentos para a utilização do Docker é eliminar a desculpa de que “na minha máquina funciona”. A utilização de containers deverá fazer parte de todo o seu fluxo de trabalho partindo da etapa de desenvolvimento até a fase de produção.

Por onde posso começar?

Como você poderia começar utilizando o Docker no seu projeto? Se você trabalha com linguagens interpretadas (como Python, Ruby e etc) a tarefa pode ser um pouco mais simples, bastaria criar um container que compartilha um diretório com a máquina host através de VOLUMES e iniciar os trabalhos. No entanto, se você trabalha com linguagens compiladas (Java, Haskell, Go e etc), a tarefa pode exigir alguns passos adicionais, já que possuímos dois estágios: compilação e execução.

O que temos para hoje?

Nesse artigo você poderá acompanhar um passo a passo de como criar um Dockerfile para uma aplicação Java com Maven, Tomcat e SpringMVC podendo aproveitar todas vantagens do Docker, citadas anteriormente.

Tecnologias utilizadas

Para este exemplo usaremos um projeto Java usando o Framework SpringMVC, que será compilado através do Maven e rodará no Tomcat. Como toda estrutura rodará baseada em Docker, não será necessário que a máquina host tenha o Java instalado, pois todo trabalho pesado será feito pelos containers.

Organizando as ideias

Para facilitar e organizar a manutenção da estrutura, você poderá separar os passos em dois containers, similar ao que é feito em ambientes com integração contínua:

1. Um para a etapa de compilação que conteria o JDK + Maven (estágio de build);
2. Outro (mais enxuto) contendo apenas JRE + Tomcat (estágio de deploy).

Para essa tarefa vamos utilizar um recurso chamado “Multi-Stage Build” que possibilita a criação de camadas intermediárias dentro do mesmo Dockerfile.

Segundo a documentação do docker, uma das coisas mais complexas de se construir uma imagem é mantê-la enxuta, e para isso é necessário lembrar de limpar os artefatos que não serão necessários antes de mover para a próxima camada.

Com o recurso do multi-stage builds é possível escolher os artefatos que vão ser copiados de um stage para outro, permitindo deixar para trás aquilo que não nos interessa. Isso evita a criação de condições com múltiplos run, a criação de camadas desnecessárias e a utilização de mais de um dockerfile, tornando o mais simples e fácil de manter.

Neste exemplo, a camada número 1 (que chamaremos de builder) servirá apenas como auxílio durante a compilação do código fonte e será descartada após cumprir o seu papel, pois não será necessária no resultado final. Assim, teremos o resultado final de uma imagem com APENAS: JRE + TOMCAT + Projeto Java.

Vamos aos passos:

Após instalar o docker, crie um arquivo nomeado como Dockerfile contendo os seguintes passos:

A primeira camada (FROM maven:3.3-jdk-8 as builder). Copia o código fonte, para dentro do container, a partir da raiz do projeto (COPY . /usr/src/mymaven). O WORKDIR seta o diretório a partir de onde os comandos serão executados.

FROM maven:3.3-jdk-8 as builder
COPY . /usr/src/mymaven
WORKDIR /usr/src/mymaven

O comando a seguir compila todo o código e copia todos artefatos (.war) gerados para dentro do diretório /usr/src/wars/

RUN mvn clean install -f /usr/src/mymaven && mkdir /usr/src/wars/
RUN find /usr/src/mymaven/ -iname '*.war' -exec cp {} /usr/src/wars/ \;

A segunda camada (FROM tomcat:7.0.90-jre8) copia os artefatos do diretório mencionado anteriormente para o diretório webapps do Tomcat.

FROM tomcat:7.0.90-jre8
COPY --from=builder /usr/src/wars/* /usr/local/tomcat/webapps/

Como resultado final o Dockerfile ficará da seguinte forma:

O repositório com o exemplo completo está disponível no meu github.

Após criar o arquivo nomeado como "Dockerfile" na raiz do projeto. Você poderá executar o comando abaixo para construir a imagem através do "docker build" e executar o container a partir do "docker run".

Executar o comando:

$ docker build -t rogeriofonseca/tomcat-server:1.0 .
&& docker run -p 8383:8080 — rm -it rogeriofonseca/tomcat-server:1.0

Pronto! Se tudo deu certo, sua aplicação estará disponível no endereço:

http://localhost:8383/springmvc-stand-alone/

Este exemplo poderia ser utilizado em qualquer projeto Java que utiliza maven e Tomcat. Porém, há uma restrição em relação ao JDK, as imagens disponibilizadas oficialmente pela Oracle utilizam apenas o OpenJDK uma vez que, os termos de uso da Oracle nos proíbe de criar e disponibilizar um container com a Oracle JDK. Podemos falar mais sobre isso num próximo artigo.

Caso queira compreender melhor o que é o Docker e como ele funciona, minha dica é o site oficial do docker e o site Mundo Docker.

Obrigado e até a próxima.