Към съдържанието
Съдържание на курса

Урок 32 — JVM срещу нативно, измерено

От · съосновател и 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. Предвиди

Запиши на лист хартия, преди да мериш:

  1. Колко пъти по-бързо според теб стартира нативният вариант? И колко по-малко памет използва в покой?
  2. Кой от двата според теб отнема повече време, за да се изгради?
  3. 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 може да провери, че има число, но не и че числото е правилното. Методът е това, което го подкрепя.

Упражнение: същата писта

  1. Запиши в mio/cifras.md, под таблицата, предвижданията си от стъпка 2 и в какво си сгрешил.
  2. Пусни ./mio/medir два пъти подред. Колко се променят hasta sano и memoria con carga между едното пускане и другото? Какво ти казва това за сравняването на едно-единствено пускане?
  3. На хартия: екипът ти има услуга, която се мащабира от 1 до 10 реплики в сутрешните пикове, и друга, която работи без рестарт цял месец. С твоите числа коя би компилирал до нативен вариант и защо?

Защо е направено така

Какво решихме в този урок, заедно с това, което отхвърлихме, и какво би ни накарало да си променим мнението:

  • int-rest се експортира с camel export към Camel Quarkus, без да му се променя маршрутът
  • Нативният вариант се компилира с Mandrel в контейнер
  • JVM срещу нативно се мери на твоята машина, с фиксиран метод и без прагове

Преговор

  1. Какво е нативен изпълним файл и какво му липсва, което JVM има?
  2. Защо hasta sano и started in са различни числа?
  3. Защо паметта под натоварване се отчита всяка секунда по време на натоварването, а не веднъж накрая?
  4. Защо двата контейнера се мерят един по един и с един и същ таван?
  5. Заключителният въпрос: някой ти казва „нативният стартира 30 пъти по-бързо“. Какво го питаш, преди да му повярваш?

Тук свършва курсът. Ако си стигнал дотук, една поръчка вече минава през API-то, ERP и партньора, без да се губи, и знаеш къде да гледаш, когато нещо се обърка.

Да обсъдим вашия проект

Предпочитате имейл? Пишете ни на hola@habil.mx