Table des matières du cours
Leçon 32 — JVM contre natif, mesuré
Par Dorian Chávez · cofondateur et Chief Executive Officer de Hábil ·
Annexe facultative. Elle peut se lire sans être exécutée.
Ce que vous allez obtenir : construire le même int-rest de deux façons, pour la JVM et comme exécutable natif, et mesurer sur votre machine ce qui change : le temps que chacun met à se construire, à être prêt à servir, et la mémoire qu'il utilise. Et le mesurer bien : que chaque chiffre dise ce qu'il prétend mesurer.
Avant de commencer, vérifiez votre machine. Compiler en natif est ce qu'il y a de plus lourd dans tout le cours. Sur la machine où nous l'avons
mesuré (Mac avec Apple M5, Docker avec 6 CPU et 16 GiB), le compilateur est allé jusqu'à utiliser 4.6 GB de mémoire et 4.6 cœurs, et
la construction native a pris 202 secondes à partir de zéro. Le détail se trouve dans
lecciones/31-de-laboratorio-a-kubernetes/CAPACIDAD.md.
Il vous faut en outre : la leçon 31 lue (celle-ci utilise son Dockerfile) et, si vous ne connaissez pas le mode natif,
conceptos/antes-de-empezar/07-nativo.md. Vous n'avez besoin ni de kind ni de
l'environnement de la 00 : la leçon fournit son propre compose.yaml avec l'API, les deux int-rest et un client de charge.
La nouveauté du jour, en une phrase
Jusqu'à aujourd'hui, chaque service du cours tournait sur la JVM. Camel Quarkus peut aussi se compiler en natif : un exécutable qui démarre sans JVM. On dit beaucoup de choses sur sa rapidité de démarrage et la mémoire qu'il économise. Aujourd'hui, vous ne le croyez pas : vous le mesurez, avec une méthode fixe, sur votre machine. La difficulté nouvelle n'est pas le natif : c'est de bien mesurer.
L'image : comparer deux voitures. Si vous mesurez l'une avec le moteur déjà chaud et l'autre à froid, ou si pour l'une vous comptez à partir du démarrage du moteur et pour l'autre à partir du moment où le conducteur monte, le résultat ne dit rien des voitures. Pour comparer, les deux passent par la même piste, avec la même charge et le même chronomètre.
| Ce qui est mesuré | Avec quoi | Pourquoi ainsi |
|---|---|---|
| Construire | L'horloge, avec --no-cache |
Qu'aucun ne réutilise ce qui reste de la fois précédente |
| Ce que dit Quarkus | La ligne started in … de son journal |
Pour la comparer à la suivante |
hasta sano (jusqu'à sain) |
Depuis que le conteneur est demandé jusqu'à ce que /q/health/ready réponde |
C'est ce qu'attend celui qui a besoin que la réplique serve |
memoria en reposo (mémoire au repos) |
docker stats, une fois démarré, sans travail |
Ce qu'il occupe en attendant |
memoria con carga (mémoire sous charge) |
docker stats chaque seconde pendant une charge de 100 commandes par seconde, 20 s ; la plus haute |
Ce qu'il occupe en travaillant |
| Image | docker image inspect |
Ce que pèse son téléchargement |
Les deux conteneurs ont la même limite (1 CPU et 512 MiB) et sont mesurés un à la fois, pour que l'un ne prenne pas de CPU à l'autre.
1. Préparez votre dossier
cd lecciones/32-jvm-contra-nativo
cp -R inicio mio
Votre travail est un script : mio/medir. Il construit déjà les deux images, démarre chaque mode, lance la charge et écrit le
tableau dans mio/cifras.md. Il lui manque les trois fonctions qui mesurent. Ouvrez-le et lisez-le de haut en bas avant d'écrire.
Ouvrez aussi compose.yaml : les deux int-rest sortent du même Dockerfile de la 31, avec deux target différents
(jvm et nativo), et écoutent sur 8091 et 8092.
2. Prédisez
Écrivez sur papier, avant de mesurer :
- Combien de fois plus vite le natif démarre-t-il, selon vous ? Et combien de mémoire en moins utilise-t-il au repos ?
- Lequel des deux met le plus de temps à se construire, selon vous ?
- Quarkus dit dans son journal
started in 0.05s. Est-ce le temps que met la réplique à pouvoir servir une commande ?
Regardez l'état actuel (il construit les deux images à partir de zéro ; sur la machine de CAPACIDAD.md, cela a pris environ 7 minutes) :
./verifica inicio
Les images se construisent, démarrent et livrent leur commande à l'API. Mais dans cifras.md manquent « hasta sano »,
« memoria en reposo » et « memoria con carga » : les fonctions qui mesurent répondent encore —.
3. Les trois mesures
TODO 1 : la mémoire d'un conteneur
docker stats la donne ainsi : 145.8MiB / 512MiB. Demandez une seule lecture, uniquement cette colonne, et gardez le premier
nombre, en MiB :
memoria() {
docker stats --no-stream --format '{{.MemUsage}}' "$1" 2>/dev/null | awk '{
v=$1; n=v+0
if (v ~ /GiB/) n=n*1024; else if (v ~ /KiB/) n=n/1024
printf "%.1f\n", n }'
}
n=v+0 convertit 145.8MiB en 145.8 : awk prend les chiffres du début. Le reste consiste à changer d'unité.
TODO 2 : jusqu'à sain
Prenez l'heure avant de demander le conteneur et interrogez /q/health/ready toutes les 50 ms, pendant 60 secondes au plus :
hasta_sano() {
local modo=$1 t0 p
p=$(puerto "$modo"); t0=$(ms)
C up -d --force-recreate "int-rest-$modo" >/dev/null 2>&1
for _ in $(seq 1 1200); do
curl -sf -o /dev/null --max-time 1 "localhost:$p/q/health/ready" && { echo $(( $(ms) - t0 )); return 0; }
sleep 0.05
done
echo "—"
}
Pourquoi le started in du journal ne suffit-il pas ? Parce que c'est ce que Quarkus dit de lui-même : cela ne compte pas le temps que met
le conteneur à naître. Celui qui attend que la réplique serve attend les deux.
TODO 3 : la mémoire sous charge
La charge tourne en arrière-plan. **Tant qu'**elle est en vie, relevez la mémoire chaque seconde et gardez la plus haute :
while kill -0 "$carga" 2>/dev/null; do
m=$(memoria "$cont"); awk -v a="$m" -v b="$tope" 'BEGIN{exit !(a+0 > b+0)}' && tope=$m
sleep 1
done
kill -0 ne tue rien : il demande seulement si le processus est toujours en vie. Il va avant le wait.
4. Cassez-en une exprès
Avec votre medir terminé, changez le TODO 3 : effacez le while et, après le wait, faites une seule lecture
(tope=$(memoria "$cont")). Avant de le lancer, copiez votre mio/cifras.md ailleurs. Lancez ./verifica.
Avant cela, prédisez : le verifica le détecte-t-il ?
Non : il sort en vert. « memoria con carga » est toujours un nombre, et le verifica demande seulement que c'en soit un. Comparez avec la copie
que vous avez gardée : le nouveau chiffre est la mémoire après la charge, et il peut sortir plus bas que le vrai. Une mesure mal
faite n'échoue pas : elle renvoie un nombre et sonne comme un fait. C'est pour cela que le verifica ne juge vos chiffres contre aucun seuil
(fiche 39), et que la méthode s'écrit à côté du tableau. Remettez le while.
5. Vérifiez
./verifica
verifica exécute votre mio/medir, qui construit les deux images à partir de zéro et mesure chacune. Puis il envoie une commande à
chaque image et contrôle dans le journal de l'API qu'elle est arrivée, vérifie que l'image native ne contient pas de JVM et contrôle que cifras.md
a été écrit lors de cette exécution avec les six chiffres de chaque mode. Elle est terminée quand vous voyez les coches vertes :
✅ La imagen jvm arrancó, contestó y su orden (…) llegó a la API
✅ La imagen nativo arrancó, contestó y su orden (…) llegó a la API
✅ Control: la imagen nativa no trae JVM; corre un ejecutable de (…) MB
✅ Cifras de jvm medidas: construir (…)s · Quarkus (…)s · sano (…) ms · reposo (…) MiB · carga (…) MiB · imagen (…) MB
✅ Cifras de nativo medidas: construir (…)s · Quarkus (…)s · sano (…) ms · reposo (…) MiB · carga (…) MiB · imagen (…) MB
Les chiffres sont les vôtres. Sur la machine où nous l'avons testé, la JVM a été saine en 1 700 ms environ avec environ 108 MiB au repos, et le natif en 240 ms environ avec environ 16 MiB. En échange, le natif a mis plus de temps à se construire. Sur votre machine, ils seront différents, et c'est très bien : comparez avec les vôtres, pas avec les nôtres.
Ça ne tourne pas ? ./verifica solucion teste la nôtre, et diff mio/medir solucion/medir vous dit en quoi elles
diffèrent.
| Ce que vous voyez | Ce que vous faites |
|---|---|
El puerto … está ocupado |
Éteignez ce que vous avez laissé tourner et réessayez |
Tu mio/medir terminó con error |
Lancez ./mio/medir seul : il vous dit à quelle étape il s'est arrêté |
No existe la imagen ni-una-orden-perdida/int-rest:nativo: no se construyó |
Lisez mio/build-nativo.log. S'il a manqué de mémoire, consultez CAPACIDAD.md : le Dockerfile permet de baisser MEMORIA_NATIVO, et cela prend plus de temps |
La imagen … no entregó su orden … a la API |
Les lignes qui suivent sont le journal d'int-rest : elles disent pourquoi |
Tu medir no escribió mio/cifras.md ou no se escribió en esta corrida |
medir s'est arrêté avant d'écrire le tableau : lancez-le seul |
A las cifras de … les falta (o no es un número): hasta sano |
Il manque le TODO 2, ou /q/health/ready n'a jamais répondu en 60 s |
… les falta …: memoria en reposo, memoria con carga |
Il manque le TODO 1 (et avec lui, le 3 ne mesure pas non plus) |
Ce que cela enseigne au-delà du cours
Un chiffre sans sa méthode ne se compare pas. « Il démarre en 50 ms » peut être ce que le programme dit de lui-même ou ce qu'attend celui qui l'utilise. Les deux sont vrais et ce n'est pas le même chiffre.
Le natif échange un coût contre un autre. Il démarre vite et utilise peu de mémoire, et il met plus de temps à se construire et demande une grosse machine pour compiler. Il convient là où l'on démarre souvent beaucoup de répliques (comme les pics de la 31) ; dans un service qui tourne des semaines sans redémarrer, la différence de démarrage ne se remarque presque pas.
Les chiffres publiés viennent d'une autre machine. Ceux d'un article, les nôtres et les vôtres viennent de machines différentes. Ils servent à savoir à quoi s'attendre ; pour décider, on mesure sur la machine où cela va tourner.
Que le test sorte en vert ne prouve pas que vous avez bien mesuré. Le verifica peut contrôler qu'il y a un nombre, pas que le nombre est le bon. C'est la méthode qui le soutient.
Exercice : la même piste
- Écrivez dans
mio/cifras.md, sous le tableau, vos prédictions de l'étape 2 et ce sur quoi vous vous êtes trompé. - Lancez
./mio/medirdeux fois de suite. De combien «hasta sano» et «memoria con carga» changent-ils d'une exécution à l'autre ? Qu'est-ce que cela vous dit sur le fait de comparer une seule exécution ? - Sur papier : votre équipe a un service qui passe de 1 à 10 répliques lors des pics du matin, et un autre qui tourne sans redémarrer tout le mois. Avec vos chiffres, lequel compileriez-vous en natif et pourquoi ?
Pourquoi on a fait ainsi
Ce que nous avons décidé dans cette leçon, avec ce que nous avons écarté et ce qui nous ferait changer d'avis :
- int-rest est exporté avec camel export vers Camel Quarkus, sans changer sa route
- Le natif se compile avec Mandrel dans un conteneur
- JVM contre natif se mesure sur votre machine, avec une méthode fixe et sans seuils
Révision
- Qu'est-ce qu'un exécutable natif, et que lui manque-t-il que la JVM possède ?
- Pourquoi «
hasta sano» et « started in » sont-ils des chiffres différents ? - Pourquoi la mémoire sous charge se lit-elle chaque seconde pendant la charge, et non une fois à la fin ?
- Pourquoi les deux conteneurs sont-ils mesurés un à la fois et avec la même limite ?
- La question de clôture : quelqu'un vous dit « le natif démarre 30 fois plus vite ». Que lui demandez-vous avant de le croire ?
Le cours se termine ici. Si vous êtes arrivé jusqu'ici, une commande traverse désormais l'API, l'ERP et le partenaire sans se perdre, et vous savez où regarder quand quelque chose échoue.
Vous préférez l'e-mail ? Écrivez-nous à hola@habil.mx