Global66 · célula Account · benchmark ·

ms-mfa en Java, Go y Rust

● = mejor de los cuatro. Mismo flujo, misma base, mismo contenedor: 1 vCPU y 512 MB por servicio, uno a la vez.

Java 25 frente a Java 17

Se repitió todo con Corretto 25 (25.0.4, LTS): mismo JAR fuente, misma configuración, mismas opciones de JVM. Solo cambia el JDK de build y de runtime.

Actualizar el JDK sin tocar nada más da una mejora chica y consistente en el camino de I/O (≈12 % con 1 vCPU y ≈16 % con 2), dentro de lo que en este equipo podría ser ruido. El arranque, la memoria y el calentamiento quedan iguales, y la imagen crece 33 MB. Frente a Go y Rust la brecha sigue siendo de 3 a 4 veces.

Lo que Java 25 trae para este problema no se activa solo: el AOT cache (JEP 483 y 514), que precarga clases y perfiles para arrancar más rápido; los compact object headers (JEP 519), que bajan la memoria; y los virtual threads (spring.threads.virtual.enabled=true). Ese es el experimento que falta para saber cuánto se acerca Java sin reescribir el servicio.

Qué se migró

ms-mfa tiene 473 archivos Java (≈11.900 líneas) repartidos en 80 casos de uso, 13 clientes REST y 14 entidades. Migrarlo entero no sirve para comparar lenguajes: la mitad del código habla con Jumio, Cognito, SNS y proveedores de SMS. Se migró el ciclo OTP completo, que es el corazón del servicio y el que recorre cada transferencia que pide segundo factor. Son cuatro endpoints, con las mismas rutas, headers y códigos de error que el original:

POST/mfa/b2c/transactions/initResuelve el business_flow, crea mfa_transaction + una mfa_validation OTP en una transacción.
POST/mfa/b2c/validations/otp/generateReglas de EvaluateMfaTransaction, OTP de 6 dígitos con SecureRandom, hash BCrypt y guardado.
POST/mfa/b2c/validations/otp/validateLock idempotente en Redis (TTL 2 s), reglas, verificación BCrypt, intentos o VERIFIED.
GET/mfa/iuse/…/statusEl check que llaman los otros micros: expiración de 10 min, flujo y dueño; cierra la transacción y marca is_validated.

Borde naranjo = paso dominado por CPU (BCrypt fuerza 10, igual que el BCryptPasswordEncoder() por defecto de EncoderConfig).

Se conservó, igual en los tres

  • Las consultas contra el mismo subconjunto de tablas y columnas.
  • Todas las reglas de EvaluateMfaTransactionUseCaseImpl, incluido cerrar la transacción y rechazar las validaciones pendientes al expirar o agotar intentos.
  • BCrypt fuerza 10, OTP de 6 dígitos, TTL de 2 s del @Idempotent y expiración de 10 min del status.
  • Los límites transaccionales del original: el aumento de intentos se persiste aunque el request falle.

Quedó fuera (stub o sin portar)

  • La consulta de KYC a ms-customer y el @TrackSnsEvent del init.
  • @ValidateSignature, el envío por SMS/email y el límite de reenvíos por otp_delivery_config.
  • La whitelist de OTP, FaceID/Jumio, PIN y TOTP.
  • El @Idempotent con espera (WAIT, 5 s) quedó como SET NX EX 2: un duplicado recibe 409.

Paridad verificada

El mismo script (bench/smoke.sh) corre contra los tres servicios y obtiene respuestas y códigos idénticos en: flujo desconocido (404), generate de otro cliente (MFA_CUSTOMER_DATA_MISMATCH), OTP incorrecto (OTP_VALIDATION_FAILED), duplicado dentro de 2 s (409), OTP correcto, flujo equivocado en el status (404), status válido, segundo status (MFA_TRANSACTION_CLOSE) y bloqueo tras tres intentos (MFA_MAX_VALIDATION_ATTEMPTS_EXCEEDED). Durante toda la carga, ningún flujo terminó con un resultado distinto al esperado.

Metodología

  • Un servicio a la vez, cada uno con 1 vCPU y 512 MB (límites de cgroup), el tamaño de una tarea chica de ECS. MySQL 8.0 y Redis 7 compartidos y sin límite, con una base y un número de DB de Redis distintos por implementación.
  • Java: Spring Boot 3.5.6, JPA/Hibernate, Spring Data Redis, Corretto 17 Alpine (la misma base que el Dockerfile de producción, sin el agente de Datadog), -XX:MaxRAMPercentage=75. La misma aplicación se corrió también sobre Corretto 25. Donde el texto dice “Java” a secas, las cifras son de Java 17.
  • Go 1.26: net/http, database/sql + go-sql-driver, go-redis y x/crypto/bcrypt. Binario estático en imagen scratch.
  • Rust: axum 0.8 sobre tokio, sqlx 0.8, redis-rs y el crate bcrypt en spawn_blocking. Binario estático (musl) en scratch.
  • Pool de 10 conexiones en los tres (el default de Hikari).
  • Carga: generador propio en Go, de lazo cerrado: N usuarios virtuales repiten el flujo sin pausa. Ligero = init → status (2 llamadas HTTP, sin BCrypt: el camino de I/O). Completo = los cuatro pasos (2 hashes BCrypt por flujo). 15 s por punto; CPU y memoria muestreadas con docker stats. El OTP se fija en 123456 por variable de entorno para poder validarlo.
  • MySQL en tmpfs, con innodb_flush_log_at_trx_commit=2 y sin binlog. En la primera corrida el fsync de Docker Desktop sobre WSL dominaba todo (≈25 ms por commit) y ocultaba cualquier diferencia entre runtimes; así se parece más a la latencia de commit de Aurora.
  • Equipo: Windows 11, 8 hilos, 16 GB, Docker Desktop 29.2 (WSL2).

Arranque y cold start

Con 1 vCPU, Spring Boot tarda s desde que el contenedor arranca hasta responder /health. Go y Rust responden en s y s de mediana, con corridas entre 0,04 y 1,8 s: esa variación es lo que tarda Docker Desktop en exponer el puerto, porque los procesos están listos en milisegundos.

Que el health responda no significa que la JVM esté caliente. En el primer segundo de carga real, Java completó flujo OTP, con una mediana de ms; Go y Rust completaron cada uno, en ≈ ms. En un servicio que escala horizontalmente, ese es tiempo en que una tarea nueva ya cuesta plata pero todavía no absorbe tráfico, y obliga a un healthCheckGracePeriod largo en ECS.

Memoria

En reposo, Java ocupa MiB, Go MiB y Rust MiB. Bajo carga la diferencia se mantiene: el pico de Java en todas las pruebas fue de MiB, contra MiB de Go y MiB de Rust.

¿Con cuánta memoria arranca?

Se repitió el arranque con límites de 64, 128 y 256 MB, seguido de 10 s de carga ligera.

Java no alcanza a levantar con 64 ni con 128 MB: el kernel lo mata por OOM durante el arranque. Con 256 MB arranca en s y atiende flujos/s. Go y Rust funcionan igual con 64 MB que con 512.

Rendimiento en el camino de I/O

El flujo ligero (init → status) es lo que más se repite en producción: cada micro que ejecuta una operación con MFA llama al status. Son dos llamadas HTTP y nueve sentencias SQL, sin criptografía.

Go y Rust se estancan en ≈250 y ≈310–340 flujos/s a partir de 8 usuarios. Ese techo no es la CPU, porque con 2 vCPU no suben (ver escalamiento): lo que los limita es el pool de 10 conexiones contra MySQL. Java se queda en ≈50 flujos/s porque se le acaba antes la CPU. Con 128 usuarios, su p99 es de ms, contra ms de Go y ms de Rust.

Con un solo usuario, que mide latencia pura sin cola, la mediana del flujo es de ms en Rust, ms en Go y ms en Java.

Rendimiento con BCrypt

El flujo completo hace dos hashes BCrypt de fuerza 10 (210 rondas de Blowfish cada uno). Ahí manda la CPU, y la ventaja de Go y Rust casi desaparece:

Con 1 vCPU ninguno pasa de ≈8 flujos completos por segundo. El BCrypt de Java, ya compilado por el JIT, es competitivo: con 64 usuarios hace flujos/s, más que Go (), cuyo x/crypto/bcrypt está escrito en Go puro. Rust es el más rápido (). La conclusión práctica no depende del lenguaje: la capacidad de generate y validate la fija el costo del hash. Bajar la fuerza a 8 cuadruplicaría el throughput en cualquiera de los tres, y para un OTP de 6 dígitos que expira en 5 minutos y admite 3 intentos, la fuerza 10 aporta poca seguridad adicional.

Calentamiento

Proceso recién arrancado, 32 usuarios de flujo ligero y ocho ventanas seguidas de 5 s:

Go y Rust entregan todo su throughput desde la primera ventana. Java arranca en flujos/s y a los 40 s va en , todavía subiendo: el JIT sigue compilando y le quita CPU al tráfico. El mejor valor de Java con 1 vCPU apareció recién en la prueba de escalamiento, varios minutos después ( flujos/s), y es el que se usa en el resumen.

Escalamiento

Vertical: la misma tarea con más o menos CPU

Se cambió la cuota de CPU del contenedor en caliente: 0,5, 1 y 2 vCPU.

En I/O, Java es el único que escala con CPU (de a flujos/s), precisamente porque es el único limitado por CPU. Go y Rust con 0,5 vCPU ya rinden más que Java con 2. Con BCrypt los tres escalan de forma parecida, como corresponde a trabajo de CPU puro.

Horizontal: más tareas

Como Go y Rust chocan con el pool de conexiones y no con la CPU, escalan agregando tareas, pero cada tarea suma 10 conexiones a MySQL: el límite pasa a ser la base, no el servicio. Java necesita más tareas para el mismo tráfico, y cada una tarda ≈ s en estar lista, más el calentamiento. Ante un pico, el autoscaling de Java reacciona con minutos de retraso; el de Go y Rust, en segundos.

Costo en Fargate

Precio on-demand de Fargate en us-east-1 (Linux/x86): US$0,04048 por vCPU-hora y US$0,004445 por GB-hora. Una tarea de 1 vCPU exige al menos 2 GB, así que las tres cuestan lo mismo por hora (US$0,0494) y la diferencia está en cuánto trabajo hace cada una.

Con 1 vCPU, la memoria no cambia la factura, porque el mínimo de 2 GB ya le sobra a Java. Sí importa en tareas de 0,25 vCPU y 0,5 GB, donde Go y Rust caben con holgura y Java, que en estas pruebas no arranca con menos de 256 MB, tardaría más de un minuto en levantar.

Código y entrega

  • Java expresa la lógica de negocio con menos ruido gracias a JPA y a los repositorios derivados, pero arrastra una imagen de 210 MB, el build con Maven y la configuración implícita de Spring. El bug más sutil del port apareció aquí: un @Transactional de más revertía el aumento de intentos cuando el OTP fallaba.
  • Go es el más largo por el manejo explícito de errores y el SQL escrito a mano, pero no tiene magia: lo que se lee es lo que corre, y compila en segundos.
  • Rust quedó con menos líneas que Java, errores tipados y sin nulos. A cambio tiene la curva más empinada (lifetimes en evaluate, spawn_blocking para no bloquear el runtime) y el build más lento.

Lo que no aparece en el benchmark: ms-mfa depende de librerías internas de Global66 (global66-mysql-starter-parent, com.global.rest.exception, el @Idempotent, el tracking a SNS), de Liquibase y del agente de Datadog. En Go o Rust todo eso hay que reescribirlo o reemplazarlo, y es la mayor parte del costo real de una migración.

Veredicto para ms-mfa

Java

Correcto, y competitivo cuando manda la CPU (BCrypt). Caro en todo lo demás: ≈32 s de arranque con 1 vCPU, ≈4× menos throughput de I/O por vCPU y ≈100× más memoria. Pasar a Java 25 sin más cambios mejora el I/O en ≈12 % y no mueve el resto.

Sigue siendo la opción si el equipo y las librerías internas pesan más que la infraestructura.

Go

Se lleva casi toda la ganancia: arranque inmediato, ≈10 MB de memoria y ≈4× el throughput de I/O de Java. Su BCrypt es el más lento de los tres.

La mejor relación entre ganancia y costo de adopción para un equipo que viene de Java.

Rust

Los mejores números en casi todo: menor latencia, mayor throughput, menos memoria e imagen de 1,3 MB. Frente a Go, la ventaja es de ≈25 % en I/O, a cambio de una curva de aprendizaje mucho mayor.

Se justifica si cada milisegundo o cada MB se paga.

Recomendación

No reescribir ms-mfa entero por rendimiento. Primero, probar lo barato sobre Java. Subir a Java 25 ya está medido y por sí solo no alcanza; lo que falta es activar lo que trae (AOT cache para el arranque, compact object headers, virtual threads) o probar CRaC, y bajar la fuerza de BCrypt del OTP a 8. Si después de eso el costo o el arranque siguen doliendo, Go es el candidato, empezando por el endpoint de status, que es I/O puro y lo llama el resto de la plataforma.

Ninguna de esas optimizaciones de Java se midió aquí. Son el siguiente experimento.

Limitaciones

  • Es un slice del servicio, no el servicio completo, y con las dependencias externas simuladas. En producción, la latencia a ms-customer, SNS y los proveedores de SMS se suma igual en los tres.
  • Una corrida por punto, en un laptop con Docker Desktop y otros contenedores activos (SonarQube). Las diferencias chicas (<15 %) caen dentro del ruido; las grandes (arranque, memoria, I/O de Java) no.
  • Java sin el agente de Datadog que usa producción (sumaría memoria y arranque) y sin ajustes de JVM, tanto en 17 como en 25.
  • MySQL en tmpfs: los tiempos de commit no son los de Aurora, y eso favorece a los runtimes más rápidos porque la base tarda más en ser el cuello de botella.
  • El generador de carga corre en el mismo equipo que los servicios.