Pular para o conteúdo principal

Capítulo 1: Preparação para Produção

Introdução​

Antes de fazer o deploy, é preciso preparar sua aplicação. Este capítulo cobre empacotamento, perfis e gestão de configurações.

🎯 Objetivos do Capítulo​

Ao final deste capítulo, você saberá:

  1. ✅ Criar um JAR executável
  2. ✅ Configurar perfis Spring
  3. ✅ Externalizar a configuração
  4. ✅ Gerenciar secrets de forma segura
  5. ✅ Otimizar para produção

1. Empacotamento: JAR vs WAR​

JAR Executável (Recomendado)​

O Spring Boot cria um fat JAR contendo tudo:

# Build
mvn clean package

# Executar
java -jar target/myapp-1.0.0.jar

Vantagens:

  • ✅ Servidor Tomcat embarcado
  • ✅ Simples de fazer deploy
  • ✅ Portável
  • ✅ Perfeito para Docker

WAR (Servidor externo)​

Para fazer deploy em Tomcat/JBoss existente:

<!-- pom.xml -->
<packaging>war</packaging>

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-tomcat</artifactId>
        <scope>provided</scope>
    </dependency>
</dependencies>
// Modificar a classe principal
@SpringBootApplication
public class Application extends SpringBootServletInitializer {
    
    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
        return builder.sources(Application.class);
    }
    
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

Recomendação​

JAR para:
- Docker / Kubernetes
- Cloud (Heroku, Railway, AWS)
- Microsserviços

WAR para:
- Infraestrutura legada
- Servidores de aplicação existentes

2. Perfis Spring​

Definir Perfis​

src/main/resources/
├── application.properties          # Configuração comum
├── application-dev.properties      # Desenvolvimento
├── application-prod.properties     # Produção
└── application-test.properties     # Testes

application.properties (comum)​

spring.application.name=myapp
server.port=8080

# Perfil padrão
spring.profiles.active=dev

application-dev.properties​

# Banco de dados H2 em memória
spring.datasource.url=jdbc:h2:mem:devdb
spring.datasource.driver-class-name=org.h2.Driver
spring.h2.console.enabled=true

# JPA
spring.jpa.hibernate.ddl-auto=create-drop
spring.jpa.show-sql=true

# Logging verboso
logging.level.com.myapp=DEBUG
logging.level.org.hibernate.SQL=DEBUG

# Actuator: tudo exposto em dev
management.endpoints.web.exposure.include=*

application-prod.properties​

# PostgreSQL em produção
spring.datasource.url=${DATABASE_URL}
spring.datasource.username=${DB_USERNAME}
spring.datasource.password=${DB_PASSWORD}

# JPA
spring.jpa.hibernate.ddl-auto=validate
spring.jpa.show-sql=false

# Logging mínimo
logging.level.root=WARN
logging.level.com.myapp=INFO

# Actuator: seguro
management.endpoints.web.exposure.include=health,info,prometheus
management.endpoint.health.show-details=when_authorized

# Segurança
server.error.include-stacktrace=never

Ativar um Perfil​

# Via argumento JVM
java -jar myapp.jar --spring.profiles.active=prod

# Via variável de ambiente
export SPRING_PROFILES_ACTIVE=prod
java -jar myapp.jar

# Via Docker
docker run -e SPRING_PROFILES_ACTIVE=prod myapp

3. Configuração Externalizada​

Ordem de Prioridade​

O Spring Boot carrega a configuração nesta ordem (prioridade crescente):

1. application.properties (dentro do JAR)
2. application-{profile}.properties (dentro do JAR)
3. application.properties (fora do JAR)
4. application-{profile}.properties (fora do JAR)
5. Variáveis de ambiente
6. Argumentos de linha de comando

Variáveis de Ambiente​

# application.properties
spring.datasource.url=${DATABASE_URL:jdbc:h2:mem:default}
spring.datasource.username=${DB_USER:sa}
spring.datasource.password=${DB_PASS:}
# Definir as variáveis
export DATABASE_URL=jdbc:postgresql://localhost:5432/mydb
export DB_USER=myuser
export DB_PASS=secret

java -jar myapp.jar

Configuração YAML (alternativa)​

# application.yml
spring:
  application:
    name: myapp
  profiles:
    active: dev

---
spring:
  config:
    activate:
      on-profile: dev
  datasource:
    url: jdbc:h2:mem:devdb
  h2:
    console:
      enabled: true

---
spring:
  config:
    activate:
      on-profile: prod
  datasource:
    url: ${DATABASE_URL}
    username: ${DB_USERNAME}
    password: ${DB_PASSWORD}

4. Gestão de Secrets​

❌ Nunca Faça​

# NUNCA no código fonte!
spring.datasource.password=MySecretPassword123
api.key=sk-1234567890abcdef

✅ Boas Práticas​

Opção 1: Variáveis de Ambiente​

export DB_PASSWORD=secret
export API_KEY=sk-xxx

Opção 2: Arquivo .env (apenas local)​

# .env (adicione ao .gitignore!)
DATABASE_URL=jdbc:postgresql://localhost:5432/mydb
DB_PASSWORD=secret
API_KEY=sk-xxx

Opção 3: Secrets Managers​

# Kubernetes Secret
apiVersion: v1
kind: Secret
metadata:
  name: myapp-secrets
type: Opaque
data:
  db-password: c2VjcmV0  # base64

Opção 4: Spring Cloud Config​

# Para secrets centralizados
spring:
  cloud:
    config:
      uri: http://config-server:8888

.gitignore​

# Secrets
.env
*.pem
*.key
application-local.properties
secrets/

5. Otimizações para Produção​

Configuração JVM​

# Production JVM settings
java -Xms512m -Xmx1024m \
     -XX:+UseG1GC \
     -XX:MaxGCPauseMillis=200 \
     -Djava.security.egd=file:/dev/./urandom \
     -jar myapp.jar

application-prod.properties​

# Compressão de respostas
server.compression.enabled=true
server.compression.mime-types=application/json,text/html,text/css
server.compression.min-response-size=1024

# Connection pool otimizado
spring.datasource.hikari.maximum-pool-size=20
spring.datasource.hikari.minimum-idle=5
spring.datasource.hikari.idle-timeout=300000

# Cache de templates
spring.thymeleaf.cache=true

# Desabilitar features de dev
spring.devtools.restart.enabled=false
spring.h2.console.enabled=false

Graceful Shutdown​

# Esperar o fim das requisições em andamento
server.shutdown=graceful
spring.lifecycle.timeout-per-shutdown-phase=30s

6. Build para Produção​

Maven​

# Build com perfil prod
mvn clean package -Pprod -DskipTests

# Ou com o perfil Spring
mvn clean package -Dspring.profiles.active=prod

pom.xml - Perfis Maven​

<profiles>
    <profile>
        <id>dev</id>
        <activation>
            <activeByDefault>true</activeByDefault>
        </activation>
        <properties>
            <spring.profiles.active>dev</spring.profiles.active>
        </properties>
    </profile>
    
    <profile>
        <id>prod</id>
        <properties>
            <spring.profiles.active>prod</spring.profiles.active>
        </properties>
    </profile>
</profiles>

<build>
    <resources>
        <resource>
            <directory>src/main/resources</directory>
            <filtering>true</filtering>
        </resource>
    </resources>
</build>

Verificar o JAR​

# Conteúdo do JAR
jar tf target/myapp-1.0.0.jar

# Testar localmente
java -jar target/myapp-1.0.0.jar --spring.profiles.active=prod

7. Resumo​

Checklist Produção​

□ JAR executável criado
□ Perfis configurados (dev, prod, test)
□ Secrets externalizados (não no código)
□ Variáveis de ambiente documentadas
□ Logging configurado (não DEBUG em prod)
□ Actuator seguro
□ Compressão ativada
□ Connection pool configurado
□ Graceful shutdown ativado

Arquivos de Configuração​

application.properties        → Configuração comum
application-dev.properties    → H2, DEBUG, tudo exposto
application-prod.properties   → PostgreSQL, WARN, seguro
application-test.properties   → H2, para testes

Variáveis Essenciais​

SPRING_PROFILES_ACTIVE=prod
DATABASE_URL=jdbc:postgresql://...
DB_USERNAME=myuser
DB_PASSWORD=secret
SERVER_PORT=8080

🎯 Próximo Passo​

A aplicação está pronta. Agora, vamos conteinerizá-la com Docker!

➡️ Capítulo 2: Conteinerização Docker

⬅️ Voltar ao Módulo 12