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.
. Nginx é um servidor web de código aberto que também pode ser utilizado como proxy reverso, balanceador de carga HTTP e servidor de e-mail proxy. Além disso, o Nginx pode ser configurado como um servidor reverso para encaminhar solicitações para uma aplicação front-end.
Nos projetos Cronapp o arquivo Dockerfile pode ser criado ao gerar um Pacote para deploy, tornando a virtualização de uma aplicação Cronapp muito mais simples, bastando apenas descompactar o pacote deploy e executar os scripts run.bat
(utilizado para executar comandos no Windows ) ou run.sh
(utilizado para executar comandos em sistemas Linux) que acompanha o pacote.
Além disso, se você deseja apenas gerar um zip contendo os arquivos estáticos do front-end, pode executar a aplicação localmente usando o Nginx.
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. Para mais detalhes de instalação em sistemas Windows, consulte a documentação de referência.
- Docker e Ngnix instalado e configurado no WSL. O Nginx será utilizado apenas ao exportar o zip front-end, consulte o tópico correspondente para mais detalhes.
Projeto Cronapp criado. Caso haja dúvidas de como criar um projeto, acesse a documentação Criar projeto.
Recomendamos que o
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.
- Enviar uma imagem para um repositório de imagens Docker;
- Obter e executar uma imagem Docker a partir de um repositório de imagens;
- 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:
- Git instalado.
- Conhecimento básico sobre Docker.
- Docker Engine instalado e logado em seu registry, como o DockerHub.
- 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) e será necessário que o usuário tenha perfil Administrador (root) do sistema.
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.
Âncora | ||||
---|---|---|---|---|
|
Arquivo Dockerfile
Para construir uma imagem, o Docker utiliza as instruções contidas no arquivo Dockerfile. Ao exportar um Pacote de Deploy, é possível selecionar a opção Dockerfile (destaque 3 na Figura 1) e incluir esse arquivo junto com o pacote, permitindo construir uma imagem local ou executá-lo em um CI/CD pipeline.
Abaixo apresentamos como esse arquivo está configurado. Os comandos abaixo definem o ambiente e os arquivos que serão incluídos na imagem Docker para executar a aplicação desejada.
Bloco de código | ||||||
---|---|---|---|---|---|---|
| ||||||
FROM cronapp/runtime:1.0.0
#ADD fullchain.pem /etc/nginx/conf.d/fullchain.pem
#ADD privkey.pem /etc/nginx/conf.d/privkey.pem
ENV CRN_MEM="80"
ENV CRN_TIMEZONE="America/Fortaleza"
ENV CRN_GZIP="on"
ENV CRN_STATIC="false"
ENV CRN_SERVER_HOST=""
#ADD io.cronapp.apps.projetodeploy-1.0-SNAPSHOT.war /tmp/html.zip
#RUN unzip /tmp/html.zip -d /usr/share/nginx/html
ADD io.cronapp.apps.projetodeploy-1.0-SNAPSHOT.war /usr/local/tomcat/webapps/ROOT.war |
Dica |
---|
Ao exportar o pacote para Deploy via 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 demonstrará como executar os quatro tipos de opções disponíveis de Pacote para Deploy utilizando comandos no terminal WSL. Para mais informações sobre este recurso, consulte o tópico "Pacote para Deploy" da documentação Importar e exportar projetos.
War Completo
Para iniciar, acesse no menu do sistema Projeto > Exportar. Em seguida, selecione a opção Pacote para Deploy (destaque 1 da Figura 1). Na janela que exibir, escolha a opção "War Completo" no campo Tipo de Artefato (2) e habilite a checkbox do campo Dockerfile (3), conforme apresentado na imagem abaixo. Por fim, clique em "OK" para iniciar o download do pacote.
Âncora | ||||
---|---|---|---|---|
|
Image Added
Figura 1 - Janela Pacote para Deploy
Após concluir o download, extraia os arquivos da pasta .zip
para uma pasta descompactada, para este exemplo a nomeamos como "war-completo". Em seguida, adicionamos a pasta descompactada no diretório WSL do usuário, seguindo o caminho \\wsl.localhost\Ubuntu-20.04\home\<nome-do-usuário>
(Figura 1.1).
Além disso, vamos alterar a porta na qual o projeto local será executado. Por padrão, o script run.sh
(destaque 1 na Figura 1.1), contendo os comandos Docker, utiliza a porta 80 para a execução do projeto. No entanto, essa é a porta padrão utilizada pelo Ngnix. Portanto, vamos alterá-la para a porta 81. Para isso, abra o script run.sh
em um editor de texto e altere "80:80" para "81:80" (2). Por fim, salve as alterações.
Image Added
Figura 1.1 - Diretório wsl onde a pasta war-completo foi adicionada e edição do script run.sh
Após seguir esses passos, vamos executar o script run.sh
no terminal do WSL. No terminal, acesse o diretório que contém a pasta descompactada e execute o seguinte comando:
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.
Bloco de código | ||||
---|---|---|---|---|
| ||||
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.
Bloco de código | ||||
---|---|---|---|---|
| ||||
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.
Bloco de código | ||||
---|---|---|---|---|
| ||||
cd <novo-diretório> |
- <novo-diretório>: nome do diretório local criado no comando anterior.
Bloco de código | ||||
---|---|---|---|---|
| ||||
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.
Bloco de código | ||||
---|---|---|---|---|
| ||||
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".
Bloco de código | ||||
---|---|---|---|---|
| ||||
docker build --build-arg CONTEXT_USE=true -t tutorialcronapp/get_started:v0.01 . |
Executar
Por fim, rode a imagem Docker.
Bloco de código | ||||
---|---|---|---|---|
| ||||
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.
Bloco de código | ||||
---|---|---|---|---|
| ||||
dockersh 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.
Bloco de código | ||||
---|---|---|---|---|
| ||||
docker push <conta-registry>/<nome-imagem>:<tag> |
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>).
.sh |
Após executar o comando, você poderá abrir o projeto localmente no navegador usando o endereço com a porta configurada no script run.sh
: http://localhost:81/
. Na imagem abaixo, à direita, podemos ver a execução do projeto no terminal do WSL, e à esquerda, a execução do projeto local no endereço configurado (destaque 1 da Figura 1.2).
Image Added
Figura 1.2 - Execução do projeto local
War Separado
No passo anterior, executamos um pacote completo que integra tanto o back-end quanto o front-end. Agora, vamos apresentar como executar um pacote War Servidor e War Front-end separadamente.
Âncora | ||||
---|---|---|---|---|
|
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, a nomeamos como "war-servidor".
Abra o script run.sh
(destaque 1 da Figura 1.2) em um editor de texto para alterar a porta utilizada no script run.sh
de "80" para "82" (destaque 2) e salve as alterações.
Image Added
Figura 1.2 - Diretório wsl onde a pasta war-servidor foi adicionada e edição do script run.sh
Por fim, no terminal WSL, execute o comando abaixo.
<tag>: informe a versão da imagem usado no comando que usamos para rodar o DockerBloco de código | ||||
---|---|---|---|---|
| ||||
docker push tutorialcronapp/get_started:v0.01 |
sh run.sh |
Uma vez que estamos lidando apenas com o War Servidor, não é possível acessar a aplicação com interfaces web. Para isso, será necessário exportar o War Front-end e usar o endereço "http://localhost:82/
" conforme configurado no servidor. Consulte o tópico abaixo para obter 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, extraia os arquivos da pasta .zip
para uma pasta descompactada no diretório WSL, a nomeamos como "war-front-end". Abra o script run.sh
(destaque 1 da Figura 1.3) em um editor de texto para alterar a porta utilizada no script run.sh
de "80" para "83" (destaque 2) e salve as alterações.
Image Added
Figura 1.3 - Diretório wsl onde a pasta war-front-end foi adicionada e edição do arquivo run.sh
Por fim, execute, no terminal WSL, o comando abaixo
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.
Bloco de código | ||||
---|---|---|---|---|
| ||||
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
Bloco de código | ||||
---|---|---|---|---|
| ||||
docker pull tutorialcronapp/get_started:v0.01 |
Image Removed
Figura 2 - obtendo imagem do registry
Executar
Rode a imagem Docker.
Bloco de código | ||||
---|---|---|---|---|
| ||||
dockersh 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.
Bloco de código | ||||
---|---|---|---|---|
| ||||
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 Dockerfiler, 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 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 |
Detalhamento dos comandos por linha:
- #Comentário
- _
- 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.
- Instala o Maven, JAVA 11, NPM, GIT e o BASH.
- Define o diretório de trabalho
/app
. - Copia o arquivo
pom.xml
para o diretório/app
. - Redefine o protocolo de comunicação do endereço Git, alterando de "
git://
" para "https://
". - Define uma variável de nome
TIER
que representa o perfil do banco de dados da aplicação. - Define uma variável de nome
CONTEXT_USE
para indicar se deve incluir o arquivocontext.xml
com dados de conexão. (verificar aviso abaixo) - Define uma variável de nome
MOBILE_APP
para indicar se deve incluir o diretório da aplicação mobile. - _
- #Comentário: Os comandos da linha 16 até 18 são utilizados apenas para repositórios externos (JAR e NPM).
- #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.
- _
- #Comentário: Repositório externos.
- Obtém as dependências Maven para dentro do Docker.
- Copia todo o conteúdo do diretório atual (que contém os arquivos do projeto) para o diretório criado no comando 5.
- 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.
- _
- #Comentário: Repositório interno.
- Copia o arquivo
settings.xml
para o diretório$HOME/.m2/
- 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.
- Copia todo o conteúdo do diretório atual (que contém os arquivos do projeto) para o diretório criado no comando 5.
- 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.
- _
- Baixa uma imagem Tomcat 9.0.17 com o Java11 e inicia as próximas instruções.
- Por garantia, remove todo o conteúdo, caso exista, do diretório "
/usr/local/tomcat/webapps/
" na imagem do Tomcat. - 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. - 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. - Define o usuário do contêiner após subir o Docker.
Aviso | ||
---|---|---|
| ||
Cuidado ao definir a variável Maven "CONTEXT_USE" como "true", isso fará com que as configurações de banco de dados sejam armazenadas na imagem, gerando um alto risco em registry público. Recomendamos alterar essa opção para "false", porém será necessário usar recursos do orquestrador Docker, onde é possível informar as conexões de banco de dados necessárias ao contêiner/aplicação por meio de secrets. |
.sh |
Agora, com os projetos back-end e front-end em execução, você pode acessar as interfaces web localmente no navegador usando o endereço configurado no front-end: "http://localhost:83/
". A imagem a seguir, exibe a página inicial após login na aplicação no endereço destacado.
Image Added
Figura 1.4 - Execução do projeto local
Âncora | ||||
---|---|---|---|---|
|
Zip Front-end
Este pacote é uma versão compactada dos arquivos estáticos do front-end de uma aplicação web, que pode ser utilizado servindo diretamente ao Nginx. 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 baixar o pacote, descompacte os arquivos e adicione a pasta descompactada ao diretório do WSL, como exibido na Figura 1.5 nomeamos a pasta como "zip-front-end" (destaque 1). Como a opção Dockerfile não foi habilitada no pacote, o script run.sh
não está incluído. Para executar a aplicação localmente, vamos utilizar o Nginx. Abra o terminal WSL, e instale o Ngnix. Para detalhes de instalação e configuração, acesse a documentação de referência.
Image Added
Figura 1.5 - Arquivos estáticos do zip front-end
Para seguir boas práticas de desenvolvimento, vamos incluir a pasta descompactada "zip-front-end" no diretório var/www/html
do WSL. Por padrão, o WSL restringe a criação de diretórios ou alterações nas pastas do sistema de arquivos do Linux, como por exemplo a pasta /var
, fora do seu contexto. Por isso, todos os passos deste tópico serão executados via terminal WSL com o perfil de usuário root. Para isso, abra o terminal WSL e execute o comando abaixo e, em seguida, adicione sua senha de usuário.
Bloco de código | ||||
---|---|---|---|---|
| ||||
sudo su |
Se o diretório /var/www/htm
l ainda não foi criado, execute o comando abaixo. Caso contrário, você pode prosseguir para o próximo passo.
Bloco de código | ||||
---|---|---|---|---|
| ||||
mkdir -p /var/www/html |
Agora vamos copiar a pasta "zip-front-end", que contém os arquivos do pacote deploy, para o diretório /var/www/htm
l. para isso execute o comando abaixo, substituindo "<nome-da-pasta>" pelo caminho do seu diretório.
Bloco de código | ||||
---|---|---|---|---|
| ||||
cp -R <nome-da-pasta>/ /var/www/html |
Em seguida, vamos ajustar as permissões de leitura, escrita e execução para os diretórios dentro de /var/www/html
. Execute o comando abaixo para realizar essa configuração. Esse comando alterará as permissões para que o proprietário tenha permissão total e outros usuários tenham apenas permissão de leitura e execução.
Bloco de código | ||||
---|---|---|---|---|
| ||||
find /var/www/html -type d -exec chmod 755 {} \; |
Também será preciso ajustar as permissões de leitura e escrita para os arquivos dentro dos diretórios de /var/www/html
. Execute o comando abaixo para realizar a configuração. Esse comando modificará as permissões para que o proprietário tenha permissão de leitura e escrita, enquanto os outros usuários terão apenas permissão de leitura.
Bloco de código | ||||
---|---|---|---|---|
| ||||
find /var/www/html -type f -exec chmod 644 {} \; |
O comando abaixo é utilizado para alterar o proprietário de arquivos ou diretórios do WSL, onde o Nginx será definido como proprietário, garantindo as permissões adequadas para acessar e manipular os arquivos.
Bloco de código | ||||
---|---|---|---|---|
| ||||
chown -R www-data:www-data /var/www/html |
Para executar o projeto localmente, será preciso adicionar a configuração do servidor no arquivo de configuração ngnix.conf
do Ngnix. 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, substituindo "<nome-da-pasta>
" pelo nome utilizado no seu diretório. 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 /var/www/html/<nome-da-pasta>;
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.
Image Added
Figura 1.6 - Projeto executando localmente
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
.