Съдържание на курса
Урок 32 — JVM срещу нативно, измерено
От Dorian Chávez · съосновател и Chief Executive Officer на Hábil ·
Незадължително приложение. Може да се чете, без да се пуска.
Какво ще постигнеш: да изградиш същия int-rest по два начина — за JVM и като нативен изпълним файл — и да измериш на своята машина какво се променя: колко време отнема на всеки да се изгради, да е готов да обслужва и колко памет използва. И да го измериш добре: всяко число да казва това, което твърди, че мери.
Преди да започнеш, провери машината си. Компилирането до нативен вариант е най-тежкото в целия курс. На машината, на която го
измерихме (Mac с Apple M5, Docker с 6 CPU и 16 GiB), компилаторът стигна до 4.6 GB памет и 4.6 ядра, а
нативното изграждане отне 202 секунди от нулата. Подробностите са в
lecciones/31-de-laboratorio-a-kubernetes/CAPACIDAD.md.
Освен това ти трябват: прочетен урок 31 (този използва неговия Dockerfile) и, ако не познаваш нативния режим,
conceptos/antes-de-empezar/07-nativo.md. Не ти трябват нито kind, нито
средата от урок 00: урокът носи собствен compose.yaml с API-то, двата int-rest и един клиент за натоварване.
Новото днес, в едно изречение
До днес всяка услуга в курса работеше върху JVM. Camel Quarkus може да се компилира и до нативен вариант: изпълним файл, който стартира без JVM. Много се говори колко по-бързо стартира и колко памет спестява. Днес не го приемаш на доверие: измерваш го, с фиксиран метод, на своята машина. Новата трудност не е нативният вариант: тя е да мериш добре.
Картината: сравняване на две коли. Ако едната я мериш с вече загрял двигател, а другата — на студено, или на едната броиш от запалването на двигателя, а на другата — от качването на шофьора, резултатът не казва нищо за колите. За да сравниш, двете минават по една и съща писта, със същия товар и същия хронометър.
| Какво се мери | С какво | Защо така |
|---|---|---|
| Изграждането | С часовника, с --no-cache |
Никой да не използва повторно нещо от предишния път |
| Какво казва Quarkus | Редът started in … от неговия лог |
За да го сравниш със следващото |
hasta sano („до здрав“) |
От момента, в който се поиска контейнерът, докато /q/health/ready отговори |
Това чака този, на когото му трябва репликата да обслужва |
memoria en reposo (памет в покой) |
docker stats, вече стартирал, без работа |
Колко заема, докато чака |
memoria con carga (памет под натоварване) |
docker stats всяка секунда по време на натоварване от 100 поръчки в секунда, 20 s; най-високата |
Колко заема, докато работи |
| Образът | docker image inspect |
Колко тежи свалянето му |
Двата контейнера имат един и същ таван (1 CPU и 512 MiB) и се мерят един по един, за да не си отнемат CPU един на друг.
1. Подготви папката си
cd lecciones/32-jvm-contra-nativo
cp -R inicio mio
Твоята работа е един скрипт: mio/medir. Той вече изгражда двата образа, вдига всеки режим, пуска натоварването и записва
таблицата в mio/cifras.md. Липсват му трите функции, които мерят. Отвори го и го прочети отгоре до долу, преди да пишеш.
Отвори също compose.yaml: двата int-rest идват от същия Dockerfile от урок 31, с два различни target
(jvm и nativo), и слушат на 8091 и 8092.
2. Предвиди
Запиши на лист хартия, преди да мериш:
- Колко пъти по-бързо според теб стартира нативният вариант? И колко по-малко памет използва в покой?
- Кой от двата според теб отнема повече време, за да се изгради?
- Quarkus казва в лога си
started in 0.05s. Това ли е времето, което е нужно на репликата, за да може да обслужи една поръчка?
Виж какво е положението днес (изгражда двата образа от нулата; на машината от CAPACIDAD.md отне около 7 минути):
./verifica inicio
Образите се изграждат, стартират и доставят своята поръчка на API-то. Но в cifras.md липсват hasta sano,
memoria en reposo и memoria con carga: функциите, които мерят, още отговарят с —.
3. Трите измервания
TODO 1: паметта на един контейнер
docker stats я дава така: 145.8MiB / 512MiB. Поискай едно-единствено отчитане, само тази колона, и вземи първото
число, в 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 превръща 145.8MiB в 145.8: awk взема цифрите от началото. Останалото е смяна на мерната единица.
TODO 2: до здрав
Вземи часа, преди да поискаш контейнера, и питай на всеки 50 ms за /q/health/ready, най-много 60 секунди:
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 "—"
}
Защо не стига started in от лога? Защото това го казва Quarkus за себе си: не брои времето, което отнема
на контейнера да се роди. Който чака репликата да обслужва, чака и двете.
TODO 3: паметта под натоварване
Натоварването върви на заден план. Докато е още живо, вземай паметта всяка секунда и запази най-високата:
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 не убива нищо: само пита дали процесът още е жив. Стои преди wait.
4. Счупи едно нарочно
С твоя завършен medir промени TODO 3: изтрий while и след wait вземи едно-единствено отчитане
(tope=$(memoria "$cont")). Преди да го пуснеш, копирай своя mio/cifras.md другаде. Пусни ./verifica.
Преди това предвиди: засича ли го verifica?
Не: излиза зелено. memoria con carga продължава да е число, а verifica иска само това да е число. Сравни с копието,
което запази: новото число е паметта след натоварването и може да излезе по-ниско от истинското. Зле направеното
измерване не се проваля: връща число и звучи като факт. Затова verifica не оценява твоите числа спрямо никакъв праг
(карта 39) и затова методът се записва до таблицата. Върни while.
5. Провери
./verifica
verifica пуска твоя mio/medir, който изгражда двата образа от нулата и мери всеки. После праща по една поръчка на
всеки образ и проверява в лога на API-то, че е пристигнала, проверява, че нативният не носи JVM, и проверява, че cifras.md
е записан при това пускане с шестте числа за всеки режим. Урокът е завършен, когато видиш зелените отметки:
✅ 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
Числата са твои. На машината, на която го тествахме, JVM беше здрава за около 1 700 ms с около 108 MiB в покой, а нативният вариант — за около 240 ms с около 16 MiB. В замяна нативният се изграждаше по-дълго. На твоята машина ще са други и това е в реда на нещата: сравнявай с твоите, а не с нашите.
Не тръгва? ./verifica solucion тества нашето решение, а diff mio/medir solucion/medir ти казва по какво се
различават.
| Какво виждаш | Какво правиш |
|---|---|
El puerto … está ocupado |
Изключи това, което си оставил да работи, и опитай отново |
Tu mio/medir terminó con error |
Пусни ./mio/medir самостоятелно: казва ти на коя стъпка е спрял |
No existe la imagen ni-una-orden-perdida/int-rest:nativo: no se construyó |
Прочети mio/build-nativo.log. Ако паметта не е стигнала, виж CAPACIDAD.md: Dockerfile позволява да намалиш MEMORIA_NATIVO, но отнема повече време |
La imagen … no entregó su orden … a la API |
Следващите редове са логът на int-rest: казват защо |
Tu medir no escribió mio/cifras.md или no se escribió en esta corrida |
medir е спрял, преди да запише таблицата: пусни го самостоятелно |
A las cifras de … les falta (o no es un número): hasta sano |
Липсва TODO 2 или /q/health/ready не е отговорил нито веднъж за 60 s |
… les falta …: memoria en reposo, memoria con carga |
Липсва TODO 1 (а без него и 3 не мери) |
Какво учи това извън курса
Число без своя метод не се сравнява. „Стартира за 50 ms“ може да е това, което програмата казва за себе си, а може да е това, което чака този, който я използва. И двете са верни, но не са едно и също число.
Нативният вариант заменя една цена с друга. Стартира бързо и използва малко памет, а се изгражда по-дълго и иска голяма машина за компилиране. Подходящ е там, където често се стартират много реплики (като пиковете от урок 31); при услуга, която работи седмици без рестарт, разликата в стартирането почти не се усеща.
Публикуваните числа са от друга машина. Тези от някоя статия, нашите и твоите са от различни машини. Вършат работа, за да знаеш какво да очакваш; за да решиш, се мери на машината, на която ще работи.
Това, че тестът излиза зелен, не доказва, че си измерил добре. Скриптът verifica може да провери, че има число, но не и че числото е правилното. Методът е това, което го подкрепя.
Упражнение: същата писта
- Запиши в
mio/cifras.md, под таблицата, предвижданията си от стъпка 2 и в какво си сгрешил. - Пусни
./mio/medirдва пъти подред. Колко се променятhasta sanoиmemoria con cargaмежду едното пускане и другото? Какво ти казва това за сравняването на едно-единствено пускане? - На хартия: екипът ти има услуга, която се мащабира от 1 до 10 реплики в сутрешните пикове, и друга, която работи без рестарт цял месец. С твоите числа коя би компилирал до нативен вариант и защо?
Защо е направено така
Какво решихме в този урок, заедно с това, което отхвърлихме, и какво би ни накарало да си променим мнението:
- int-rest се експортира с camel export към Camel Quarkus, без да му се променя маршрутът
- Нативният вариант се компилира с Mandrel в контейнер
- JVM срещу нативно се мери на твоята машина, с фиксиран метод и без прагове
Преговор
- Какво е нативен изпълним файл и какво му липсва, което JVM има?
- Защо
hasta sanoиstarted inса различни числа? - Защо паметта под натоварване се отчита всяка секунда по време на натоварването, а не веднъж накрая?
- Защо двата контейнера се мерят един по един и с един и същ таван?
- Заключителният въпрос: някой ти казва „нативният стартира 30 пъти по-бързо“. Какво го питаш, преди да му повярваш?
Тук свършва курсът. Ако си стигнал дотук, една поръчка вече минава през API-то, ERP и партньора, без да се губи, и знаеш къде да гледаш, когато нещо се обърка.
Предпочитате имейл? Пишете ни на hola@habil.mx