Tutoriales de VPS
Spring Boot en una VPS: JDK 25, memoria JVM, systemd y Nginx
Despliegue Spring Boot con JDK 25 mantenido, jar ejecutable, límites JVM, systemd y Nginx HTTPS. Configure apagado ordenado, imágenes por capas, salud privada y reversión compatible con migraciones.

Frente a las guías de Node.js, Python y Go, Java necesita un presupuesto de memoria propio. La JVM usa heap y memoria nativa: metadatos, stacks, código compilado y buffers directos. Reservar espacio de direcciones no equivale a ocupar toda esa memoria física; los demás runtimes también tienen sobrecarga.
Esta guía usa Ubuntu 24.04/26.04 y Spring Boot 4, builds fuera de la VPS, systemd y Nginx HTTPS. Dimensione y pruebe el proyecto real; una máquina pequeña no falla necesariamente.
La memoria suele importar, pero CPU, disco, pools y dependencias externas también causan problemas.
| Uso | VPS inicial de ejemplo | Condiciones |
|---|---|---|
| Una aplicación Boot | 2 vCPU / 2 GB | Punto inicial, no mínimo garantizado |
| Aplicación y base juntas | 4 vCPU / 4 GB | Presupuestar ambos servicios |
| Varias JVM | 4 vCPU / 8 GB+ | Cada una tiene sobrecarga |
| Elasticsearch/datos | 8 GB+ | Evaluación independiente |
El original explica la dificultad de 1 GB con:
- 256–512 MB de heap;
- 200–400 MB fuera del heap;
- 100–200 MB de sistema y SSH;
- decenas de MB adicionales para Nginx.
Son estimaciones, no requisitos medidos. Deje margen para picos y consulte dimensionamiento. Swap/ZRAM amortigua presión, pero no sustituye capacidad suficiente.
Las referencias LTS son 17 (2021), 21 (2023) y 25 (septiembre de 2025). La afirmación original de soporte universal hasta octubre de 2032 es incorrecta: depende de proveedor y condiciones. Oracle indica soporte Premier de JDK 25 hasta septiembre de 2030 y Extended hasta septiembre de 2033; no garantiza esas fechas para cualquier OpenJDK. Revise el mantenimiento de su distribución.
sudo apt update
sudo apt install -y openjdk-25-jdk
java -version
Compruebe primero con apt-cache policy que openjdk-25-jdk existe en repositorios habilitados y confiables para su Ubuntu. No presuponga que todos los Ubuntu/Debian lo incluyen ni que 25.0.4 del original siga actualizado. Si falta, use una distribución mantenida como Temurin con instalación y actualizaciones documentadas.
El original de septiembre limitaba Boot 4.1.1 a Java 17–26 y rechazaba 27. Los requisitos oficiales consultados para esta edición describen Boot 4.1.2 compatible con Java 17–27. Compruebe la versión exacta bloqueada y sus integraciones.
- JDK 25 LTS es una opción razonable con distribuidor que mantenga soporte.
- JDK 26 no es LTS; el período de referencia Oracle acabó en septiembre de 2026.
- Evalúe JDK 27 frente a su Boot concreto, no una tabla antigua.
La VPS necesita el runtime Java; Maven/Gradle puede quedarse en CI.
mvn package puede consumir memoria y CPU considerables. Construya localmente o en CI:
mvn clean package -DskipTests
# 产物
ls target/*.jar
-DskipTests omite pruebas expresamente. Ejecute en CI las pruebas necesarias para publicar ese artefacto; el ejemplo no prueba que se hayan ejecutado.
Inspeccione el jar Boot ejecutable:
# 能直接跑(含内嵌 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 la clase de aplicación; Main-Class selecciona el launcher Boot. Configure spring-boot-maven-plugin; un jar normal puede carecer de launcher o dependencias.
GraalVM Native Image es otra vía. Revise requisitos Boot/GraalVM, incluida la referencia 25+ del original, y pruebe reflexión, proxies y metadatos nativos. El coste y la compatibilidad cambian; inicio en milisegundos y poca memoria son resultados específicos, no garantías.
El original registra estos valores ergonómicos:
MaxRAMPercentage = 25.0 # 最多用 25% 的内存做堆
InitialRAMPercentage = 1.5625 # 初始堆
MinRAMPercentage = 50.0
UseContainerSupport = true # 默认开启
Son observaciones históricas, no mediciones repetidas en esta edición. Dependen de JDK, recolector, sistema y cgroup. El porcentaje limita heap, no todo el proceso. Puede usar límites explícitos o un porcentaje validado con presupuesto duro del proceso/contenedor.
Ejemplo 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/-Xmxfijan heap inicial/máximo. 512m/768m es un punto de partida; igualarlos puede reducir cambios de tamaño, pero no es obligatorio.- Mantenga
-Xmxpor debajo del total.-Xmxigual a la mitad o más de la máquina aún puede dejar poco margen para memoria nativa y otros servicios. -XX:MaxMetaspaceSizelimita Metaspace. Mida las clases reales: un límite pequeño provoca su propio OOM y sin límite sigue restringido por memoria disponible.-Xss512kreduce stack por hilo; pruebe recursión y cantidad de hilos para evitar StackOverflowError.-XX:+ExitOnOutOfMemoryErrorpermite salir por ciertos OutOfMemoryError y activarRestart=always. No evita el OOM del kernel ni diagnostica su causa.-XX:+HeapDumpOnOutOfMemoryErrorcrea un dump sensible y potencialmente tan grande como el heap. Prepare directorio privado escribible, espacio y retención. SIGKILL del kernel puede no dejar dump.
java -Xlog:gc -jar app.jar
# 启动日志第一行会打印 Using G1 / Using Serial
- G1 es frecuente en configuraciones servidor adecuadas.
- SerialGC puede reducir sobrecarga con heap pequeño; evalúe
-XX:+UseSerialGCcon 1–2 núcleos, sin darlo por mejor.
Compare pausas y rendimiento con -Xlog:gc y tráfico representativo.
Guarde /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
Cree appuser, releases/shared, destino current real y variables modo 600 antes de iniciar. Separe dumps/subidas escribibles del código. La unidad no incluye todos los límites del comando JVM anterior: añada límites aprobados de memoria directa/stack deliberadamente.
SuccessExitStatus=143acepta128+15, un valor convencional de salida por SIGTERM; depende del proceso, y evita clasificar esa salida como fallo ensystemctl status.MemoryMax=1500Mdebe cubrir-Xmx, memoria nativa y margen, no igualar-Xmx.-Duser.timezone=Asia/Shanghaielige Asia/Shanghai; cambie por la zona IANA necesaria o UTC. Ocho horas es un caso regional; JDK normalmente incluye reglas horarias.WorkingDirectoryafectaconfig/application.ymlrelativo. Useshared/.envo rutas externas explícitas para configuración real.
sudo systemctl daemon-reload
sudo systemctl enable --now myapp
sudo systemctl status myapp
Revise journalctl -u myapp -n 50 --no-pager y la lista systemd.
systemctl restart envía SIGTERM al proceso antiguo. La documentación actual activa apagado ordenado por defecto en servidores embebidos compatibles; la afirmación de cierre inmediato de Boot 4 quedó obsoleta. Declare la política en application.yml:
server:
shutdown: graceful
spring:
lifecycle:
timeout-per-shutdown-phase: 20s
Los 20 segundos son por fase, no necesariamente total global. Deje margen bajo TimeoutStopSec para todas las fases, workers y limpieza; aumente los 30 segundos del servicio si hace falta. Reiniciar una instancia todavía deja un intervalo sin escucha.
Fije explícitamente el enlace de la aplicación a 127.0.0.1, por ejemplo SERVER_ADDRESS=127.0.0.1. El puerto 8080 por defecto no significa loopback solamente.
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() refleje HTTPS y no http:
server:
forward-headers-strategy: framework
Confíe solo en el proxy y mantenga el backend privado para impedir cabeceras falsificadas. Véase bucles HTTPS. Configure Certbot después de revisar DNS, puertos y renovación, o use Caddy. Los puertos bajos requieren privilegios/capacidades; el proxy evita dárselos a Java.
Las capas reutilizan caché de dependencias sin cambios; no garantizan tiempo concreto 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 debe seleccionar exactamente el jar ejecutable previsto y el paquete debe incluir tools mode e índice de capas. El app.jar extraído referencia dependencias externas extraídas, no es cualquier jar ordinario.
- Prefiera
jremantenido ajdksi no compila;eclipse-temurines una opción. El ahorro de tamaño varía. -XX:MaxRAMPercentage=70necesita un límite--memoryreal o equivalente Compose. El 70% de heap aún puede dejar margen nativo insuficiente.- Mantenga
USER appuser, secretos privados y montajes restrictivos. Sin root ayuda, pero no es aislamiento completo. - Use versión/digest probado, no
latest.
Consulte límites Compose y limpieza Docker.
Añada 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
Conserve show-details: never salvo necesidad concreta de operadores autenticados. Los detalles revelan componentes internos. Restrinja /actuator/: el proxy general del original también lo publica. Use una ubicación que deniegue/devuelva 404 antes del reenvío, o un puerto de gestión privado separado con autorización. Revise salud local; systemd activo no equivale a aplicación sana.
- OOM: compare
-Xmxmás uso nativo con límites de proceso/VPS, evalúe-XX:MaxMetaspaceSizey use-XX:+ExitOnOutOfMemoryErrorpara errores JVM. Busque muertes del kernel condmesg | grep -i oom. - Inicio lento: revise fases y reintentos a base, Redis o API externa. Treinta segundos por sí solos no indican causa.
- Cambiar configuración: variables/parámetros pueden sobrescribir
application.ymldel jar. Suministre producción medianteEnvironmentFile:
SPRING_DATASOURCE_URL=jdbc:postgresql://127.0.0.1:5432/appdb
SPRING_PROFILES_ACTIVE=prod
SPRING_DATASOURCE_URL corresponde a spring.datasource.url. Reinicie tras editar variables. -Dspring.profiles.active en la unidad puede prevalecer sobre la variable del perfil; elimínelo o alinéelo al cambiar.
- Memoria no recuperada: use
jcmd <pid> GC.heap_dumpcon herramientas JDK y destino privado, o dump OOM. Revise cachés/colecciones sin límite, conexiones y ThreadLocal. Swap no repara fugas. - Logs llenan disco: la consola pasa al journal:
sudo journalctl --vacuum-size=500M
sudo sed -i 's/^#\?SystemMaxUse=.*/SystemMaxUse=500M/' /etc/systemd/journald.conf
sudo systemctl restart systemd-journald
Vacuum borra logs archivados; el límite persistente necesita ajuste efectivo. Prefiera un drop-in revisado y confirme que sed realmente encuentra la opción. Los logs propios requieren rotación aparte.
Flujo 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 el original emitido por spring-boot-maven-plugin: app.jar es el jar reempaquetado y app.jar.original el inicial. Si hay varios, elija uno explícito comprobado en lugar de ls/head. Ejecute pruebas antes del build que las omite, conserve set -euo pipefail y no cambie current tras fallar.
Guarde el destino anterior, copie datos/secretos/subidas, compruebe hash y propietario, cambie y reinicie, después valide commit activo y salud local/pública. Si falla, restaure el destino y reinicie. Limpie solo tras validar, reteniendo artefactos activo y anterior. Migraciones deben ser compatibles: revertir jar no restaura datos ni garantiza disponibilidad inmediata. Para continuidad, use dos instancias con cambio de proxy probado.
Consulte PostgreSQL y Redis. Use 127.0.0.1 en el mismo host y túnel SSH si hace falta; véase exposición de bases.
El máximo habitual de 10 conexiones de HikariCP es un valor a revisar. Dimensione la suma de pools de todas las instancias y otros clientes frente a max_connections, memoria y carga.
- RackNerd anual es una opción a verificar; incluso el ejemplo 2 GB necesita medición.
- Vultr ofrece flexibilidad por horas; revise interrupción y migración de disco al ampliar.
- Contabo requiere comprobar E/S y precio de renovación.
- CN2 GIA de DMIT responde a rutas de China continental, sin garantía de estabilidad o velocidad mundial.
Ubuntu y Debian alojan Java, pero compruebe openjdk-25-jdk y su soporte en la versión concreta. Véase distribuciones.
- Node.js para frontend/BFF;
- Go para comparar artefactos;
- Dimensionamiento para memoria JVM;
- Compose de producción para límites y reversión;
- Ensayos de recuperación para ir más allá del jar.