O Docker é uma plataforma open source que possibilita a criação e administração de ambientes de forma isolada. Dessa forma, uma aplicação pode ser empacotada dentro de um container com todas as bibliotecas e recursos necessários para ser executada em outro host que possua apenas o Docker instalado, possibilitando a integração com múltiplos clouds, como AWS, Azure ou Google.

Nesse exemplos usamos o Docker como tecnologia de container, porém, seria possível utilizar outras ferramentas, como o Kubernetes.

Nesse tutorial, mostraremos como:

1. Criar e executar uma imagem Docker a partir do repositório de código Git.

2. Enviar uma imagem para um repositório de imagens Docker;

3. Obter e executar uma imagem Docker a partir de um repositório de imagens;

4. Entender os comandos do arquivo Dockerfile.

As ações 1 e 2 podem ser automatizadas através de um pipeline Jenkins, por exemplo. Veja mais detalhes em nosso tutorial Esteira DevOps - CI/CD pipeline.

Requisitos:

Requisitos

Antes de começar a seguir os passos do tutorial é preciso ter certeza de que se tem um ambiente minimamente preparado para reproduzir o exemplo. Abaixo estão os requisitos principais:

1. Conhecimentos básicos sobre Docker e Nginx.

2. WSL instalado e configurado

3. Git instalado.
4. Conhecimento básico sobre Docker

   .

5. Docker Engine instalado e logado em seu registry, como o DockerHub.

6. Projeto Cronapp criado. Caso haja dúvidas de como criar um projeto, acesse a documentação Criar projeto.

7. Recomendamos que o equipamento possua os requisitos do ambiente de produção

   .Possuir um projeto Cronapp (v2.7 ou maior) no Git (exemplo GitHub) e um repositório de imagens Docker para enviar sua imagem

   .

   Nesse tutorial usaremos DockerHub, para utilizar outro registry, será necessário: configurar o Docker, respeitar a nomenclatura de tag em repositórios privados e adaptar os comandos desta documentação.

Terminal

Os comandos exibidos nesse tutorial serão executados via terminal /Prompt de Comando (Windows, Linux ou Mac) WSL e será necessário que o usuário tenha perfil Administrador (root) do sistema. Âncoracriar-executar-imagem-dockercriar-executar-imagem-docker

Criar e executar imagem Docker

Abra o seu terminal e execute os comandos abaixo, mostraremos em detalhes o que cada comando faz.

Clone do repositório git

O comando abaixo irá clonar o projeto do Git para dentro do diretório informado. 

git clone <endereço> -b <branch> <novo-diretório>

• <endereço>: endereço HTTPS do repositório git.
• <branch>: branch que será baixada.
• <novo-diretório>: nome do diretório local a ser criado.

git clone https://github.com/cronapp-samples/Get_Started.git -b master proj-get-started

Após concluir o processo de clonagem do repositório Git, utilize o comando a seguir para acessar o diretório recém-criado e prosseguir com os próximos passos.

cd <novo-diretório>

• <novo-diretório>: nome do diretório local criado no comando anterior.

cd proj-get-started

Compilar

No próximo passo iremos baixar todas as bibliotecas e compilar o projeto. Esse processo costuma demorar alguns minutos.

Esse passo irá executar todos os comandos do arquivo Dockerfile do projeto.

docker build --build-arg CONTEXT_USE=<variavel-context_user> -t <conta-registry>/<nome-imagem>:<tag> .

• <variavel-context_user>:  se "true", define que as configurações de banco de dados sejam armazenadas na imagem Docker. Veja mais detalhes na caixa de atenção dessa variável.
• <conta-registry>: nome da sua conta DockerHub, ou outro registry Docker.
• <nome-imagem>: nome de um repositório da sua conta DockerHub, ou outro registry Docker. Esse nome deve estar em letras minúsculas.
• <tag>: informe uma versão da imagem, exemplo "v0.1" ou "versao2".

docker build --build-arg CONTEXT_USE=true -t tutorialcronapp/get_started:v0.01 .

Executar

Por fim, rode a imagem Docker.

docker run --name <nome-container> --rm -p <porta>:8080 <conta-registry>/<nome-imagem>:<tag>

• <nome-container>: defina um nome para o contêiner Docker.
• <porta>:8080: porta local para executar o projeto e a porta onde o Docker está rodando, o padrão é "8080". Garanta que não exista outro serviço sendo executado na primeira porta.
  No código exemplo abaixo, escolhemos a porta "9090" para o projeto e deixamos a porta padrão "8080" para o Docker.
• <conta-registry>: informe a sua conta DockerHub, ou outro registry Docker, informado no comando anterior.
• <nome-imagem>: informe o repositório da sua conta DockerHub, ou outro registry Docker, informado no comando anterior.
• <tag>: informe a versão da imagem usado no comando anterior. 

Devido ao parâmetro "–-rm", o contêiner será automaticamente removido pelo Docker ao parar, porém a imagem é mantida.

docker run --name get-started --rm -p 9090:8080 tutorialcronapp/get_started:v0.01

Abrir o projeto

Abra o navegador e informe o endereço: localhost:<primeira-porta-usada-no-comando-acima> para executar o projeto.

Na figura abaixo vemos as seguintes janelas: o terminal exibindo as imagens locais do Docker, incluindo a que acabamos de criar; o navegador com o projeto local aberto e a aplicação do Docker Desktop, exibindo o container atualmente em execução.

Image Removed

Figura 1 - Janelas do terminal, navegador com o projeto em execução e Docker Desktop

Enviar imagem para o Registry

Agora que temos a imagem Docker do projeto, podemos enviá-la para um registry Docker, como o DockerHub. Necessário já ter criado o repositório na conta que usamos nos comandos acima e estar logado no Docker Desktop.

docker push <conta-registry>/<nome-imagem>:<tag>

• <conta-registry>: informe a sua conta DockerHub, ou outro registry Docker, informado no comando que usamos para rodar o Docker.
  Caso utilize um registry que não seja o DockerHub, será necessário informar o endereço completo (ex: dominio_do_registry.com/<conta_registry>/<nome-imagem>:<tag>).
• <nome-imagem>: informe o repositório da sua conta DockerHub, ou outro registry Docker, informado no comando que usamos para rodar o Docker.
• <tag>: informe a versão da imagem usado no comando que usamos para rodar o Docker

docker push tutorialcronapp/get_started:v0.01

Para mais informações de instalação e configuração, consulte a documentação oficial.

Obter e executar imagem do Registry

Com a imagem no Docker Hub, ou outro registry, é possível obter e executar localmente em 2 comandos.

Obter imagem

Execute o comando abaixo para obter a imagem.

docker pull <conta-registry>/<nome-imagem>:<tag>

• <conta-registry>: informe a sua conta DockerHub, ou outro registry Docker, informado no comando que usamos para rodar o Docker.
  Caso utilize um registry que não seja o DockerHub, será necessário informar o endereço completo (ex: dominio_do_registry.com/<conta_registry>/<nome-imagem>:<tag>).
• <nome-imagem>: informe o repositório da sua conta DockerHub, ou outro registry Docker, informado no comando que usamos para rodar o Docker.
• <tag>: informe a versão da imagem usado no comando que usamos para rodar o Docker

docker pull tutorialcronapp/get_started:v0.01

Image Removed

Figura 2 - obtendo imagem do registry

Executar

Rode a imagem Docker.

docker run --name <nome-container> --rm -p <porta>:8080 <conta-registry>/<nome-imagem>:<tag>

• <nome-container>: defina um nome para o contêiner Docker.
• <porta>:8080: porta local para executar o projeto e a porta onde o Docker está rodando, o padrão é "8080". Garanta que não exista outro serviço sendo executado na primeira porta.
  No código exemplo abaixo, escolhemos a porta "9090" para o projeto e deixamos a porta padrão "8080" para o Docker.
• <conta-registry>: informe a sua conta DockerHub, ou outro registry Docker, informado no comando anterior.
• <nome-imagem>: informe o repositório da sua conta DockerHub, ou outro registry Docker, informado no comando anterior.
• <tag>: informe a versão da imagem usado no comando anterior. 

Devido ao parâmetro "–-rm", o contêiner será automaticamente removido pelo Docker ao parar, porém a imagem é mantida.

docker run --name get-started --rm -p 9090:8080 tutorialcronapp/get_started:v0.01

Abrir o projeto

Abra o navegador e informe o endereço: localhost:<primeira-porta-usada-no-comando-acima> para executar o projeto. (Figura 1)

Arquivo Dockerfile

Para construir uma imagem, o Docker utiliza as instruções contidas no arquivo DockerfilerDockerfile, normalmente localizado na raiz do projeto. Todos os projetos criados a partir da versão 2.7 do Cronapp já possui esse arquivo configurado para construir uma imagem local ou executá-lo em um CI/CD pipeline.

Veremos aqui Abaixo apresenta como esse arquivo está configurado.

## Consulte a documentação do Docker em https://docs.cronapp.io para informações sobre o conteúdo desse arquivo.

FROM ubuntu:18.04 as maven_builder 
RUN apt update && apt install -y maven openjdk11-11-jdk npm git bash
WORKDIR /app
ADD pom.xml /app/pom.xml
RUN git config --global url."https://".insteadOf git://
ARG TIER
ARG CONTEXT_USE
ARG MOBILE_APP

## Para repositório EXTERNO não é necessário alterações.
## Para repositório INTERNO comente as linhas 16, 17 e 18 e retire os comentários nas linhas 21, 22, 23 e 24.

## Usando repositórios externo - JAR e NPM
RUN mvn dependency:go-offline -B
ADD . /app
RUN cd /app && mvn package -X -Dcronapp.profile=${TIER} -Dcronapp.useContext=${CONTEXT_USE} -Dcronapp.mobileapp=${MOBILE_APP}

## Usando repositórios interno - JAR e NPM
#ADD settings.xml  $HOME/.m2/settings.xml
#RUN npm config set registry https://my.registry.com/your-repository/name && mvn -s /app/settings.xml dependency:go-offline -B
#ADD . /app
#RUN cd /app && mvn -s /app/settings.xml package -X -Dcronapp.profile=${TIER} -Dcronapp.useContext=${CONTEXT_USE} -Dcronapp.mobileapp=${MOBILE_APP}

FROM tomcat:9.0.17-jre11
RUN rm -rf /usr/local/tomcat/webapps/* && groupadd tomcat && useradd -s /bin/false -M -d /usr/local/tomcat -g tomcat tomcat
COPY --from=maven_builder /app/target/*.war /usr/local/tomcat/webapps/ROOT.war
RUN chown tomcat:tomcat -R /usr/local/tomcat
USER tomcat

Detalhamento dos comandos por linha:

1.  #Comentário
2. _
3. Baixa a versão 18.04 do Ubuntu, cria uma referência com o nome "maven_builder" e inicia a primeira instrução do build.
4. Instala o Maven, JAVA 11, NPM, GIT e o BASH.
5. Define o diretório de trabalho /app.
6. Copia o arquivo pom.xml para o diretório /app.
7. Redefine o protocolo de comunicação do endereço Git, alterando de "git://" para "https://".
8. Define uma variável de nome TIER que representa o perfil do banco de dados da aplicação.
9. Define uma variável de nome CONTEXT_USE para indicar se deve incluir o arquivo context.xml com dados de conexão. (verificar aviso abaixo)
10. Define uma variável de nome MOBILE_APP para indicar se deve incluir o diretório da aplicação mobile.
11. _
12.  #Comentário: Os comandos da linha 16 até 18 são utilizados apenas para repositórios externos (JAR e NPM).
13.  #Comentário: Caso necessite usar em repositórios internos, comente as linhas 16 até 18 e retire os comentários das linhas 21 até 24.
14.  _
15. #Comentário: Repositório externos.
16. Obtém as dependências Maven para dentro do Docker.
17. Copia todo o conteúdo do diretório atual (que contém os arquivos do projeto) para o diretório criado no comando 5.
18. Nesse passo são executados uma sequência de comandos:
    • Acessa o diretório criado no passo  3;
    • Força a exibição do log no formato Debug, facilitando a identificação de erros e passa 3 parâmetros Maven para a geração do .war: 
      
      • cronapp.profile, define o tipo do perfil do banco de dados,
      • cronapp.useContext, indica se deve incluir o context.xml com dados de conexão do banco de dados,
      • cronapp.mobileapp, indica se deve incluir o diretório com a aplicação mobile.
19.  _
20. #Comentário: Repositório interno.
21. Copia o arquivo settings.xml para o diretório $HOME/.m2/
22. Nesse passo são executados uma sequência de comandos:
    • Define de onde serão obtidas as dependências do NPM;
    • Obtém as dependências Maven contidos no settings.xml para dentro do Docker.
23. Copia todo o conteúdo do diretório atual (que contém os arquivos do projeto) para o diretório criado no comando 5.
24. Nesse passo são executados uma sequência de comandos:
    • Acessa o diretório criado no passo  3;
    • Força a exibição do log no formato Debug (facilitando a identificação de erros), utiliza o settings.xml e mais os 3 parâmetros Maven para a geração do .war: 
      
      • cronapp.profile, define o tipo do perfil do banco de dados,
      • cronapp.useContext, indica se deve incluir o context.xml com dados de conexão do banco de dados,
      • cronapp.mobileapp, indica se deve incluir o diretório com a aplicação mobile.
25. _
26. Baixa uma imagem Tomcat 9.0.17 com o Java11 e inicia as próximas instruções.
27. Por garantia, remove todo o conteúdo, caso exista, do diretório "/usr/local/tomcat/webapps/" na imagem do Tomcat.
28. Copia o arquivo .war gerado no diretório "/app/target/" da primeira imagem (Alpine Linux) para o diretório "/usr/local/tomcat/webapps/" dessa imagem, em seguida renomeia o arquivo .war para ROOT.war.
29. Adiciona uma permissão de forma recursiva ao local "/usr/local/tomcat" (e seus subdiretórios) para o usuário tomcat e o grupo tomcat.
30. Define o usuário do contêiner após subir o Docker.

Caso necessário, é possível editar o comando Maven (RUN mvn clean && mvn package ...) e adicionar novos parâmetros, como por exemplo, incluir o projeto mobile no arquivo .war. 

Passos

Este tutorial irá apresentar como executar, via comandos no WSL, os quatro tipos de opções disponíveis para Pacote para Deploy. 

War Completo

A primeira opção que vamos executar no Pacote para Deploy é a "War Completo". Para isso, acesse no menu do sistema Projeto > Exportar. Em seguida, escolha a opção "Pacote para Deploy". Na janela que abrir escolha no campo "Tipo de Artefato" a opção "War Completo" e habilite a checkbox do campo "Dockerfile", assim como exibe a imagem abaixo. 

Figura 1 - Janela Pacote para Deploy

Após finalizar o download do pacote, extraia os arquivos da pasta .zip baixada para uma pasta descompactada. Em seguida, adicione a pasta descompactada no diretório wsl, para este exemplo adicionamos a pasta no diretório do usuário, seguindo o caminho \\wsl.localhost\Ubuntu-20.04\home\laila. Assim como mostra a imagem abaixo.

Figura 1.1 - Diretório wsl onde a pasta descompactada foi adicionada

Após esses passos, vamos executar no terminal do wsl o script run.sh. Para isso, no terminal acesse o diretório que contém a pasta descompactada e execute o comando abaixo.

sh run.sh

Figura 1.2 - Terminal e execução no navegdor

War Separado

War Servidor

War Front-end

Zip Front-end