Съдържание на курса
Урок 31 — От лаборатория към проект, в Kubernetes
От Dorian Chávez · съосновател и 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. Предвиди
Отговори на лист хартия:
- Ако една реплика на int-rest резервира 200 милиядра CPU (една пета от ядро) и използва 300, на какъв процент е? С цел 50 % колко реплики би поискал HPA?
- Ако репликата не резервира CPU, спрямо какво изчислява HPA процента?
- Натоварването трае две минути и после свършва. Кога според теб 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 не тества този момент с поръчки във въздуха. За да си сигурен, че нищо не се прекъсва при намаляване, трябва да го тестваш с натоварване, с реалните времена на всяка услуга.
Упражнение: касите в супермаркета
- На хартия: с
requests.cpu: 200m, цел 50 % и максимум 4 колко реплики иска HPA, ако 2 реплики са на 180 %? А ако са на 20 %? - Смени целта на 80 % и пусни
./verifica. До по-малко реплики ли се качи? Колко време отне да намалее? - Ако утре искаше да мащабираш int-bd по този начин, какво би трябвало да пресметнеш отново от урок 24 и с кое число: минимума или максимума на репликите?
Защо е направено така
Какво решихме в този урок, заедно с това, което отхвърлихме, и какво би ни накарало да си променим мнението:
- Учебен Kubernetes с kind, с фиксирани версии, и клъстер, който се изтрива накрая
- В Kubernetes отива int-rest, експортиран с camel export към Camel Quarkus, без да му се променя маршрутът
- HPA мащабира по CPU, измерен като процент от това, което всяка реплика резервира
Преговор
- Какво прави един HPA и какво мери?
- Каква е разликата между
requestsиlimits? - За какво служи
maxReplicas? - Защо verifica брои готовите реплики на Deployment-а, а не това, което казва маршрутът?
- Заключителният въпрос: HPA казва
<unknown>/50%. Обясни защо и какво липсва на Deployment-а.
Следва: в урок 32 същият int-rest се компилира и до нативен вариант и ти мериш на своята машина какво се променя: колко време отнема да се изгради, да стартира и колко памет използва.
Предпочитате имейл? Пишете ни на hola@habil.mx