Guia Passo a Passo: Deploy de uma API REST Java no Docker

Introdução
O Docker é uma ferramenta poderosa que simplifica o processo de empacotar, distribuir e executar aplicativos em contêineres. Neste guia, vamos explorar como fazer o deploy de uma API REST Java em um contêiner Docker.

Pré-requisitos
• JDK instalado
• Maven instalado
• Docker instalado
• Conta no Docker Hub
• Intellij ou uma IDEA de sua preferência (no exemplo será utilizado Intellij).
Conhecimento básico do Docker e do Docker Compose.

Se gostou do artigo, lhe serviu deixe um like ou um comentário, é sempre bom saber, obrigado e até logo.

Passo 1: Criando o repositório Docker Hub

Acesse o site: https://hub.docker.com/
Caso não possua, crie uma conta o processo é bem simples, após criar a conta, siga os passos abaixo:

Quanto a regra de criação do nome do repositório: O nome do seu repositório deve conter uma combinação de caracteres alfanuméricos e pode conter os caracteres especiais ., _ ou -. As letras devem ser minúsculas.

Clique em Create e após isso, verá essa tela:

Dê atenção ao destaque em vermelho, ali terá o seu nome de usuário no meu caso: diegobr e o nome do repositório: dockerapirest
Grave essas duas informações, pois iremos utilizá-la a seguir.

Passo 2: Preparando o Projeto
Certifique-se de ter um projeto Java Spring Boot pronto para ser empacotado. Se você ainda não tem um, pode criar um rapidamente usando o Spring Initializer.
Recomendo usar essas dependências para melhor didática, será necessário para o teste mais a frente:

Você, pode iniciar um do zero: https://start.spring.io/
Ou você pode usar o exemplo do artigo, acessando aqui: https://github.com/diegoSbrandao/Deploy-Docker-Exemplo

Abra o pom.xml e vá até o final em plugins, conforme imagem abaixo, você irá adicionar esse trecho de código:

IMPORTANTE: Na linha 16 você deve alterar, para o nome do seu usuário e nome do seu repositório no Docker Hub.

           <plugin>
                <groupId>com.spotify</groupId>
                <artifactId>dockerfile-maven-plugin</artifactId>
                <version>1.4.13</version>
                <executions>
                    <execution>
                        <id>default</id>
                        <goals>
                            <goal>build</goal>
                            <goal>push</goal>
                        </goals>
                    </execution>
                </executions>
                <configuration>
                    <useMavenSettingsForAuth>true</useMavenSettingsForAuth>
                    <repository>diegobr/dockerapirest</repository>
                    <tag>${project.version}</tag>
                    <buildArgs>
                        <JAR_FILE>${project.build.finalName}.jar</JAR_FILE>
                    </buildArgs>
                </configuration>
            </plugin>

A princípio ficará assim seu pom.

Explicação de cada linha da configuração do plugin:

Declaração do plugin

A tag declara o uso do plugin dockerfile-maven-plugin. Ela fornece as seguintes informações:
groupId: com.spotify - Identifica o fornecedor do plugin, Spotify.
artifactId: dockerfile-maven-plugin - Identifica o artefato do plugin, dockerfile-maven-plugin.
version: 1.4.13 - Especifica a versão do plugin, 1.4.13.

Execução do plugin
A tag define as fases e metas de execução do plugin. Neste caso, há uma única execução com o ID default. Ela executa duas metas:

build: Constrói a imagem Docker usando o Dockerfile especificado no projeto.
push: Envia a imagem Docker construída para o repositório especificado.

Configuração do plugin
A tag define os parâmetros de configuração do plugin. Ela inclui as seguintes configurações:
useMavenSettingsForAuth: true - Indica que as credenciais de autenticação devem ser recuperadas do arquivo Maven settings.xml.
repository: seu nome/nome repositorio - Especifica o repositório Docker Hub para onde a imagem será enviada.

tag: {project.version}\ - Define a tag da imagem Docker para a versão atual do projeto. 4. buildArgs: JAR_FILE={project.build.finalName}.jar- Define um argumento de build chamadoJAR_FILE que define o valor para o nome do arquivo JAR gerado pela compilação do projeto. Este argumento é usado no Dockerfile para especificar o arquivo JAR a ser incluído na imagem.

Passo 3: Dockerfile

Na raiz do projeto crie o arquivo Dockerfile, lembrando ele deve ter exatamente este nome e NENHUMA extensão.
Existe várias formas de cria-lo, eu deixo a abaixo uma delas:

Com o arquivo Dockerfile criado, vamos usar a configuração para subirmos nossa imagem:

FROM eclipse-temurin:17-jdk-alpine
RUN mkdir app
ARG JAR_FILE
ADD /target/${JAR_FILE} /app/spring-docker-spotify.jar
WORKDIR /app
ENTRYPOINT java -jar spring-docker-spotify.jar

Explicação:
--FROM eclipse-temurin:17-jdk-alpine
Esta linha especifica a imagem base para o contêiner Docker. A imagem eclipse-temurin:17-jdk-alpine é um ambiente de execução Java leve baseado no OpenJDK 17 e no Alpine Linux.

-- RUN mkdir app
Esta linha cria um diretório chamado app dentro do contêiner. Este diretório será usado para armazenar os arquivos do aplicativo.

-- ARG JAR_FILE
Esta linha define um argumento chamado JAR_FILE. O valor deste argumento será especificado ao construir a imagem Docker.

-- ADD /target/${JAR_FILE} /app/spring-docker-spotify.jar
Esta linha copia o arquivo JAR do diretório target para o diretório app no contêiner. O argumento JAR_FILE é usado para especificar o nome do arquivo JAR.

-- WORKDIR /app
Esta linha define o diretório de trabalho para o contêiner como o diretório app. Isso significa que quando o contêiner for iniciado, quaisquer comandos executados serão executados a partir do diretório app.

-- ENTRYPOINT java -jar spring-docker-spotify.jar

Esta linha define o ponto de entrada para o contêiner. O entrypoint é o comando que será executado quando o contêiner for iniciado. Neste caso, o entrypoint é o comando java, que é usado para executar o arquivo JAR. A opção -jar especifica que o comando java deve executar um arquivo JAR. O argumento spring-docker-spotify.jar especifica o nome do arquivo JAR a ser executado.

Passo 4: Criando a imagem.
Importante tenha logado no Docker Desktop.

Antes de criarmos, considere alterar a versão da aplicação do pom, conforme exemplo abaixo:

Agora iremos empacotar e criar nossa imagem, no terminal da raiz do projeto onde estão pom.xml, use o comando: mvn package

Se tudo ocorrer conforme esperado, terá esse resultado no console:

Utilize o comando: docker images, deve aparecer conforme abaixo, sua imagem:

Agora, vamos subir a imagem para o Docker Hub no passo 5.

Passo 5: Subindo imagem no Docker Hub

Para subir sua imagem você irá utilizar os comandos abaixo:

docker tag nome-da-imagem:tag nome-do-usuario/nome-do-repositorio:tag

docker push nome-do-usuario/nome-do-repositorio:tag

Exemplificando, no caso do exemplo o meu ficará assim:

docker tag diegobr/dockerapirest:1.0.0 diegobr/dockerapirest:tag
informação como pode ver retiradas daqui.

Após incluir o comando acima:

Nada será mostrado, isto é normal e esperado.

E agora damos o comando de push:
docker push diegobr/dockerapirest:1.0.0

Após o comando a imagem será montada e enviada.

Vá ao seu repositório e escolhe a opção Tag:

Você verá o número da tag que criou e o pull da sua imagem Docker.

Passo 6: Testando spring actuator.

Para testar, apaguei toda a imagem que tinha da api, conforme imagem abaixo:

E vou utilizar a imagem que subi para testar, para isso: simplesmente copiamos o Docker pull conforme destaque em vermelho, no caso estou utilizando o bash do git, mas pode ser qualquer terminal.

Imagem baixada e agora vamos testar:

Utilize o comando abaixo para rodar a imagem:

docker run -p 8080:8080 diegobr/dockerapirest:1.0.0

Agora, abrimos um navegador ou use postman ou insomnia, caso prefira, e utilize esse endereço: http://localhost:8080/actuator/health
Conforme, pode ver na imagem a aplicação foi deploy no Docker com sucesso.

Se seguiu até aqui, meu muito obrigado, se gostou do artigo, lhe serviu deixe um like ou um comentário, é sempre bom saber, obrigado e até logo.