Docker - ecosif-auth

Este documento explica como usar Docker para executar o ecosif-auth.

Pré-requisitos

Docker 20.10+
Docker Compose 2.0+

Dockerfile

O projeto inclui um Dockerfile multi-stage que:

Stage 1 (Build): Compila a aplicação usando Maven
Stage 2 (Runtime): Cria imagem final otimizada com apenas o JAR

Características do Dockerfile

Base: Amazon Corretto 17 (Alpine)
Multi-stage: Reduz tamanho final da imagem
Usuário não-root: Executa como usuário ecosif (segurança)
Health check: Incluído para monitoramento
Otimizações JVM: Configuradas para containers

Build da Imagem

Build Local

docker build -t ecosif-auth:latest .

Build com Tag Específica

docker build -t ecosif-auth:0.7.01.202511271 .

Docker Compose

docker-compose.yml

Crie um arquivo docker-compose.yml na raiz do projeto:

version: '3.8'

services:
  postgres:
    image: postgres:15
    container_name: ecosif-postgres
    environment:
      POSTGRES_DB: ${POSTGRES_DB:-ecosif}
      POSTGRES_USER: ${POSTGRES_USER:-postgres}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-postgres}
    ports:
      - "${POSTGRES_PORT:-5432}:5432"
    volumes:
      - postgres_data:/var/lib/postgresql/data
    networks:
      - ecosif-network
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER:-postgres}"]
      interval: 10s
      timeout: 5s
      retries: 5

  ecosif-auth:
    build:
      context: .
      dockerfile: Dockerfile
    container_name: ecosif-auth
    depends_on:
      postgres:
        condition: service_healthy
    environment:
      # Database
      - POSTGRES_HOST=postgres
      - POSTGRES_PORT=${POSTGRES_PORT:-5432}
      - POSTGRES_DB=${POSTGRES_DB:-ecosif}
      - POSTGRES_USER=${POSTGRES_USER:-postgres}
      - POSTGRES_PASSWORD=${POSTGRES_PASSWORD:-postgres}
      # Server
      - ECOSIF_AUTH_PORT=${ECOSIF_AUTH_PORT:-8080}
      # JWT
      - AUTH_TOKEN_SECRET=${AUTH_TOKEN_SECRET}
      - TOKEN_EXPIRATION=${TOKEN_EXPIRATION:-1800000}
      # OAuth2 (Opcional)
      - AUTH2_CLIENT_ID=${AUTH2_CLIENT_ID:-}
      - AUTH2_SECRET=${AUTH2_SECRET:-}
      # CORS
      - ECOSIF_CORS=${ECOSIF_CORS:-http://localhost:4200}
      # Flyway
      - ECOSIF_FLYWAY_ENABLED=${ECOSIF_FLYWAY_ENABLED:-true}
      # Hibernate
      - HIBERNATE_DDL_AUTO=${HIBERNATE_DDL_AUTO:-none}
      # Logging
      - LOG_FORMAT=${LOG_FORMAT:-default}
      - ECOSIF_LOGSHOW=${ECOSIF_LOGSHOW:-false}
      - ECOSIF_LOGMODE_ROOT=${ECOSIF_LOGMODE_ROOT:-INFO}
      - ECOSIF_LOGMODE_SPRING=${ECOSIF_LOGMODE_SPRING:-INFO}
      - ECOSIF_LOGMODE_HIBERNATE_SQL=${ECOSIF_LOGMODE_HIBERNATE_SQL:-INFO}
    ports:
      - "${ECOSIF_AUTH_PORT:-8080}:8080"
    networks:
      - ecosif-network
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8080/actuator/health"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 60s

volumes:
  postgres_data:

networks:
  ecosif-network:
    driver: bridge

Arquivo .env

Crie um arquivo .env na mesma pasta do docker-compose.yml:

# Database
POSTGRES_DB=ecosif
POSTGRES_USER=postgres
POSTGRES_PASSWORD=sua_senha_segura
POSTGRES_PORT=5432

# Server
ECOSIF_AUTH_PORT=8080

# JWT (OBRIGATÓRIO - gere uma chave segura)
AUTH_TOKEN_SECRET=$(openssl rand -base64 64)

# Token Expiration (30 minutos)
TOKEN_EXPIRATION=1800000

# OAuth2 (Opcional)
AUTH2_CLIENT_ID=
AUTH2_SECRET=

# CORS
ECOSIF_CORS=http://localhost:4200

# Flyway
ECOSIF_FLYWAY_ENABLED=true

# Hibernate
HIBERNATE_DDL_AUTO=none

# Logging
LOG_FORMAT=default
ECOSIF_LOGSHOW=false
ECOSIF_LOGMODE_ROOT=INFO
ECOSIF_LOGMODE_SPRING=INFO
ECOSIF_LOGMODE_HIBERNATE_SQL=INFO

Executando com Docker Compose

Iniciar Serviços

docker-compose up -d

Ver Logs

# Todos os serviços
docker-compose logs -f

# Apenas ecosif-auth
docker-compose logs -f ecosif-auth

# Apenas postgres
docker-compose logs -f postgres

Parar Serviços

docker-compose stop

Parar e Remover Contêineres

docker-compose down

Parar e Remover Tudo (incluindo volumes)

docker-compose down -v

Rebuild da Imagem

docker-compose build --no-cache
docker-compose up -d

Executando Container Individualmente

Executar Container

docker run -d \
  --name ecosif-auth \
  -p 8080:8080 \
  -e POSTGRES_HOST=host.docker.internal \
  -e POSTGRES_PORT=5432 \
  -e POSTGRES_DB=ecosif \
  -e POSTGRES_USER=postgres \
  -e POSTGRES_PASSWORD=senha \
  -e AUTH_TOKEN_SECRET=sua_chave_secreta_muito_longa \
  ecosif-auth:latest

Health Check

O container inclui health check configurado:

# Verificar status
docker ps

# Health check manual
docker exec ecosif-auth curl -f http://localhost:8080/actuator/health

Troubleshooting

Container não inicia

Verifique os logs: bash docker logs ecosif-auth
Verifique variáveis de ambiente: bash docker exec ecosif-auth env | grep POSTGRES
Verifique conectividade com banco: bash docker exec ecosif-auth ping postgres

Erro de conexão com banco

Verifique se o PostgreSQL está rodando: bash docker ps | grep postgres
Verifique se as credenciais estão corretas
Verifique se a rede está configurada corretamente: bash docker network inspect ecosif-network

Erro de migração Flyway

Verifique se o banco está acessível
Verifique logs do Flyway: bash docker logs ecosif-auth | grep flyway
Desabilite temporariamente Flyway para debug: bash ECOSIF_FLYWAY_ENABLED=false docker-compose up -d

Container reinicia constantemente

Verifique os logs: bash docker logs --tail 100 ecosif-auth
Verifique recursos (memória, CPU): bash docker stats ecosif-auth
Verifique health check: bash docker inspect ecosif-auth | grep Health -A 10

Volumes Persistentes

Dados do PostgreSQL

Os dados do PostgreSQL são persistidos em volume:

# Listar volumes
docker volume ls

# Inspecionar volume
docker volume inspect <nome-do-volume>

Backup do Banco

# Criar backup
docker exec ecosif-postgres pg_dump -U postgres ecosif > backup.sql

# Restaurar backup
docker exec -i ecosif-postgres psql -U postgres ecosif < backup.sql

Otimizações

Reduzir Tamanho da Imagem

O Dockerfile já está otimizado com multi-stage build. Para reduzir ainda mais:

Use .dockerignore para excluir arquivos desnecessários
Use Alpine Linux (já está usando)
Limpe cache do Maven após build

Performance

Ajuste recursos do container: yaml deploy: resources: limits: cpus: '2' memory: 2G reservations: cpus: '1' memory: 1G
Configure JVM para containers: bash JAVA_OPTS="-XX:+UseContainerSupport -XX:MaxRAMPercentage=75.0"

Produção

Recomendações para Produção

Use secrets: Não coloque senhas em variáveis de ambiente simples
HTTPS: Configure reverse proxy (nginx, traefik) com HTTPS
Monitoramento: Configure health checks e métricas
Backups: Configure backups automáticos do banco
Logs: Configure log aggregation (ELK, CloudWatch, etc.)
Resources: Defina limites de recursos
Rede: Use rede isolada
Tags: Use tags específicas (não latest)

Exemplo com Secrets

services:
  ecosif-auth:
    secrets:
      - db_password
      - jwt_secret

secrets:
  db_password:
    external: true
  jwt_secret:
    external: true