Estruturação do Ambiente de Build

Para gerenciar a implantação de uma arquitetura de microserviços baseada em Maven com múltiplos módulos, é essencial configurar o Jenkins para interagir diretamente com o daemon do Docker do host. Isso permite que o pipeline construa imagens e gerencie cotnainers de forma eficiente.

Configuração do Dockerfile

O arquivo Dockerfile abaixo foi proejtado para ser genérico, aceitando argumentos em tempo de build para definir o artefato JAR e a porta de exposição.

FROM openjdk:21-slim

# Argumentos para customização em tempo de build
ARG APP_FILE
ARG APP_PORT

# Definição do diretório de trabalho
WORKDIR /deploy

# Cópia do artefato gerado pelo Maven
COPY ${APP_FILE}.jar service-app.jar

# Exposição da porta dinâmica
EXPOSE ${APP_PORT}

# Inicialização da aplicação com parâmetros de ambiente
ENTRYPOINT ["java", "-jar", "-Duser.timezone=America/Sao_Paulo", "-Dfile.encoding=UTF-8", "service-app.jar", "--spring.profiles.active=prod"]

Orquestração com Docker Compose

O docker-compose.yml centraliza a rede e a definição dos serviços. No exemplo abaixo, utilizamos uma rede externa para garantir a comunicação entre diferentes stacks.

networks:
  backend_mesh:
    external: true

services:
  gateway-service:
    image: cloud-gateway:latest
    container_name: ms-gateway
    restart: unless-stopped
    ports:
      - "9301:9301"
    networks:
      backend_mesh:
        ipv4_address: 172.19.8.71

  auth-core:
    image: cloud-auth-core:latest
    container_name: ms-auth
    restart: unless-stopped
    ports:
      - "9304:9304"
    networks:
      backend_mesh:
        ipv4_address: 172.19.8.74

Configuração do Pipeline no Jenkins

Para tornar o processo flexível, utiliza-se a Construção Parametrizada. Isso permite que o operador escolha quais módulos deseja compilar e implantar individualmente.

Parâmetros de Build

Defina uma variável do tipo "Extended Choice Parameter" ou similar para listar os módulos (ex: base-modules/service-auth:9304). O Jenkins usará esses valores para processar o build via Shell Script.

Agendamento de Builds (Cron)

O Jenkins utiliza uma sintaxe baseada em Cron com a adição do símbolo H (Hash) para distribuir a carga no servidor.

• H/15 * * * *: Executa a cada 15 minutos.
• H 22 * * 1-5: Executa todas as noites de segunda a sexta às 22h.
• H 0 1 * *: Executa mensalmente no dia primeiro.

Comanods de Compilação Maven

Dependendo da necessidade, o comando de build pode variar entre o projeto completo ou módulos específicos:

# Build de módulos específicos selecionados via parâmetro
clean package -U -pl ${SELECTED_MODULES} -am -Dmaven.test.skip=true

# Build de toda a estrutura
clean package -U -Dmaven.test.skip=true

Automação via Shell Script

O script abaixo processa os parâmetros, remove containers antigos, constrói novas imagens e reinicia os serviços via Docker Compose.

#!/bin/bash
set -e

APP_PREFIX="my-project"

# Função para limpeza de recursos Docker
clear_docker_resource() {
    local target_name=$1
    if [ "$(docker ps -a -q -f name=${target_name})" ]; then
        echo "### Removendo container: ${target_name} ###"
        docker rm -f ${target_name}
    fi
}

# Processamento da lista de módulos
IFS=',' read -ra MODULE_LIST <<< "${base_modules}"

for entry in "${MODULE_LIST[@]}"; do
    # Extração de metadados do parâmetro
    module_path=$(echo "${entry%%:*}" | xargs)
    module_name=${module_path##*/}
    short_name=${module_path##*-}
    target_port=${entry##*:}
    
    container_id="${APP_PREFIX}-${short_name}"
    image_tag="${APP_PREFIX}-${module_name}"

    clear_docker_resource "$container_id"

    echo "### Iniciando Build da Imagem: ${image_tag} ###"
    docker build -t ${image_tag}:latest \
        --build-arg APP_FILE=./${module_path}/target/${module_name} \
        --build-arg APP_PORT=${target_port} .
done

echo "### Atualizando stack de containers ###"
docker-compose up -d
echo "### Deploy finalizado com sucesso ###"

Verificação

Após a execução do job no Jenkins, valide o status dos containers através do comando docker ps ou via logs do Docker Compose para garantir que todos os microserviços subiram corretamente na rede configurada.