Tutoriais de VPS
Spring Boot na VPS: JDK 25, memória JVM, systemd e Nginx
Implante Spring Boot com JDK 25 mantido, jar executável, limites JVM, systemd e Nginx HTTPS. Configure encerramento gracioso, imagens em camadas, saúde privada e rollback compatível com migrações.

Em relação aos guias de Node.js, Python e Go, Java merece um orçamento próprio de memória. A JVM usa heap e memória nativa: metadados, stacks, código compilado e buffers diretos. Reservar espaço de endereços não ocupa imediatamente a mesma quantidade de memória física; outros runtimes também têm overhead.
Este guia usa Ubuntu 24.04/26.04 e Spring Boot 4, builds fora da VPS, systemd e Nginx HTTPS. Dimensione e teste a aplicação real; falhas em máquinas pequenas não são inevitáveis.
Memória costuma importar, mas CPU, disco, pools e dependências externas também causam falhas.
| Uso | VPS inicial de exemplo | Condições |
|---|---|---|
| Uma aplicação Boot | 2 vCPU / 2 GB | Ponto inicial, não mínimo garantido |
| Aplicação e banco juntos | 4 vCPU / 4 GB | Orçamento separado para cada serviço |
| Várias JVMs | 4 vCPU / 8 GB+ | Cada processo tem overhead |
| Elasticsearch/dados | 8 GB+ | Exige avaliação própria |
O original ilustra por que 1 GB pode ficar apertado:
- 256–512 MB de heap;
- 200–400 MB fora do heap;
- 100–200 MB para sistema e SSH;
- dezenas de MB adicionais para Nginx.
Essas faixas são estimativas, não requisitos medidos. Deixe margem para picos e veja dimensionamento. Swap/ZRAM alivia pressão, mas não substitui capacidade suficiente.
As referências LTS são 17 (2021), 21 (2023) e 25 (setembro de 2025). A afirmação original de suporte universal até outubro de 2032 está incorreta: depende do distribuidor e dos termos. Oracle indica suporte Premier do JDK 25 até setembro de 2030 e Extended até setembro de 2033; isso não garante as mesmas datas para qualquer OpenJDK. Confira a política da distribuição.
sudo apt update
sudo apt install -y openjdk-25-jdk
java -version
Use apt-cache policy para confirmar openjdk-25-jdk nos repositórios habilitados e confiáveis da sua versão Ubuntu. Não presuma disponibilidade em todo Ubuntu/Debian nem que o 25.0.4 citado ainda esteja atualizado. Se não houver pacote, use uma distribuição mantida como Temurin com instalação e atualizações documentadas.
O original de setembro limitava Boot 4.1.1 a Java 17–26 e desaconselhava 27. Os requisitos oficiais consultados nesta edição descrevem Boot 4.1.2 compatível com Java 17–27. Confira a versão exata bloqueada e suas integrações.
- JDK 25 LTS é uma opção razoável com distribuidor que mantenha suporte.
- JDK 26 não é LTS; a janela de referência Oracle terminou em setembro de 2026.
- Avalie JDK 27 contra seu Boot real, não uma faixa antiga.
A VPS precisa do runtime Java; Maven/Gradle pode ficar no CI.
mvn package pode consumir bastante CPU/memória. Construa localmente ou no CI:
mvn clean package -DskipTests
# 产物
ls target/*.jar
-DskipTests pula testes explicitamente. Rode no CI os testes necessários para publicar esse artefato; o exemplo não comprova que eles foram executados.
Confira o jar Boot executável:
# 能直接跑(含内嵌 Tomcat 和全部依赖)
java -jar target/myapp-0.0.1.jar
# 检查有没有 Main-Class 和 Start-Class
unzip -p target/myapp-0.0.1.jar META-INF/MANIFEST.MF
Start-Class identifica a classe da aplicação; Main-Class escolhe o launcher Boot. Configure spring-boot-maven-plugin; um jar comum pode não ter launcher ou dependências.
GraalVM Native Image é outra opção. Confira requisitos Boot/GraalVM, incluindo a referência 25+ do original, e teste reflexão, proxies e metadados nativos. Custo e compatibilidade são diferentes; início em milissegundos e pouca memória são resultados específicos, não garantias.
O original registra estes valores ergonômicos:
MaxRAMPercentage = 25.0 # 最多用 25% 的内存做堆
InitialRAMPercentage = 1.5625 # 初始堆
MinRAMPercentage = 50.0
UseContainerSupport = true # 默认开启
São observações históricas, não medições repetidas nesta edição. Dependem de JDK, coletor, sistema e cgroup. Percentual controla heap, não o processo inteiro. Limites explícitos ou percentual validado com orçamento rígido de processo/contêiner podem funcionar.
Exemplo para 2 GB:
java \
-Xms512m -Xmx768m \
-XX:MaxMetaspaceSize=192m \
-XX:MaxDirectMemorySize=128m \
-Xss512k \
-XX:+ExitOnOutOfMemoryError \
-XX:+HeapDumpOnOutOfMemoryError \
-XX:HeapDumpPath=/srv/app/shared/dumps \
-jar app.jar
-Xms/-Xmxdefinem heap inicial/máximo. 512m/768m é um ponto inicial; igualar pode reduzir redimensionamentos, mas não é obrigatório.- Mantenha
-Xmxabaixo da capacidade total.-Xmxcom metade ou mais da máquina ainda pode deixar pouco espaço para memória nativa e outros serviços. -XX:MaxMetaspaceSizelimita Metaspace. Meça as classes reais: limite pequeno causa outro OOM; sem teto explícito, continua limitado pela memória disponível.-Xss512kreduz stack por thread; teste recursão e quantidade de threads para evitar StackOverflowError.-XX:+ExitOnOutOfMemoryErrorpermite sair em certos OutOfMemoryError e acionarRestart=always. Não evita OOM do kernel nem diagnostica a causa.-XX:+HeapDumpOnOutOfMemoryErrorgera dump sensível e potencialmente do tamanho do heap. Crie diretório privado gravável, reserve espaço e defina retenção. SIGKILL do kernel pode não deixar dump.
java -Xlog:gc -jar app.jar
# 启动日志第一行会打印 Using G1 / Using Serial
- G1 é comum em configurações de servidor adequadas.
- SerialGC pode reduzir overhead em heap pequeno; avalie
-XX:+UseSerialGCem 1–2 núcleos sem presumir que seja melhor.
Compare pausas e vazão com -Xlog:gc e tráfego representativo.
Salve /etc/systemd/system/myapp.service:
[Unit]
Description=Spring Boot App
After=network.target
[Service]
Type=simple
User=appuser
Group=appuser
WorkingDirectory=/srv/app/current
EnvironmentFile=/srv/app/shared/.env
ExecStart=/usr/bin/java \
-Xms512m -Xmx768m \
-XX:MaxMetaspaceSize=192m \
-XX:+ExitOnOutOfMemoryError \
-XX:+HeapDumpOnOutOfMemoryError \
-XX:HeapDumpPath=/srv/app/shared/dumps \
-Duser.timezone=Asia/Shanghai \
-Dspring.profiles.active=prod \
-jar /srv/app/current/app.jar
SuccessExitStatus=143
Restart=always
RestartSec=5
KillSignal=SIGTERM
TimeoutStopSec=30
StandardOutput=journal
StandardError=journal
SyslogIdentifier=myapp
MemoryMax=1500M
LimitNOFILE=65535
NoNewPrivileges=true
PrivateTmp=true
ProtectSystem=strict
ProtectHome=true
ReadWritePaths=/srv/app/shared
[Install]
WantedBy=multi-user.target
Crie appuser, releases/shared, destino current real e arquivo de ambiente modo 600 antes de iniciar. Separe dumps/uploads graváveis do código. A unidade não inclui todos os limites do comando JVM anterior: acrescente limites aprovados de memória direta/stack deliberadamente.
SuccessExitStatus=143aceita128+15, valor convencional de saída por SIGTERM; depende do processo e evita classificar essa saída como falha emsystemctl status.MemoryMax=1500Mdeve cobrir-Xmx, overhead nativo e margem, não igualar-Xmx.-Duser.timezone=Asia/Shanghaiseleciona Asia/Shanghai; substitua pela zona IANA necessária ou UTC. Oito horas é um caso regional, e o JDK normalmente inclui regras de fuso.WorkingDirectoryafetaconfig/application.ymlrelativo. Useshared/.envou caminhos externos explícitos para configuração real.
sudo systemctl daemon-reload
sudo systemctl enable --now myapp
sudo systemctl status myapp
Confira journalctl -u myapp -n 50 --no-pager e a lista systemd.
systemctl restart envia SIGTERM ao processo antigo. A documentação atual habilita encerramento gracioso por padrão nos servidores embutidos suportados; a afirmação de parada imediata do Boot 4 ficou desatualizada. Declare a política em application.yml:
server:
shutdown: graceful
spring:
lifecycle:
timeout-per-shutdown-phase: 20s
Os 20 segundos são por fase, não necessariamente total global. Deixe margem sob TimeoutStopSec para fases, workers e limpeza; aumente os 30 segundos do serviço se necessário. Reiniciar uma única instância ainda deixa uma janela sem listener.
Configure explicitamente a aplicação para escutar em 127.0.0.1, por exemplo SERVER_ADDRESS=127.0.0.1. Porta 8080 padrão não significa apenas loopback.
upstream springapp {
server 127.0.0.1:8080;
keepalive 32;
}
server {
listen 80;
listen [::]:80;
server_name app.example.com;
client_max_body_size 20m;
access_log /var/log/nginx/app.access.log;
error_log /var/log/nginx/app.error.log warn;
location / {
proxy_pass http://springapp;
proxy_http_version 1.1;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
proxy_set_header Connection "";
proxy_connect_timeout 5s;
proxy_read_timeout 60s;
}
}
sudo nginx -t && sudo systemctl reload nginx
Configure server.forward-headers-strategy para que request.getScheme() reflita HTTPS em vez de http:
server:
forward-headers-strategy: framework
Confie somente no proxy e mantenha o backend privado para impedir headers falsificados. Veja loops HTTPS. Configure Certbot após verificar DNS, portas e renovação, ou use Caddy. Portas baixas exigem privilégios/capabilities; o proxy evita concedê-los ao Java.
Camadas permitem reutilizar cache de dependências estáveis, sem garantir tempo específico de build:
FROM eclipse-temurin:25-jre AS builder
WORKDIR /app
COPY target/*.jar app.jar
RUN java -Djarmode=tools -jar app.jar extract --layers --destination extracted
FROM eclipse-temurin:25-jre
WORKDIR /app
RUN useradd -r -u 1001 appuser
COPY --from=builder /app/extracted/dependencies/ ./
COPY --from=builder /app/extracted/spring-boot-loader/ ./
COPY --from=builder /app/extracted/snapshot-dependencies/ ./
COPY --from=builder /app/extracted/application/ ./
USER appuser
ENTRYPOINT ["java", "-XX:MaxRAMPercentage=70", "-jar", "app.jar"]
COPY deve selecionar exatamente o jar executável previsto, e o pacote precisa incluir tools mode e índice de camadas. app.jar extraído referencia dependências extraídas; não é qualquer jar comum.
- Prefira
jremantido ajdkquando não compila;eclipse-temuriné uma opção. Economia de tamanho varia. -XX:MaxRAMPercentage=70exige limite--memoryreal ou equivalente Compose. Heap de 70% ainda pode deixar margem nativa insuficiente.- Preserve
USER appuser, segredos privados e mounts restritos. Sem root ajuda, mas não é isolamento completo. - Use versão/digest testado, não
latest.
Veja limites Compose e limpeza Docker.
Adicione Actuator:
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
management:
endpoints:
web:
exposure:
include: health,info
endpoint:
health:
show-details: never
Mantenha show-details: never salvo necessidade específica de operadores autenticados. Detalhes revelam componentes internos. Restrinja /actuator/: o proxy geral do original também o publica. Use location com bloqueio/404 antes do encaminhamento ou porta de gerenciamento privada separada com autorização. Verifique saúde local; systemd ativo não significa aplicação saudável.
- OOM: compare
-Xmxe memória nativa aos limites de processo/VPS, avalie-XX:MaxMetaspaceSizee use-XX:+ExitOnOutOfMemoryErrorpara erros JVM. Confira mortes pelo kernel comdmesg | grep -i oom. - Início lento: examine fases e reintentos para banco, Redis e APIs. Trinta segundos isoladamente não identificam a causa.
- Mudar configuração: ambiente/parâmetros podem sobrescrever
application.ymldo jar. Forneça produção porEnvironmentFile:
SPRING_DATASOURCE_URL=jdbc:postgresql://127.0.0.1:5432/appdb
SPRING_PROFILES_ACTIVE=prod
SPRING_DATASOURCE_URL corresponde a spring.datasource.url. Reinicie depois de editar o ambiente. -Dspring.profiles.active da unidade pode prevalecer sobre a variável do perfil; remova ou alinhe ao mudar.
- Memória não coletada: use
jcmd <pid> GC.heap_dumpcom ferramentas JDK e caminho privado, ou dump OOM. Examine caches/coleções sem limite, conexões e ThreadLocal. Swap não resolve vazamentos. - Logs lotam o disco: a saída de console vai para o journal:
sudo journalctl --vacuum-size=500M
sudo sed -i 's/^#\?SystemMaxUse=.*/SystemMaxUse=500M/' /etc/systemd/journald.conf
sudo systemctl restart systemd-journald
Vacuum remove logs arquivados; limites persistentes precisam de configuração efetiva. Prefira drop-in revisado e confira se sed realmente encontra a opção. Arquivos de log próprios exigem rotação separada.
Fluxo original:
#!/usr/bin/env bash
set -euo pipefail
HOST=deploy@your-vps
RELEASE=$(date +%Y%m%d-%H%M%S)
TARGET=/srv/app/releases/$RELEASE
# 1. 本地打包
mvn clean package -DskipTests
JAR=$(ls target/*.jar | grep -v original | head -1)
# 2. 传输
ssh "$HOST" "mkdir -p $TARGET"
scp "$JAR" "$HOST:$TARGET/app.jar"
# 3. 切换并重启
ssh "$HOST" "ln -sfn $TARGET /srv/app/current && sudo systemctl restart myapp"
# 4. 清理旧版本,保留最近 5 个
ssh "$HOST" "ls -1dt /srv/app/releases/* | tail -n +6 | xargs -r rm -rf"
grep -v original filtra o original gerado por spring-boot-maven-plugin: app.jar é reempacotado e app.jar.original o inicial. Se houver vários, selecione um artefato explícito verificado em vez de ls/head. Rode testes antes do build que os pula, preserve set -euo pipefail e não troque current após falha.
Guarde o destino anterior, faça backup de dados/segredos/uploads, confira hash e proprietário, troque e reinicie; depois valide commit ativo e saúde local/pública. Se falhar, restaure o destino e reinicie. Limpe somente após validar, mantendo artefatos ativo e de rollback. Migrações devem ser compatíveis: voltar jar não restaura dados nem garante disponibilidade imediata. Para continuidade, use duas instâncias com troca de proxy testada.
Veja PostgreSQL e Redis. Use 127.0.0.1 no mesmo host e túnel SSH quando necessário; consulte exposição de bancos.
O máximo habitual de 10 conexões do HikariCP é um padrão a revisar. Dimensione a soma dos pools de instâncias e demais clientes frente a max_connections, memória e carga real.
- RackNerd anual é uma opção a conferir; até o exemplo de 2 GB precisa de medição.
- Vultr oferece flexibilidade por hora; confira interrupção e migração de disco ao redimensionar.
- Contabo exige verificar E/S e preço de renovação.
- CN2 GIA da DMIT atende rotas da China continental, sem garantia de estabilidade ou velocidade mundial.
Ubuntu e Debian hospedam Java, mas confira openjdk-25-jdk e suporte na versão exata. Veja distribuições.
- Node.js para frontend/BFF;
- Go para comparar artefatos;
- Dimensionamento para orçamento JVM;
- Compose de produção para limites e rollback;
- Ensaios de recuperação para ir além do jar.