Introducción
No existe un ganador universal en la comparación entre .NET Native AOT, JIT y ReadyToRun. Cada modelo de publicación optimiza una parte distinta del sistema: Native AOT elimina el JIT en ejecución y reduce mucho el tiempo hasta la primera respuesta; ReadyToRun anticipa parte de la compilación sin abandonar el runtime dinámico; una aplicación JIT framework-dependent puede compartir el runtime instalado con otros procesos; y una publicación JIT self-contained prioriza el aislamiento operativo. Elegir solo por la etiqueta “CLI”, “servidor” o “serverless” ignora las restricciones que realmente controlan el resultado.
La decisión debe empezar por el objetivo medible de la aplicación. El tiempo de startup importa para procesos efímeros, pero el throughput en caliente, p95 y p99, CPU, memoria residente, tamaño de distribución, frecuencia de actualización, compatibilidad con código dinámico y tiempo de publicación también pueden decidir el proyecto. En este artículo, comparo los cuatro modelos con el mismo código en .NET 10 y linux-x64, conservando los resultados en bruto. La conclusión no es una regla lista: es una matriz que relaciona métricas y restricciones con el contexto de operación.
Este texto complementa la guía .NET Native AOT: Parte 1 — Ecosistema de Compilación. En la guía conceptual, expliqué Roslyn, IL, ILC, trimming y compatibilidad. Aquí, el foco es corregir simplificaciones comunes con un experimento reproducible: separar una aplicación framework-dependent de una distribución autocontenida, separar startup de throughput y no confundir asignación gestionada con RSS.
ℹ️ Información: todos los números de este artículo provienen de los CSV y JSON del laboratorio. Los valores absolutos describen este workload, este hardware y este entorno; las relaciones entre perfiles son hipótesis para que las pruebes, no garantías para otra aplicación.
Requisitos previos
- .NET SDK 10.0.400 o una imagen Docker equivalente.
- Docker Desktop con contenedores Linux para reproducir el entorno Ubuntu 24.04 y el RID
linux-x64. - Conocimientos básicos de publicación framework-dependent, self-contained, ReadyToRun y Native AOT.
uvpara ejecutar el consolidador determinista de los CSV y JSON.- Microsoft Crank y Bombardier para repetir la carga HTTP.
Lo que revelaron los comentarios sobre la decisión AOT
Una discusión técnica sobre el artículo conceptual expuso el principal fallo de las recomendaciones basadas solo en el tipo de aplicación. Decir que Native AOT sirve para CLI y serverless, mientras que JIT sirve para servidores de larga duración, parece útil porque cabe en una frase. El problema es que esa frase omite el objetivo. Una CLI usada una vez al mes puede no justificar el esfuerzo de compatibilidad; un backend replicado cientos de veces puede valorar densidad y startup; un worker duradero puede depender de plugins; un servicio estable de CPU puede tener un resultado distinto al de un servicio con una distribución de tráfico variable.
El startup tampoco es sinónimo del cold start de un proveedor. El laboratorio mide el intervalo entre iniciar un proceso y recibir una respuesta válida de /ready, con la caché del sistema de archivos caliente. Un cold start de Azure Functions, AWS Lambda u otra plataforma incluye decisiones del proveedor, creación de sandbox, pull de imagen, red, configuración e inicialización de la aplicación. No medí ese camino y, por lo tanto, no atribuyo a Native AOT una ganancia universal en serverless gestionado.
Otro punto importante es la previsibilidad. Quitar el JIT evita compilar métodos durante la ejecución, pero no elimina pausas de GC, planificación del sistema operativo, contención, I/O ni page faults. Del mismo modo, los source generators reducen el descubrimiento dinámico y trasladan errores al build, pero no hacen automáticamente más rápida cualquier arquitectura. Son propiedades relevantes para la decisión, no sellos de superioridad.
Mi regla revisada es más exigente: define una meta, elige las métricas capaces de refutarla y compara distribuciones equivalentes. Si el objetivo es reducir la primera respuesta, mide procesos nuevos. Si es aumentar la densidad, mide el RSS bajo una carga representativa. Si es sostener throughput, calienta la aplicación y registra latencia de cola y CPU junto con las peticiones por segundo.
Metodología: cómo hacer justa la comparación
El experimento usa Ubuntu 24.04 en Docker Desktop, procesador Intel Core i5-1245U x64, aproximadamente 8 GB de memoria disponibles, SDK 10.0.400 y runtime 10.0.11. Todos los perfiles se ejecutan en Release, entorno Production, sin providers de logging y con el mismo payload. El código no accede a base de datos, disco ni servicio externo durante la medición.

El workload recibe Seed=42, ItemCount=2048 e Iterations=8. Cada ejecución alquila un array con ArrayPool<int>, genera valores deterministas, ordena los datos, calcula la media y el percentil 95 y produce un SHA-256. La Minimal API serializa la respuesta con source generation de System.Text.Json. Esta combinación ejercita CPU, asignación, genéricos y serialización sin dejar que el I/O externo domine.
Los nombres combinan el modo de compilación con el modelo de distribución:
- JIT (Just-In-Time) compila IL a código nativo durante la ejecución.
- FDD (Framework-Dependent Deployment) publica solo la aplicación y exige un runtime .NET compatible instalado en el host.
- SCD (Self-Contained Deployment) incluye el runtime .NET en el directorio publicado.
- R2R (ReadyToRun) anticipa la compilación de los assemblies elegibles, pero conserva el runtime y el JIT.
- Native AOT (Native Ahead-Of-Time) genera antes de la ejecución un binario nativo autocontenido, sin JIT en producción.
Los cuatro perfiles son:
| Perfil | Runtime en el directorio | Código anticipado | JIT en ejecución |
|---|---|---|---|
| JIT FDD (dependiente del framework) | No; usa una instalación compatible | Las bibliotecas del runtime pueden contener R2R | Sí |
| JIT SCD (autocontenido) | Sí | Las bibliotecas del runtime pueden contener R2R | Sí |
| R2R SCD (ReadyToRun autocontenido) | Sí | Aplicación y dependencias elegibles | Sí |
| Native AOT (nativo autocontenido) | Runtime reducido incluido | Aplicación cerrada en código nativo | No |
El harness restaura las dependencias antes del cronómetro, ejecuta tres pares de publish limpio e incremental e inicia cada perfil 30 veces en orden aleatorio. Antes de medir el startup, copia los publishes al sistema de archivos Linux local del contenedor; ejecutar binarios grandes directamente en el bind mount de Windows añadió casi diez segundos artificiales en pruebas preliminares.
Para el estado en caliente, BenchmarkDotNet usa jobs out-of-process reales para .NET 10 JIT y Native AOT. La carga HTTP usa Microsoft Crank con Bombardier, 64 conexiones, 15 segundos de warm-up y 30 segundos de medición. La aplicación y el generador están en contenedores separados, pero en la misma máquina física. Eso contamina la capacidad absoluta, por lo que uso los resultados solo como comparación relativa en este entorno.
Ejemplo Práctico: laboratorio reproducible en .NET 10
La API se construyó con el host reducido de ASP.NET Core. El marcador escrito después de Start() permite a Crank sincronizar la carga sin habilitar logs distintos entre perfiles:
| |
📂 Código Fuente: El ejemplo completo está disponible en el repositorio de ejemplos del blog:
BlogSamples/NativeAot/DecisionLab/
El comando principal publica, mide el tamaño y ejecuta los 120 startups dentro de la imagen fijada:
| |
El manifiesto registra el commit, el estado del worktree, el fingerprint de las fuentes y el entorno. El fingerprint es necesario porque un hash de HEAD no identifica cambios aún no commiteados. El consolidador calcula la mediana, el mínimo, el máximo, la desviación absoluta mediana (MAD) y la razón frente a JIT FDD; las diferencias de hasta un 3% se marcan como dentro del umbral operativo de ruido, sin fingir significancia estadística.
Publish, tamaño y startup del proceso
Native AOT trasladó el costo al build. El publish limpio mediano tardó 98,145 segundos, frente a 11,589 segundos del JIT FDD, 28,450 segundos del JIT SCD y 25,812 segundos del R2R SCD. En el publish incremental, la distancia se redujo: Native AOT quedó en 13,398 segundos; JIT FDD, 11,679; JIT SCD, 14,552; y R2R SCD, 13,787.
| Perfil | Publish limpio mediano | Publish incremental mediano |
|---|---|---|
| JIT FDD | 11,589 s | 11,679 s |
| JIT SCD | 28,450 s | 14,552 s |
| R2R SCD | 25,812 s | 13,787 s |
| Native AOT | 98,145 s | 13,398 s |
El tamaño exige una comparación cuidadosa. Los 165.687 bytes del JIT FDD representan solo los archivos de la aplicación; la instalación compartida de .NET queda fuera del directorio. JIT SCD y R2R SCD incluyen runtime y bibliotecas y quedaron cerca de 109,7 MB. Native AOT incluyó el runtime reducido necesario y llegó a 28,3 MB. Comprimidos, los directorios ocuparon 81.471 bytes, 48,2 MB, 48,2 MB y 10,9 MB, respectivamente.
| Perfil | Unidad comparada | Descomprimido | ZIP |
|---|---|---|---|
| JIT FDD | Aplicación, sin runtime instalado | 165.687 B | 81.471 B |
| JIT SCD | Distribución completa | 109.703.386 B | 48.156.909 B |
| R2R SCD | Distribución completa | 109.745.882 B | 48.177.185 B |
| Native AOT | Distribución completa | 28.306.209 B | 10.865.327 B |
En el startup del proceso, Native AOT presentó una mediana de 63,794 ms y un MAD de 8,948 ms. JIT FDD registró 587,644 ms; JIT SCD, 633,357 ms; y R2R SCD, 585,283 ms. R2R y JIT FDD quedaron dentro del umbral operativo del 3%, por lo que este experimento no permite declarar a R2R ganador en el startup.
| Perfil | Mediana de startup | MAD | Muestras |
|---|---|---|---|
| JIT FDD | 587,644 ms | 100,856 ms | 30 |
| JIT SCD | 633,357 ms | 93,885 ms | 30 |
| R2R SCD | 585,283 ms | 79,038 ms | 30 |
| Native AOT | 63,794 ms | 8,948 ms | 30 |
⚠️ Atención: estos números miden un proceso nuevo con la caché del sistema de archivos caliente. No miden el arranque de la máquina, el pull del contenedor ni el cold start de un proveedor serverless.
Runtime compartido y unidades autocontenidas
Framework-dependent es una opción eficiente cuando varias aplicaciones usan una instalación compatible de .NET en el mismo host. El costo del runtime no desaparece; se instala, se actualiza y potencialmente se comparte fuera del artefacto de la aplicación. En contenedores aislados o hosts sin runtime, esa premisa cambia.
Cada publicación Native AOT es una unidad autocontenida y lleva las partes del runtime que necesita. En el modelo de publicación documentado, no existe un runtime Native AOT común consumido por varios ejecutables gestionados independientes. El sistema operativo puede compartir páginas de solo lectura entre procesos del mismo binario, pero eso es un comportamiento de memoria virtual y no convierte ejecutables distintos en clientes de un runtime común.
ℹ️ Información:
UnmanagedCallersOnlypuede exportar entry points C de un módulo Native AOT para interoperabilidad nativa. Eso no crea una DLL gestionada AOT compartida entre aplicaciones .NET.
Throughput, latencia y memoria bajo carga
La campaña HTTP usa el mismo endpoint y payload en los cuatro perfiles. Registro la mediana y la dispersión de peticiones por segundo, p50, p95, p99, CPU máxima del proceso y working set máximo en cinco rondas aleatorias por perfil. Como la aplicación y Bombardier comparten la misma máquina física, los números no representan la capacidad máxima de producción.
Las 20 rondas terminaron con cero respuestas inválidas. JIT FDD presentó la mayor mediana, 932 RPS, seguido de Native AOT con 810 RPS, JIT SCD con 803 RPS y R2R SCD con 734 RPS. La dispersión fue alta: el MAD varió de 82 RPS en JIT SCD a 240 RPS en R2R SCD, y los intervalos observados se superponen. En este host compartido, el orden de las medianas no sustenta una regla general de throughput.
| Perfil | RPS mediana | MAD RPS | p50 | p95 | p99 |
|---|---|---|---|---|---|
| JIT FDD | 932 | 130 | 63,936 ms | 136,854 ms | 194,880 ms |
| JIT SCD | 803 | 82 | 78,570 ms | 142,288 ms | 210,696 ms |
| R2R SCD | 734 | 240 | 83,483 ms | 191,594 ms | 312,714 ms |
| Native AOT | 810 | 186 | 79,518 ms | 145,527 ms | 210,021 ms |
La señal más nítida apareció en los recursos. Native AOT registró una mediana de 41 MB para el working set máximo, frente a 103 MB en JIT FDD, 101 MB en JIT SCD y 96 MB en R2R SCD. La CPU máxima mediana fue del 62% en Native AOT, 83% en JIT FDD, 79% en JIT SCD y 86% en R2R SCD. Son máximos muestreados por Crank, no consumo medio ni memoria privada.
| Perfil | CPU máxima mediana | Working set máximo mediano | MAD del working set |
|---|---|---|---|
| JIT FDD | 83% | 103 MB | 2 MB |
| JIT SCD | 79% | 101 MB | 2 MB |
| R2R SCD | 86% | 96 MB | 2 MB |
| Native AOT | 62% | 41 MB | 1 MB |
ℹ️ Información: en esta campaña, Native AOT usó alrededor del 40% del working set máximo mediano de JIT FDD. El resultado es específico de este workload AOT-friendly y no predice el RSS de otra aplicación.
JIT, Dynamic PGO y Native AOT en el código caliente
ReadyToRun no elimina el JIT. Con tiered compilation habilitada, los métodos usados con frecuencia pueden ver su código R2R reemplazado por código producido por el optimizing JIT. Dynamic PGO trabaja junto con ese mecanismo: instrumenta la ejecución, observa tipos y caminos calientes y usa esos datos para recompilar métodos relevantes.
Native AOT no dispone de JIT en producción, así que no puede adaptar el código durante la ejecución de la misma forma. Es una diferencia de capacidad, no una prueba de que el JIT siempre gane. El código AOT evita el warm-up de compilación y puede empatar o superar al JIT en workloads específicos; el JIT puede beneficiarse cuando el proceso dura lo suficiente y la distribución observada orienta optimizaciones útiles.
En el SDK 10.0.400 y en las fuentes públicas consultadas, no confirmé un flujo estable y documentado de PGO en build para Native AOT que pudiera recomendarse como procedimiento de producción en este laboratorio. Por eso, la comparación usa los valores predeterminados soportados y no incluye opciones experimentales. Incluso cuando haya un perfil offline disponible, debe representar producción: los cambios de tipos, rutas o distribución de tráfico pueden envejecer la evidencia recogida.
Los dos jobs completados por el mismo BenchmarkDotNet produjeron una mediana de 1,034 ms para JIT y 1,638 ms para Native AOT. En este workload en caliente, Native AOT tardó 1,585 veces el tiempo del baseline JIT. Las asignaciones gestionadas quedaron próximas: 8.984 bytes por operación en JIT y 9.370 bytes en Native AOT, una diferencia del 4,3%.
| Runtime | Mediana | MAD | Muestras | Asignación por operación |
|---|---|---|---|---|
| .NET 10 JIT | 1,034 ms | 0,133 ms | 92 | 8.984 B |
| Native AOT 10 | 1,638 ms | 0,161 ms | 99 | 9.370 B |
BenchmarkDotNet marcó la distribución de Native AOT como bimodal (mValue = 3,25) y eliminó un outlier; en JIT, eliminó ocho outliers. Por lo tanto, el resultado refuta la hipótesis de empate en este ensayo, pero no demuestra que el JIT siempre gane en código caliente. Solo muestra que, para esta carga, en este entorno y con los valores predeterminados soportados, la adaptación disponible en el runtime JIT coincidió con una menor duración mediana.
Source generators y reflection cambian el costo
El workload usa source generation de System.Text.Json. El contexto JSON registra los contratos usados por la API, lo que permite al compilador ver qué metadatos deben conservarse. Eso reduce el descubrimiento basado en reflection y hace el escenario deliberadamente compatible con Native AOT.
Reflection no es un bloque único. El acceso analizable a metadatos o miembros conservados puede funcionar con anotaciones y pruebas. Los problemas más fuertes aparecen cuando el conjunto de código solo se conoce en ejecución: Assembly.LoadFile, Reflection.Emit, plugins abiertos y serializers que descubren tipos arbitrarios. El trimmer necesita ver el grafo en el build; de lo contrario, no puede probar qué puede eliminar.
Evitar código dinámico puede ser una decisión arquitectónica sana, sobre todo cuando los source generators y los contratos explícitos anticipan errores. También puede ser inviable para un producto cuyo valor depende de una extensibilidad abierta. La compatibilidad debe ocupar una fila propia en la matriz de decisión; no debe tratarse como un detalle resuelto por un atributo genérico que lo conserva todo.
Dónde las conclusiones no se aplican directamente
El hard real-time exige previsibilidad de extremo a extremo. La ausencia de JIT no controla pausas de GC, planificación del sistema operativo, interrupciones, I/O, locks ni page faults. El soft real-time, en cambio, puede funcionar con un proceso JIT caliente y medido. Este laboratorio no mide deadlines ni usa un sistema operativo de tiempo real.
Blazor WebAssembly AOT es otro pipeline. Compila código .NET a WebAssembly ejecutado por el navegador y normalmente cambia una descarga mayor por mejor rendimiento en tramos intensivos de CPU. No es el mismo modelo de ejecutable Native AOT para Linux, Windows o macOS. Blazor Server se acerca más a la decisión de un backend ASP.NET Core, pero las funcionalidades y dependencias deben evaluarse por separado.
Tampoco hay resultados de previews de .NET 11, bibliotecas Native AOT exportadas, proveedores serverless ni aplicaciones con base de datos. Incluir esos escenarios sin medirlos aumentaría el alcance aparente y reduciría la utilidad de la conclusión.
Matriz de decisión orientada al objetivo
| Objetivo o restricción | Pregunta de medición | Opciones que merecen baseline |
|---|---|---|
| Primera respuesta | ¿Cuánto tarda un proceso nuevo en responder? | Native AOT, R2R y JIT |
| Throughput en caliente | ¿Qué perfil sostiene RPS con p95/p99 aceptables? | JIT con tiering/PGO y Native AOT |
| Memoria y densidad | ¿Cuál es el RSS bajo carga por réplica? | Native AOT, JIT FDD y JIT SCD |
| Distribución | ¿Cuántos bytes se transfieren y actualizan? | FDD si existe runtime; AOT/SCD si no existe |
| Runtime compartido | ¿Varias aplicaciones usan el mismo host administrado? | JIT FDD |
| Plugins y código dinámico | ¿El grafo de código se conoce en el build? | JIT; validar el trimming antes de AOT |
| Tiempo de build | ¿La frecuencia de entrega tolera un publish AOT? | JIT/R2R como baseline |
| Operación | ¿Las herramientas de diagnóstico cubren el modo elegido? | Validar por entorno e incidente esperado |
Una CLI distribuida a máquinas sin .NET puede valorar Native AOT por startup y empaquetado. Muchas aplicaciones en un host administrado pueden aprovechar FDD. Un backend duradero y variable puede beneficiarse de la adaptación del JIT. Edge e IoT pueden priorizar bytes, memoria y restricciones de ejecución. Estos ejemplos orientan qué pruebas ejecutar; ninguno sustituye la medición.
Limitaciones del experimento
El hardware es un notebook con Docker Desktop 4.81.0, y la aplicación y el generador de carga compiten por la misma CPU. El RID es solo linux-x64, el sistema es Ubuntu 24.04 y se observó el plan de energía Equilibrado (equilibrado) durante la campaña. Eso no controla la frecuencia, la temperatura ni las tareas en segundo plano del host, que pueden aumentar la dispersión. La campaña usa la caché del sistema de archivos caliente y no reinicia el sistema operativo entre muestras.
El workload es sintético, determinista y deliberadamente AOT-friendly. No representa acceso a base de datos, red externa, plugins, descubrimiento abierto de tipos ni una base de código grande. La memoria que reporta Crank es el working set máximo, mientras que BenchmarkDotNet registra la asignación gestionada por operación; esas métricas responden preguntas distintas.
Tres publishes y 30 startups permiten observar la dispersión operativa, pero no convierten el laboratorio en un estudio universal. Las cinco rondas HTTP ayudan a detectar inestabilidad, y el umbral del 3% evita anunciar diferencias pequeñas como ganadoras. Aun así, el umbral no es una prueba formal de significancia.
Consejos y Buenas Prácticas
Empieza con un baseline simple. Compara primero la publicación predeterminada que tu equipo ya opera. Native AOT y ReadyToRun deben mejorar una métrica relevante lo suficiente como para pagar el costo de compatibilidad, build y mantenimiento.
Ejecuta las pruebas de rendimiento en Release y Production. Debug y el entorno Development añaden trabajo y configuración que distorsionan los resultados. Mantén logging, GC, payload y funcionalidad iguales entre perfiles siempre que el modo de publicación lo permita.
Mide distribuciones, no una única ejecución. Usa procesos nuevos para el startup, warm-up explícito para el steady state y orden aleatorio. Registra la mediana y la dispersión para no confundir ruido térmico, caché o tareas en segundo plano con un efecto del compilador.
Separa el tamaño de la aplicación del tamaño de la distribución. FDD app-only presupone un runtime instalado; SCD y Native AOT incluyen el runtime. Declara la unidad comparada y, cuando la transferencia importe, mide también el artefacto comprimido.
Conserva los datos en bruto y el entorno. CSV, JSON, manifiesto, commit y fingerprint de las fuentes hacen auditable cada tabla. Copiar números a mano en Markdown sin trazabilidad facilita errores de unidad y redondeo.
Trata las respuestas inválidas como un fallo de la prueba. Un RPS alto con HTTP 400, 500 o timeouts no es rendimiento de la aplicación. Automatiza un gate que exija cero respuestas malas antes de consolidar la ronda.
Sigue las regresiones en CI con tolerancia al ruido. Un benchmark aislado no impide que dependencias o cambios de workload alteren el resultado. Usa una máquina estable y alerta solo cuando la diferencia supere la variabilidad histórica del escenario.
Resumen Objetivo
- Decisión entre JIT, ReadyToRun y Native AOT — no existe un ganador universal; primera respuesta, throughput, latencia de cola, CPU, memoria, distribución y compatibilidad responden preguntas distintas.
- Startup de Native AOT en este entorno — la mediana fue de 63,794 ms en 30 procesos, frente a 587,644 ms en JIT FDD; la medición usa la caché del sistema de archivos caliente y no representa el cold start de un proveedor.
- Publish de Native AOT en este entorno — el publish limpio mediano tardó 98,145 s, mientras que el incremental tardó 13,398 s; el costo más alto se concentró en la compilación limpia.
- Tamaño de JIT FDD — los 165.687 bytes medidos cubren solo la aplicación y presuponen un runtime compatible instalado, por lo que no son directamente comparables con las distribuciones autocontenidas completas.
- Tamaño de Native AOT — la distribución completa quedó en 28.306.209 bytes descomprimidos y 10.865.327 bytes en ZIP, incluidas las partes necesarias del runtime sin JIT.
- ReadyToRun — mantiene IL, runtime, JIT y tiered compilation; en este startup, R2R SCD y JIT FDD quedaron dentro del umbral operativo del 3%.
- Carga HTTP en este entorno — JIT FDD tuvo una mediana de 932 RPS, Native AOT 810, JIT SCD 803 y R2R SCD 734; Native AOT registró 41 MB de working set máximo mediano frente a 103 MB en JIT FDD, pero la alta dispersión impide generalizar la capacidad.
- Código caliente en este workload — la mediana fue de 1,034 ms en JIT y 1,638 ms en Native AOT; el informe marcó la distribución AOT como bimodal, por lo que la conclusión se limita a este ensayo.
Lee También
- .NET Native AOT: Parte 1 — Ecosistema de Compilación
- Paralelismo en C#: Parallel, PLINQ y Tasks en la Práctica
- .NET Worker con BackgroundService para Alto Volumen
- C# como Script en .NET: Cómo Usarlo y Cuándo Vale la Pena
Referencias
- Native AOT deployment overview — modelo de publicación, requisitos, runtime reducido y limitaciones oficiales.
- Native code interop with Native AOT — P/Invoke directo y exports C con
UnmanagedCallersOnly. - ReadyToRun deployment overview — formato R2R, impacto en el tamaño e interacción con tiered compilation.
- Compilation config settings — tiered compilation, ReadyToRun y dynamic PGO.
- Known trimming incompatibilities — serializers por reflection, generación dinámica y carga de assemblies.
- Blazor WebAssembly AOT — pipeline WebAssembly y trade-off entre descarga y ejecución.
- BenchmarkDotNet NativeAOT — jobs y toolchains out-of-process para runtimes distintos.
- Microsoft Crank — controller, agents y jobs de carga usados por el equipo de .NET.
- ASP.NET Core load and stress testing — orientación para ejecutar carga en Release y Production.

Al comentar, aceptas nuestra Política de Privacidad, Términos de Uso, Política de Eliminación de Datos.