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

Урок 31 — От лаборатория към проект, в Kubernetes

От · съосновател и Chief Executive Officer на Hábil ·

Незадължително приложение. Курсът свърши с урок 30. Този урок и урок 32 са за този, който работи с Kubernetes или иска да види докъде стига това, което е направил. Могат да се четат, без да се пускат.

Какво ще постигнеш: да пренесеш int-rest, същия от урок 12, от папката на лабораторията в образ на Camel Quarkus, да го пуснеш в учебен Kubernetes и да направиш така, че репликите му да се увеличават сами, когато пристигат много поръчки, и да намаляват, когато те свършат.

Преди да започнеш, провери машината си. Измерихме го на Mac с Apple M5 и Docker с 6 CPU и 16 GiB: урок 31 поиска около 1.4 GiB памет повече от вече използваната, 2.7 ядра в пика и около 4.4 GB образи. Урок 32 иска доста повече. Подробностите и как е измерено са в lecciones/31-de-laboratorio-a-kubernetes/CAPACIDAD.md. Това са числа от една-единствена машина: на твоята може да са други.

Освен това ти трябват: завършен урок 12 и две програми, които досега не си използвал:

Програма За какво Откъде се инсталира
kind Учебен Kubernetes, който работи вътре в Docker kind.sigs.k8s.io, „Installation“
kubectl За да говориш с този Kubernetes kubernetes.io, „Install Tools“

Този урок не използва средата от урок 00: създава собствен клъстер с име ni-una-orden-perdida и го изтрива накрая, независимо дали е минало добре, или зле. Ако не познаваш Kubernetes, прочети преди това conceptos/antes-de-empezar/08-kubernetes.md.

Новото днес, в едно изречение

В урок 12 сложи replicas: 3 на ръка: три реплики винаги, независимо дали има много работа, или никаква. Днес оставяш това решение на Kubernetes, с HPA (HorizontalPodAutoscaler): част, която гледа колко CPU използват репликите на int-rest и добавя още, когато наближат целта си, или маха, когато са излишни. За да може да мери, всяка реплика трябва да резервира CPU: HPA мери в проценти от резервираното.

Картината: касите в един супермаркет. Когато има малко хора, отворена е една. Управителят гледа опашките и когато всяка касиерка обслужва повече, отколкото ѝ се полага, отваря още една — до четирите, които има. Когато магазинът се опразни, ги затваря една по една. Но за да знаеш дали една касиерка „е на 150 %“, първо трябва да кажеш колко се полага на всяка. Точно това се резервира.


1. Подготви папката си

cd lecciones/31-de-laboratorio-a-kubernetes
cp -R inicio mio

Преди да пишеш, прочети това, което вече е направено:

Файл Какво е Пишеш ли го?
int-rest/int-rest.camel.yaml Маршрутът на int-rest от урок 12, без да е променена нито една буква, със своите мапинги и еталонни тестови случаи Не
Dockerfile От папката до образ, на етапи: camel export я превръща в проект на Camel Quarkus, той се компилира и остава образ за JVM (и още един, нативен, за урок 32). Всичко в контейнери: не инсталираш нито Java, нито Maven Не, прочети го
cluster/ Клъстерът на kind, metrics-server (това, което мери CPU на всяка реплика), API-то за поръчки и един клиент, който праща натоварването Не
mio/k8s/int-rest.yaml Deployment-ът (репликите) и Service-ът (постоянното име, което разпределя между тях) Да, TODO 1 и 2
mio/k8s/hpa.yaml HPA Да, TODO 3 и 4

Обърни внимание на две неща в Dockerfile и в Deployment-а. Конфигурацията не е в application.properties: това, което се решава при компилиране, отива в pom.xml, а това, което се решава при изпълнение, отива в променливи на средата на Deployment-а (QUARKUS_SHUTDOWN_TIMEOUT). И образът не се сваля от никакъв регистър: kind load го качва на възела, затова пише imagePullPolicy: Never.

2. Предвиди

Отговори на лист хартия:

  1. Ако една реплика на int-rest резервира 200 милиядра CPU (една пета от ядро) и използва 300, на какъв процент е? С цел 50 % колко реплики би поискал HPA?
  2. Ако репликата не резервира CPU, спрямо какво изчислява HPA процента?
  3. Натоварването трае две минути и после свършва. Кога според теб HPA маха излишните реплики?

Виж какво е положението днес (първия път отнема няколко минути: сваля образи и изгражда):

./verifica inicio

Първите отметки излизат зелени: клъстерът се създава, int-rest се изгражда с camel export и поръчка 1001 стига до API-то в клъстера. После излиза в червено тази за резервирания CPU, а Kubernetes отхвърля HPA: липсва му максимумът на репликите.

3. Резервация, таван и цел

TODO 1 и 2: какво резервира всяка реплика и нейният таван

В mio/k8s/int-rest.yaml, вътре в контейнера, добави resources:

resources:
  requests:            # lo que la copia RESERVA en el nodo
    cpu: 200m
    memory: 256Mi
  limits:              # el techo
    cpu: "1"
    memory: 512Mi
Какво означава Ако се надхвърли
requests Kubernetes слага репликата само на възел, който има това свободно, и HPA мери спрямо него —
limits.cpu Повече от едно ядро не ѝ се дава Забавя се принудително
limits.memory Повече от 512 MiB не ѝ се дава Kubernetes рестартира репликата

200m се чете „200 милиядра“: едно ядро е 1000m. С резервирани 200m реплика, която използва 100m, е на 50 %.

TODO 3 и 4: HPA

В mio/k8s/hpa.yaml, под scaleTargetRef:

minReplicas: 1
maxReplicas: 4
metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 50

На всеки 15 секунди (периодът, с който Kubernetes идва по подразбиране; може да се конфигурира) HPA прави тази сметка и я държи между минимума и максимума:

copias que quiere = copias que hay × (CPU promedio ÷ meta), redondeado hacia arriba
ejemplo: 1 copia al 150 % con meta de 50 % → quiere 3

Максимумът не е дреболия: той е това, което пречи на голямо натоварване да изяде целия възел. А behavior.scaleDown, което файлът вече носи, прави така, че да намалява след 30 секунди без натоварване, за да го видиш в курса. По подразбиране чака 5 минути, за да не се качва и сваля през цялото време.

4. Счупи едно нарочно

С твоите завършени файлове махни cpu: 200m от requests (остави паметта) и пусни ./verifica.

Преди това предвиди: HPA е написан правилно и Kubernetes го приема. Мащабира ли?

Не. Скриптът verifica казва, че int-rest не резервира CPU, а после, че HPA не успява да го прочете: ако го попиташ сам (kubectl get hpa), целта излиза като <unknown>/50%. HPA не е счупен: липсва му спрямо какво да мери. Процент без база не е число. Върни реда.

5. Провери

./verifica

verifica създава клъстера, изгражда int-rest, внедрява го с твоите файлове, праща поръчка 1001 като контрола и после натоварване от 150 поръчки в секунда в продължение на две минути. Брои готовите реплики на Deployment-а (а не това, което казва маршрутът), проверява, че Service-ът е разпределил между тях и че API-то е отговорило на всички поръчки. После изчаква да намалеят. На машината от CAPACIDAD.md отне около 4 минути; твоята ще каже. Урокът е завършен, когато видиш зелените отметки:

✅ Clúster kind «ni-una-orden-perdida» creado (Kubernetes …)
✅ int-rest salió de camel export a una imagen de Camel Quarkus, y está en el clúster junto con la API
✅ Kubernetes aceptó mio/k8s/int-rest.yaml (el Deployment y el Service)
✅ Control: la orden 1001 pasó por int-rest y la API la registró una vez (la ruta no cambió ni una letra)
✅ Cada copia de int-rest reserva CPU: requests.cpu=200m
✅ Kubernetes aceptó mio/k8s/hpa.yaml
✅ El HPA escala a int-rest entre 1 y 4 copias, con meta de CPU de 50 %
✅ El HPA ya lee la CPU de int-rest: (…) % de lo reservado, sin carga
✅ Con carga, el HPA subió int-rest de 1 a (…) copias listas (máximo 4)
✅ (…) copias de int-rest atendieron órdenes de la carga: el Service repartió
✅ Las (…) órdenes de la carga llegaron a la API y cada una tuvo respuesta: ninguna se perdió mientras crecía
✅ Sin carga, int-rest volvió a 1 copia(s) en (…) s

При нашите пускания HPA се качи до 4 реплики в едно и до 3 в друго; затова verifica иска „повече от минимума“, а не точно число. До колко се качва, зависи от твоята машина.

Докато работи, в друг терминал можеш да гледаш как HPA работи. Скриптът verifica пази ключа на клъстера във временен файл, за да не пипа твоята конфигурация на kubectl; искаш го от kind:

kubectl --kubeconfig <(kind get kubeconfig --name ni-una-orden-perdida) get hpa,deploy -w

Не тръгва? ./verifica solucion тества нашето решение, а diff -r mio solucion ти казва по какво се различават.

Какво виждаш Какво правиш
No encuentro «kind» или «kubectl» Инсталирай го от връзката в таблицата от „Преди да започнеш“
kind no pudo crear el clúster Провери дали Docker е вдигнат и има свободна памет (виж CAPACIDAD.md)
No se pudo construir int-rest Първото изграждане сваля зависимости: провери връзката си. Следващите редове казват къде е спряло
Kubernetes rechazó mio/k8s/int-rest.yaml Това е грешка в YAML или в имената: съобщението на Kubernetes излиза отдолу
int-rest no reserva CPU (resources.requests.cpu) Липсва TODO 1 или resources е останало извън контейнера
Kubernetes rechazó mio/k8s/hpa.yaml (TODO 3 y 4) Липсва maxReplicas или metrics е с грешен отстъп
El HPA debe escalar a int-rest … con un máximo mayor que el mínimo Провери minReplicas, maxReplicas и дали целта е type: Utilization
El HPA no logra leer la CPU de int-rest Почти винаги липсва requests.cpu. Kubernetes казва защо в същото съобщение
Con carga, int-rest se quedó en 1 copia(s) Целта не е процент от резервираното или е толкова висока, че никога не се достига
Sin carga, int-rest sigue en … copias Променил си behavior.scaleDown: върни го както беше

Какво учи това извън курса

Същият маршрут, друго място. int-rest премина от папката на лабораторията в образ на Camel Quarkus в Kubernetes, без да му се променя YAML-ът. Промени се как се пакетира и кой решава колко реплики има.

За да мащабираш, ти трябват само мярка и база. HPA не знае нищо за поръчки: знае за CPU спрямо резервираното. Ако резервацията е грешна, решението за мащабиране също е грешно.

Максимумът пази съседа. Без maxReplicas голямо натоварване добавя реплики, докато възелът не издържи. И спомни си урок 24: ако int-bd се мащабираше сам, таванът към ERP трябваше да се мисли с максимума на репликите, а не с днешните.

Мащабирането без загуби се проектира и се тества. При това пускане всички поръчки от натоварването получиха отговор, докато се появяваха нови реплики: Service-ът не праща нова работа на реплика, която още не е казала, че е готова. Когато маха реплика, Kubernetes ѝ дава гратисен прозорец и Quarkus се опитва да довърши това, което е носила, но verifica не тества този момент с поръчки във въздуха. За да си сигурен, че нищо не се прекъсва при намаляване, трябва да го тестваш с натоварване, с реалните времена на всяка услуга.

Упражнение: касите в супермаркета

  1. На хартия: с requests.cpu: 200m, цел 50 % и максимум 4 колко реплики иска HPA, ако 2 реплики са на 180 %? А ако са на 20 %?
  2. Смени целта на 80 % и пусни ./verifica. До по-малко реплики ли се качи? Колко време отне да намалее?
  3. Ако утре искаше да мащабираш int-bd по този начин, какво би трябвало да пресметнеш отново от урок 24 и с кое число: минимума или максимума на репликите?

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

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

  • Учебен Kubernetes с kind, с фиксирани версии, и клъстер, който се изтрива накрая
  • В Kubernetes отива int-rest, експортиран с camel export към Camel Quarkus, без да му се променя маршрутът
  • HPA мащабира по CPU, измерен като процент от това, което всяка реплика резервира

Преговор

  1. Какво прави един HPA и какво мери?
  2. Каква е разликата между requests и limits?
  3. За какво служи maxReplicas?
  4. Защо verifica брои готовите реплики на Deployment-а, а не това, което казва маршрутът?
  5. Заключителният въпрос: HPA казва <unknown>/50%. Обясни защо и какво липсва на Deployment-а.

Следва: в урок 32 същият int-rest се компилира и до нативен вариант и ти мериш на своята машина какво се променя: колко време отнема да се изгради, да стартира и колко памет използва.

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

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