Versões comparadas
Chave
- Esta linha foi adicionada.
- Esta linha foi removida.
- A formatação mudou.
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.
Informações |
---|
A partir da versão 2.9.6-SP.44, o arquivo Dockerfile não é mais criado junto com o projeto, mas ao gerar um Pacote para deploy. Isso tornou a virtualização de uma aplicação Cronapp muito mais simples, bastando apenas descompactar o pacote deploy e executar os scripts run.bat ou run.sh que acompanha o pacote. Em breve essa documentação será atualizada. |
Nesse tutorial, mostraremos como:
Criar e executar uma imagem Docker a partir do repositório de código Git. |
Obter e executar uma imagem Docker a partir de um repositório de imagens;
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:
WSL instalado e configurado.
Docker Engine instalado e logado em seu registry, como o DockerHub.
Projeto Cronapp criado. Caso haja dúvidas de como criar um projeto, acesse a documentação Criar projeto.
Recomendamos que o equipamento possua os requisitos do ambiente de produção.
Terminal
Os comandos exibidos nesse tutorial serão executados via terminal WSL e será necessário que o usuário tenha perfil Administrador (root) do sistema. Para mais informações de instalação e configuração, consulte a documentação oficial.
Arquivo Dockerfile
Para construir uma imagem, o Docker utiliza as instruções contidas no arquivo Dockerfile, 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.
Abaixo apresenta como esse arquivo está configurado.
Bloco de código | ||||||||||
---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||
## 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 |
Dica |
---|
Caso necessário, é possível editar o comando Maven ( Veja a lista de parâmetros Cronapp ao gerar pacotes Maven no tópico Exportando war via comando (High-code) da documentação Importar e exportar projetos. |
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
Para iniciar, acesse no menu do sistema Projeto > Exportar. Em seguida, escolha a opção Pacote para Deploy (destaque 1 da Figura 1) e, na janela que exibir, escolha no campo Tipo de Artefato (2) a opção "War Completo" e habilite a checkbox do campo Dockerfile (3), assim como apresentado na imagem abaixo. Por fim, clique em "OK" para iniciar o download do pacote.
Image Removed
Figura 1 - Janela Pacote para Deploy
Após finalizar o download, extraia os arquivos da pasta .zip
para uma pasta descompactada que nomeamos como "war-completo". Em seguida, adicione a pasta descompactada no diretório wsl. Para este exemplo, adicionamos a pasta descompactada no diretório do usuário, seguindo o caminho \\wsl.localhost\Ubuntu-20.04\home\laila
(Figura 1.1).
.
Image Removed
Figura 1.1 - Diretório wsl onde a pasta descompactada foi adicionada e edição do script run.sh
Após esses passos, vamos executar no terminal do wsl o script run.sh
. No terminal, acesse o diretório que contém a pasta descompactada e execute o comando abaixo.
Bloco de código | ||
---|---|---|
| ||
sh run.sh |
Após a execução do comando, será possível abrir o projeto local no navegador utilizando o endereço local com a porta configurada: http://localhost:81/
. Na imagem abaixo, ao lado direito podemos ver a execução do projeto no terminal wsl e ao lado esquerdo a execução do projeto local no endereço configurado (destaque 1 da Figura 1.2).
Image Removed
Figura 1.2 - Execução do projeto local
War Separado
Agora vamos apresentar como exportar um pacote War Servidor e um Front-end de forma separada.
War Servidor
Acesse novamente a janela Opções de Geração de Pacote para Deploy (Figura 1), No campo Tipo de Artefato (destaque 2 da Figura 1), escolha a opção "War Servidor", habilite a checkbox Dockerfile (3) e faça o download do pacote. Em seguida, extraia os arquivos da pasta zip para uma pasta descompactada no diretório wsl e siga os passos da Figura 1.1 para alterar a porta utilizada no script run.sh
. Altere a porta de "80" para "82" e execute o comando abaixo.
Bloco de código | ||
---|---|---|
| ||
sh run.sh |
Visto que se trata apenas do war servidor, não é possível acessar a aplicação com interfaces web. Para isso, teremos que exportar o war front-end e utilizar o endereço http://localhost:<porta-configurada>/
de acordo com a porta configurada no servidor. Consulte o tópico abaixo para mais detalhes.
War Front-end
Na janela Opções de Geração de Pacote para Deploy (Figura 1), no campo Tipo de Artefato (destaque 2 da Figura 1), escolha a opção "War Front-end" e habilite a checkbox Dockerfile (3). No campo Endereço do servidor (4) adicione o endereço http://localhost:82/
configurado no war servidor anteriormente. Em seguida, faça o download da aplicação e siga os passos descritos na Figura 1.1, descompactando os arquivos e adicionando a pasta descompactada no diretório wsl e, em seguida, altere a porta utilizada no arquivo run.sh. Para isso, abra o script run.sh
em um editor de texto e faça a alteração da primeira porta 80 para 83. Por fim, execute o comando abaixo.
Bloco de código | ||
---|---|---|
| ||
sh run.sh |
Figura 2 - Alteração do arquivo run.sh
Após esta etapa, siga os passos da Figura 1.2. Por fim, poderá executar o projeto local no navegador utilizando o endereço configurado: http://localhost:83/
.
Zip Front-end
Este pacote é uma versão compactada dos arquivos estáticos do fron-tend de uma aplicação web, que pode ser utilizado servindo diretamente ao Nginx, por exemplo. Na janela Opções de Geração de Pacote para Deploy, na opção Tipo de Artefato (destaque 2 da Figura 1), escolha a opção "Zip Front-end". Não será preciso habilitar a checkbox Dockerfile (3). No campo Endereço do servidor (4) adicione o endereço http://localhost:82/
configurado no war servidor. Após o download do pacote, descompacte os arquivos e adicione a pasta descompactada no diretório wsl, como mostra a imagem abaixo. Visto que a opção Dockerfile do pacote deploy não foi habilitada, o script run.sh não é incluído no pacote, para executar a aplicação localmente usaremos o ngnix.
Figura - Arquivos estáticos do zip front-end
Abra o terminal wsl, e instale e configure o Ngnix. Após a instalação, no arquivo de configuração do ngnix (ngnix.conf), será preciso adicionar a configuração do servidor que executará a aplicação. Para abrir o arquivo ngnix.conf e editá-lo, execute o comando abaixo:
Bloco de código | ||
---|---|---|
| ||
sudo nano /etc/nginx/nginx.conf |
Com o arquivo de configuração aberto, adicione o código abaixo dentro do bloco http do arquivo. Para mais informações de configuração, consulte a documentação oficial.
Bloco de código | ||
---|---|---|
| ||
server {
listen 84;
server_name localhost:84;
location / {
root /home/laila/zip-front-end;
index index.html;
}
} |
Por fim, execute o comando abaixo para reiniciar o serviço Nginx e aplicar as alterações:
Bloco de código | ||
---|---|---|
| ||
sudo systemctl restart nginx |
Para executar o projeto localmente, abra o navegador e informe o endereço com base na porta configurada no arquivo nginx.conf
: http://localhost:84/
. A imagem abaixo exibe a aplicação local na página inicial após o login.