Це багатосторінковий друкований вигляд цього розділу. Натисність щоб друкувати.
Запуск застосунків
- 1: Запуск застосунку без збереження стану за допомогою Deployment
- 2: Горизонтальне ручне масштабування для Deployment
- 3: Оновлення Deployment без простою
- 4: Запуск одноекземплярного застосунку зі збереженням стану
- 5: Запуск реплікованого застосунку зі збереженням стану
- 6: Масштабування StatefulSet
- 7: Видалення StatefulSet
- 8: Примусове видалення Podʼів StatefulSet
- 9: Покрокове керівництво HorizontalPodAutoscaler
- 10: Вказання бюджету порушень для вашого застосунку
- 11: Отримання доступу до API Kubernetes з Podʼа
1 - Запуск застосунку без збереження стану за допомогою Deployment
На цій сторінці показано, як запустити застосунок за допомогою обʼєкта Deployment у Kubernetes.
Цілі
- Створити Deployment nginx.
- Використати kubectl для виведення інформації про Deployment.
- Оновити Deployment.
Перш ніж ви розпочнете
Вам треба мати кластер Kubernetes, а також інструмент командного рядка kubectl має бути налаштований для роботи з вашим кластером. Рекомендується виконувати ці настанови у кластері, що має щонайменше два вузли, які не виконують роль вузлів управління. Якщо у вас немає кластера, ви можете створити його, за допомогою minikube або використовувати одну з цих пісочниць:
Версія вашого Kubernetes сервера має бути не старішою ніж v1.9.Для перевірки версії введіть kubectl version.
Створення та дослідження Deployment nginx
Ви можете запустити застосунок, створивши обʼєкт Deployment у Kubernetes, а описати Deployment можна у файлі YAML. Наприклад, цей файл YAML описує Deployment, який запускає образ Docker nginx:1.14.2:
apiVersion: apps/v1
kind: Deployment
metadata:
name: nginx-deployment
spec:
selector:
matchLabels:
app: nginx
replicas: 2 # tells deployment to run 2 pods matching the template
template:
metadata:
labels:
app: nginx
spec:
containers:
- name: nginx
image: nginx:1.14.2
ports:
- containerPort: 80
Створіть Deployment на основі файлу YAML:
kubectl apply -f https://k8s.io/examples/application/deployment.yamlВиведіть інформацію про Deployment:
kubectl describe deployment nginx-deploymentВивід подібний до такого:
Name: nginx-deployment Namespace: default CreationTimestamp: Tue, 30 Aug 2016 18:11:37 -0700 Labels: app=nginx Annotations: deployment.kubernetes.io/revision=1 Selector: app=nginx Replicas: 2 desired | 2 updated | 2 total | 2 available | 0 unavailable StrategyType: RollingUpdate MinReadySeconds: 0 RollingUpdateStrategy: 1 max unavailable, 1 max surge Pod Template: Labels: app=nginx Containers: nginx: Image: nginx:1.14.2 Port: 80/TCP Environment: <none> Mounts: <none> Volumes: <none> Conditions: Type Status Reason ---- ------ ------ Available True MinimumReplicasAvailable Progressing True NewReplicaSetAvailable OldReplicaSets: <none> NewReplicaSet: nginx-deployment-1771418926 (2/2 replicas created) No events.Перегляньте Podʼи, створені Deployment:
kubectl get pods -l app=nginxВивід подібний до такого:
NAME READY STATUS RESTARTS AGE nginx-deployment-1771418926-7o5ns 1/1 Running 0 16h nginx-deployment-1771418926-r18az 1/1 Running 0 16hВиведіть інформацію про Pod:
kubectl describe pod <pod-name>де
<pod-name>— це назва одного з ваших Podʼів.
Оновлення Deployment
Ви можете оновити Deployment, застосувавши новий файл YAML. Цей файл YAML вказує, що Deployment слід оновити до nginx 1.16.1.
apiVersion: apps/v1
kind: Deployment
metadata:
name: nginx-deployment
spec:
selector:
matchLabels:
app: nginx
replicas: 2
template:
metadata:
labels:
app: nginx
spec:
containers:
- name: nginx
image: nginx:1.16.1 # Update the version of nginx from 1.14.2 to 1.16.1
ports:
- containerPort: 80
Застосуйте новий файл YAML:
kubectl apply -f https://k8s.io/examples/application/deployment-update.yamlСпостерігайте, як Deployment створює Podʼи з новими назвами й видаляє старі Podʼи:
kubectl get pods -l app=nginx
Масштабування застосунку шляхом збільшення кількості реплік
Ви можете збільшити кількість Podʼів у вашому Deployment, застосувавши новий файл YAML. Цей файл YAML встановлює replicas на 4, що означає, що Deployment повинен мати чотири Podʼи:
apiVersion: apps/v1
kind: Deployment
metadata:
name: nginx-deployment
spec:
selector:
matchLabels:
app: nginx
replicas: 4 # Update the replicas from 2 to 4
template:
metadata:
labels:
app: nginx
spec:
containers:
- name: nginx
image: nginx:1.16.1
ports:
- containerPort: 80
Застосуйте новий файл YAML:
kubectl apply -f https://k8s.io/examples/application/deployment-scale.yamlПеревірте, що Deployment має чотири Podʼи:
kubectl get pods -l app=nginxВивід подібний до такого:
NAME READY STATUS RESTARTS AGE nginx-deployment-148880595-4zdqq 1/1 Running 0 25s nginx-deployment-148880595-6zgi1 1/1 Running 0 25s nginx-deployment-148880595-fxcez 1/1 Running 0 2m nginx-deployment-148880595-rwovn 1/1 Running 0 2m
Докладні процедури масштабування, зокрема зменшення масштабу й масштабування до нуля, дивіться в розділі Масштабування Deployment вручну.
Видалення Deployment
Видаліть Deployment за назвою:
kubectl delete deployment nginx-deployment
ReplicationControllers — старий спосіб
Рекомендований спосіб створення реплікованого застосунку — використовувати Deployment, який своєю чергою використовує ReplicaSet. До того як у Kubernetes зʼявилися Deployment і ReplicaSet, репліковані застосунки налаштовували за допомогою ReplicationController.
Що далі
- Дізнайтеся більше про обʼєкти Deployment.
- Дізнайтеся, як оновити Deployment без простою.
2 - Горизонтальне ручне масштабування для Deployment
На цій сторінці показано, як вручну масштабувати Deployment горизонтально, змінюючи кількість його реплік. Ручне масштабування дає змогу безпосередньо контролювати кількість запущених Podʼів для передбачуваних змін навантаження або керування витратами.
Це відрізняється від вертикального масштабування, за якого кількість реплік лишається незмінною, але змінюється кількість ресурсів, доступних кожному Podʼу.
Цілі
- Масштабування Deployment вгору для обробки більшого трафіку.
- Зменшення масштабу Deployment для економії ресурсів.
- Масштабування Deployment до нуля для тимчасового призупинення робочого навантаження.
- Розуміння, коли використовувати ручне масштабування, а коли HorizontalPodAutoscaler.
Перш ніж ви розпочнете
Вам треба мати кластер Kubernetes, а також інструмент командного рядка kubectl має бути налаштований для роботи з вашим кластером. Рекомендується виконувати ці настанови у кластері, що має щонайменше два вузли, які не виконують роль вузлів управління. Якщо у вас немає кластера, ви можете створити його, за допомогою minikube або використовувати одну з цих пісочниць:
Вам потрібен наявний Deployment. Якщо у вас його немає і ви просто хочете попрактикуватися, можна створити Deployment nginx зі сторінки Запуск застосунку без збереження стану за допомогою Deployment:
kubectl apply -f https://k8s.io/examples/application/deployment.yaml
Перевірте, що Deployment запускає два Podʼи:
kubectl get deployment nginx-deployment
Вивід подібний до такого:
NAME READY UP-TO-DATE AVAILABLE AGE
nginx-deployment 2/2 2 2 10s
Масштабування Deployment вгору
Існує кілька способів змінити кількість реплік наявного Deployment.
Масштабування вгору за допомогою kubectl scale
Використовуйте kubectl scale, щоб встановити кількість реплік:
kubectl scale deployment/nginx-deployment --replicas=4
Вивід подібний до такого:
deployment.apps/nginx-deployment scaled
Перевірте, що Deployment має чотири Podʼи:
kubectl get deployment nginx-deployment
Вивід подібний до такого:
NAME READY UP-TO-DATE AVAILABLE AGE
nginx-deployment 4/4 4 4 1m
Декларативне масштабування за допомогою kubectl apply
Замість виконання імперативної команди можна оновити файл маніфесту й застосувати його. Цей підхід добре підходить для робочих процесів із конфігурацією під контролем версій.
Збережіть поточну конфігурацію Deployment у локальний файл:
kubectl get deployment nginx-deployment -o yaml > /tmp/nginx-deployment.yaml
Відредагуйте /tmp/nginx-deployment.yaml і змініть .spec.replicas на 4.
Перед застосуванням порівняйте свої локальні зміни зі станом кластера:
kubectl diff -f /tmp/nginx-deployment.yaml
Застосуйте відредагований маніфест:
kubectl apply -f /tmp/nginx-deployment.yaml
Зменшення масштабу Deployment
Щоб зменшити кількість Podʼів, встановіть --replicas на менше значення:
kubectl scale deployment/nginx-deployment --replicas=2
Kubernetes коректно завершує зайві Podʼи, дотримуючись налаштування terminationGracePeriodSeconds кожного Podʼа.
Перевірте, що Deployment має два Podʼи:
kubectl get pods -l app=nginx
Вивід подібний до такого:
NAME READY STATUS RESTARTS AGE
nginx-deployment-66b6c48dd5-7gl6h 1/1 Running 0 2m
nginx-deployment-66b6c48dd5-v8mkd 1/1 Running 0 2m
Масштабування до нуля
Ви можете масштабувати Deployment до нуля, щоб тимчасово призупинити робоче навантаження, не видаляючи сам Deployment:
kubectl scale deployment/nginx-deployment --replicas=0
Перевірте, що жоден Pod не працює:
kubectl get deployment nginx-deployment
Вивід подібний до такого:
NAME READY UP-TO-DATE AVAILABLE AGE
nginx-deployment 0/0 0 0 5m
Примітка:
Масштабування до нуля видаляє всі Podʼи, але зберігає Deployment і його ReplicaSet. Ви можете знову масштабувати вгору в будь-який час, встановивши--replicas на додатне число.Поширені випадки використання масштабування до нуля:
- Тимчасове призупинення робочого навантаження для економії ресурсів
- Вікна налагодження або обслуговування
- Контроль витрат у середовищах розробки або тестування
Інші способи зміни кількості реплік
Окрім kubectl scale, ви можете змінити .spec.replicas за допомогою kubectl edit або kubectl patch.
Масштабування за допомогою kubectl edit
kubectl edit deployment nginx-deployment
Змініть поле .spec.replicas у редакторі, потім збережіть і вийдіть.
Масштабування за допомогою kubectl patch
Ви можете оновити .spec.replicas за допомогою strategic merge patch:
kubectl patch deployment nginx-deployment -p '{"spec":{"replicas":4}}'
Для скриптів використовуйте патч JSON із попередньою перевіркою. Наведена нижче команда встановлює кількість реплік на 4, але лише якщо поточна кількість дорівнює 2:
kubectl patch deployment nginx-deployment --type=json -p='[
{"op": "test", "path": "/spec/replicas", "value": 2},
{"op": "replace", "path": "/spec/replicas", "value": 4}
]'
Операція test призводить до збою патчу, якщо поточне значення не збігається, що запобігає небажаним змінам, коли кілька людей або скриптів змінюють той самий Deployment.
Коли використовувати ручне, а коли автоматичне масштабування
| Аспект | Ручне масштабування | Автоматичне масштабування (HPA) |
|---|---|---|
| Найкраще для | Передбачуваних, запланованих або одноразових змін навантаження | Змінного або непередбачуваного попиту |
| Як це працює | Ви встановлюєте .spec.replicas безпосередньо | HPA регулює кількість реплік на основі спостережуваних метрик |
| Час реакції | Негайно після виконання команди | Реагує на метрики з невеликою затримкою |
| Врахування метрик | Відсутнє — кількість реплік вирішуєте ви | Відстежує CPU, памʼять або власні метрики |
| Обслуговування | Потребує ручного втручання для налаштування | Працює автономно після налаштування |
Увага:
Якщо HorizontalPodAutoscaler керує Deployment, не встановлюйте репліки вручну. HPA постійно узгоджує кількість реплік і перевизначає будь-які ручні зміни.Очищення
Видаліть Deployment:
kubectl delete deployment nginx-deployment
Що далі
- Дізнайтеся більше про Deployments.
- Пройдіть матеріал Горизонтальне автомасштабування Podʼів.
- Дізнайтеся, як масштабувати StatefulSet.
- Дізнайтеся про керування ресурсами.
3 - Оновлення Deployment без простою
На цій сторінці показано, як оновити запущений Deployment до нової версії за допомогою поетапного оновлення. Поетапне оновлення поступово замінює старі Podʼи новими, тому ваш застосунок залишається доступним протягом усього процесу.
Цілі
- Запустити поетапне оновлення Deployment.
- Стежити за перебігом розгортання.
- Призупинити та відновити розгортання.
- Налаштувати параметри стратегії поетапного оновлення.
- (За потреби) Відкотитися до попередньої ревізії.
Перш ніж ви розпочнете
Вам треба мати кластер Kubernetes, а також інструмент командного рядка kubectl має бути налаштований для роботи з вашим кластером. Рекомендується виконувати ці настанови у кластері, що має щонайменше два вузли, які не виконують роль вузлів управління. Якщо у вас немає кластера, ви можете створити його, за допомогою minikube або використовувати одну з цих пісочниць:
Вам потрібен наявний Deployment. Якщо у вас його немає, створіть Deployment nginx зі сторінки Запуск застосунку без збереження стану за допомогою Deployment:
kubectl apply -f https://k8s.io/examples/application/deployment.yaml
Перевірте, що Deployment запускає два Podʼи:
kubectl get deployment nginx-deployment
Вивід подібний до такого:
NAME READY UP-TO-DATE AVAILABLE AGE
nginx-deployment 2/2 2 2 10s
Виконання поетапного оновлення
Будь-яка зміна в полі .spec.template Deployment запускає поетапне оновлення. Kubernetes створює нові Podʼи з оновленою конфігурацією й поступово завершує старі Podʼи.
Оновлення за допомогою kubectl apply
Ви можете запустити поетапне оновлення, відредагувавши маніфест Deployment і застосувавши зміну. Цей підхід добре працює, якщо ви зберігаєте маніфести в системі контролю версій.
Експортуйте поточний Deployment у локальний файл:
kubectl get deployment nginx-deployment -o yaml > /tmp/nginx-deployment.yaml
Відредагуйте /tmp/nginx-deployment.yaml і змініть .spec.template.spec.containers[0].image з nginx:1.14.2 на nginx:1.16.1.
Перед застосуванням порівняйте свої локальні зміни зі станом кластера:
kubectl diff -f /tmp/nginx-deployment.yaml
Вивід подібний до такого:
diff -u -N /tmp/LIVE/apps.v1.Deployment.default.nginx-deployment /tmp/MERGED/apps.v1.Deployment.default.nginx-deployment
--- /tmp/LIVE/apps.v1.Deployment...
+++ /tmp/MERGED/apps.v1.Deployment...
@@ -29,7 +29,7 @@
containers:
- - image: nginx:1.14.2
+ - image: nginx:1.16.1
name: nginx
Застосуйте оновлений маніфест:
kubectl apply -f /tmp/nginx-deployment.yaml
Оновлення лише образу контейнера
Щоб оновити образ контейнера без редагування файлу маніфесту, використовуйте kubectl set image:
kubectl set image deployment/nginx-deployment nginx=nginx:1.16.1
Вивід подібний до такого:
deployment.apps/nginx-deployment image updated
Перевірте, що образ було оновлено:
kubectl get deployment nginx-deployment -o jsonpath='{.spec.template.spec.containers[0].image}'
Вивід подібний до такого:
nginx:1.16.1
Відстеження перебігу розгортання
Використовуйте kubectl rollout status, щоб стежити за перебігом поетапного оновлення:
kubectl rollout status deployment/nginx-deployment
Вивід подібний до такого:
Waiting for deployment "nginx-deployment" rollout to finish: 1 out of 2 new replicas have been updated...
Waiting for deployment "nginx-deployment" rollout to finish: 1 out of 2 new replicas have been updated...
Waiting for deployment "nginx-deployment" rollout to finish: 1 old replicas are pending termination...
deployment "nginx-deployment" successfully rolled out
Після завершення розгортання перевірте Deployment:
kubectl get deployment nginx-deployment
Вивід подібний до такого:
NAME READY UP-TO-DATE AVAILABLE AGE
nginx-deployment 2/2 2 2 2m
Призупинення та відновлення розгортання
Ви можете призупинити розгортання, щоб перевірити часткове оновлення або обʼєднати кілька змін в одне розгортання.
Призупинення розгортання
kubectl rollout pause deployment/nginx-deployment
Вивід подібний до такого:
deployment.apps/nginx-deployment paused
Виконання додаткових змін під час призупинення
Поки розгортання призупинено, ви можете вносити додаткові зміни. Ці зміни не запускають нове розгортання, доки ви його не відновите:
kubectl set image deployment/nginx-deployment nginx=nginx:1.17.0
Примітка:
Ви можете внести кілька змін у призупинений Deployment. Kubernetes застосовує всі зміни разом, коли ви відновлюєте розгортання.Відновлення розгортання
kubectl rollout resume deployment/nginx-deployment
Вивід подібний до такого:
deployment.apps/nginx-deployment resumed
Перевірте, що розгортання завершується:
kubectl rollout status deployment/nginx-deployment
Налаштування стратегії поетапного оновлення
Deployments підтримують два типи стратегій оновлення:
- RollingUpdate (стандартно): поступово замінює старі Podʼи новими.
- Recreate: спочатку завершує всі наявні Podʼи, а потім створює нові. Це призводить до простою.
Для стратегії RollingUpdate ці параметри контролюють, як Kubernetes виконує оновлення:
| Параметр | Що контролює | Стандартно | Приклад |
|---|---|---|---|
maxUnavailable | Максимальна кількість Podʼів, які можуть бути недоступні під час оновлення | 25% | 1 або 25% |
maxSurge | Максимальна кількість додаткових Podʼів, які можуть бути створені під час оновлення | 25% | 1 або 25% |
Примітка:
maxUnavailable та maxSurge приймають абсолютне число або відсоток. Kubernetes обчислює відсотки від бажаної кількості реплік, округлюючи вниз для maxUnavailable та округлюючи вгору для maxSurge.Для налаштування цих параметрів використовуйте kubectl patch:
kubectl patch deployment nginx-deployment -p \
'{"spec":{"strategy":{"rollingUpdate":{"maxUnavailable":"25%","maxSurge":"25%"}}}}'
Ви також можете задати ці поля в маніфесті Deployment у .spec.strategy.rollingUpdate. Докладні приклади дивіться в розділах max unavailable і max surge документації з концепцій Deployment.
Виявлення розгортання, що застрягло
Якщо розгортання не просувається протягом часу, вказаного в .spec.progressDeadlineSeconds (стандартно: 600 секунд), Kubernetes позначає стан Deployment Progressing як False. Перевірити цей стан можна, описавши Deployment:
kubectl describe deployment nginx-deployment
Шукайте стан Progressing у розділі Conditions виводу. Розгортання, що застрягло, зазвичай вказує на те, що нові Podʼи не можуть запуститися. Розділ Events у виводі може допомогти діагностувати проблему.
Відкочування до попередньої ревізії
Якщо нова версія спричиняє проблеми, ви можете відкотитися до попередньої ревізії.
Перегляд історії розгортання
kubectl rollout history deployment/nginx-deployment
Вивід подібний до такого:
deployment.apps/nginx-deployment
REVISION CHANGE-CAUSE
1 <none>
2 <none>
Примітка:
СтовпецьCHANGE-CAUSE показує значення анотації kubernetes.io/change-cause на момент кожної ревізії. Ця анотація не встановлюється автоматично, але якщо ви використовуєте автоматизоване рішення для керування Deployments, ваш інструмент може записувати в цю анотацію певний текст.Відкочування до попередньої ревізії
kubectl rollout undo deployment/nginx-deployment
Вивід подібний до такого:
deployment.apps/nginx-deployment rolled back
Відкочування до конкретної ревізії
kubectl rollout undo deployment/nginx-deployment --to-revision=1
Перевірте, що відкочування завершується:
kubectl rollout status deployment/nginx-deployment
Примітка:
Історія ревізій Deployment зберігається в ReplicaSets, якими він керує. Стандартно Kubernetes зберігає 10 старих ReplicaSets. Ви можете змінити це обмеження, встановивши.spec.revisionHistoryLimit у маніфесті Deployment. Значення 0 повністю вимикає відкочування.Очищення
Видаліть Deployment:
kubectl delete deployment nginx-deployment
Що далі
- Дізнайтеся більше про Deployments.
- Дізнайтеся, як масштабувати Deployment вручну.
- Пройдіть матеріал Горизонтальне автомасштабування Podʼів.
- Дізнайтеся, як виконати поетапне оновлення DaemonSet.
4 - Запуск одноекземплярного застосунку зі збереженням стану
На цій сторінці показано, як запустити одноекземплярний застосунок зі збереженням стану в Kubernetes, використовуючи PersistentVolume та Deployment. Застосунок — MySQL.
Цілі
- Створити PersistentVolume, що посилається на диск у вашому середовищі.
- Створити Deployment MySQL.
- Відкрити доступ до MySQL іншим Podʼам у кластері за відомим DNS-імʼям.
Перш ніж ви розпочнете
Вам треба мати кластер Kubernetes, а також інструмент командного рядка kubectl має бути налаштований для роботи з вашим кластером. Рекомендується виконувати ці настанови у кластері, що має щонайменше два вузли, які не виконують роль вузлів управління. Якщо у вас немає кластера, ви можете створити його, за допомогою minikube або використовувати одну з цих пісочниць:
Для перевірки версії введіть
kubectl version.Вам потрібно мати або динамічний provisioner PersistentVolume з типовим StorageClass, або самостійно статично надати PersistentVolumes, щоб задовольнити PersistentVolumeClaims, які використовуються тут.
Розгортання MySQL
Ви можете запустити застосунок зі збереженням стану, створивши Deployment Kubernetes і підʼєднавши його до наявного PersistentVolume за допомогою PersistentVolumeClaim. Наприклад, цей файл YAML описує Deployment, який запускає MySQL і посилається на PersistentVolumeClaim. Файл визначає монтування тому для /var/lib/mysql, а потім створює PersistentVolumeClaim, що шукає том на 20G. Цю заявку задовольняє будь-який наявний том, що відповідає вимогам, або динамічний provisioner.
Примітка: пароль визначено у файлі конфігурації yaml, і це небезпечно. Безпечне рішення дивіться в розділі Kubernetes Secrets.
apiVersion: v1
kind: Service
metadata:
name: mysql
spec:
ports:
- port: 3306
selector:
app: mysql
clusterIP: None
---
apiVersion: apps/v1
kind: Deployment
metadata:
name: mysql
spec:
selector:
matchLabels:
app: mysql
strategy:
type: Recreate
template:
metadata:
labels:
app: mysql
spec:
containers:
- image: mysql:9
name: mysql
env:
# Use secret in real usage
- name: MYSQL_ROOT_PASSWORD
value: password
ports:
- containerPort: 3306
name: mysql
volumeMounts:
- name: mysql-persistent-storage
mountPath: /var/lib/mysql
volumes:
- name: mysql-persistent-storage
persistentVolumeClaim:
claimName: mysql-pv-claim
apiVersion: v1
kind: PersistentVolume
metadata:
name: mysql-pv-volume
labels:
type: local
spec:
storageClassName: manual
capacity:
storage: 20Gi
accessModes:
- ReadWriteOnce
hostPath:
path: "/mnt/data"
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
name: mysql-pv-claim
spec:
storageClassName: manual
accessModes:
- ReadWriteOnce
resources:
requests:
storage: 20Gi
Розгорніть PV та PVC з файлу YAML:
kubectl apply -f https://k8s.io/examples/application/mysql/mysql-pv.yamlРозгорніть вміст файлу YAML:
kubectl apply -f https://k8s.io/examples/application/mysql/mysql-deployment.yamlВиведіть інформацію про Deployment:
kubectl describe deployment mysqlВивід подібний до такого:
Name: mysql Namespace: default CreationTimestamp: Tue, 01 Nov 2016 11:18:45 -0700 Labels: app=mysql Annotations: deployment.kubernetes.io/revision=1 Selector: app=mysql Replicas: 1 desired | 1 updated | 1 total | 0 available | 1 unavailable StrategyType: Recreate MinReadySeconds: 0 Pod Template: Labels: app=mysql Containers: mysql: Image: mysql:9 Port: 3306/TCP Environment: MYSQL_ROOT_PASSWORD: password Mounts: /var/lib/mysql from mysql-persistent-storage (rw) Volumes: mysql-persistent-storage: Type: PersistentVolumeClaim (a reference to a PersistentVolumeClaim in the same namespace) ClaimName: mysql-pv-claim ReadOnly: false Conditions: Type Status Reason ---- ------ ------ Available False MinimumReplicasUnavailable Progressing True ReplicaSetUpdated OldReplicaSets: <none> NewReplicaSet: mysql-63082529 (1/1 replicas created) Events: FirstSeen LastSeen Count From SubobjectPath Type Reason Message --------- -------- ----- ---- ------------- -------- ------ ------- 33s 33s 1 {deployment-controller } Normal ScalingReplicaSet Scaled up replica set mysql-63082529 to 1Перегляньте Podʼи, створені Deployment:
kubectl get pods -l app=mysqlВивід подібний до такого:
NAME READY STATUS RESTARTS AGE mysql-63082529-2z3ki 1/1 Running 0 3mПеревірте PersistentVolumeClaim:
kubectl describe pvc mysql-pv-claimВивід подібний до такого:
Name: mysql-pv-claim Namespace: default StorageClass: Status: Bound Volume: mysql-pv-volume Labels: <none> Annotations: pv.kubernetes.io/bind-completed=yes pv.kubernetes.io/bound-by-controller=yes Capacity: 20Gi Access Modes: RWO Events: <none>
Доступ до екземпляра MySQL
Наведений вище файл YAML створює сервіс, який дає іншим Podʼам у кластері змогу отримувати доступ до бази даних. Параметр Service clusterIP: None дозволяє DNS-імені Service розвʼязуватися безпосередньо в IP-адресу Podʼа. Це оптимально, коли за Service стоїть лише один Pod і ви не маєте наміру збільшувати кількість Podʼів.
Запустіть клієнта MySQL, щоб підʼєднатися до сервера:
kubectl run -it --rm --image=mysql:9 --restart=Never mysql-client -- mysql -h mysql -ppassword
Ця команда створює в кластері новий Pod, у якому працює клієнт MySQL, і підʼєднує його до сервера через Service. Якщо зʼєднання встановлено, значить, ваша база даних MySQL зі збереженням стану запущена й працює.
Waiting for pod default/mysql-client-274442439-zyp6i to be running, status is Pending, pod ready: false
If you don't see a command prompt, try pressing enter.
mysql>
Оновлення
Образ або будь-яку іншу частину Deployment можна оновити як зазвичай за допомогою команди kubectl apply. Ось деякі запобіжні заходи, специфічні для застосунків зі збереженням стану:
- Не масштабуйте застосунок. Це налаштування призначене лише для одноекземплярних застосунків. Базовий PersistentVolume можна змонтувати лише в один Pod. Про кластеризовані застосунки зі збереженням стану дивіться документацію StatefulSet.
- Використовуйте
strategy:type: Recreateу файлі конфігурації YAML для Deployment. Це вказує Kubernetes не використовувати поетапні оновлення. Поетапні оновлення не працюватимуть, оскільки одночасно не може працювати більше одного Podʼа. СтратегіяRecreateзупинить перший Pod перед створенням нового з оновленою конфігурацією.
Видалення Deployment
Видаліть розгорнуті обʼєкти за назвою:
kubectl delete deployment,svc mysql
kubectl delete pvc mysql-pv-claim
kubectl delete pv mysql-pv-volume
Якщо ви надали PersistentVolume вручну, вам також потрібно вручну видалити його й звільнити базовий ресурс. Якщо ви використовували динамічний provisioner, він автоматично видаляє PersistentVolume, коли бачить, що ви видалили PersistentVolumeClaim. Деякі динамічні provisioners (наприклад, для EBS і PD) також звільняють базовий ресурс під час видалення PersistentVolume.
Що далі
Дізнайтеся більше про обʼєкти Deployment.
Дізнайтеся більше про розгортання застосунків
5 - Запуск реплікованого застосунку зі збереженням стану
Ця сторінка показує, як запустити реплікований застосунок зі збереженням стану (StatefulSet). Цей застосунок — реплікована база даних MySQL. У топології цього прикладу є один головний сервер і кілька реплік, що використовують асинхронну реплікацію на основі рядків.
Примітка:
Ця конфігурація не призначена для промислового середовища. Налаштування MySQL залишаються на небезпечних типових значеннях, щоб зосередитися на загальних патернах запуску застосунків зі збереженням стану в Kubernetes.Перш ніж ви розпочнете
Вам треба мати кластер Kubernetes, а також інструмент командного рядка kubectl має бути налаштований для роботи з вашим кластером. Рекомендується виконувати ці настанови у кластері, що має щонайменше два вузли, які не виконують роль вузлів управління. Якщо у вас немає кластера, ви можете створити його, за допомогою minikube або використовувати одну з цих пісочниць:
Вам потрібно мати або динамічний provisioner PersistentVolume з типовим StorageClass, або самостійно статично надати PersistentVolumes, щоб задовольнити PersistentVolumeClaims, які використовуються тут.
- Цей підручник передбачає, що ви знаєте про Постійні томи та StatefulSets, а також інші основні поняття, такі як Pod, Service та ConfigMap.
- Трохи знань MySQL корисні, але цей підручник має на меті представити загальні патерни, які можуть бути корисними для інших систем.
- Ви використовуєте простір імен default або інший простір імен, в якому відсутні обʼєкти, що конфліктують.
- У вас має бути AMD64-сумісний процесор.
Цілі
- Розгорнути репліковану топологію MySQL за допомогою StatefulSet.
- Надіслати клієнтський трафік MySQL.
- Спостерігати стійкість до перерв у роботі.
- Масштабувати StatefulSet вгору та вниз.
Розгортання MySQL
Приклад розгортання складається з ConfigMap, двох Service та StatefulSet.
Створення ConfigMap
Створіть ConfigMap із наступного файлу конфігурації YAML:
apiVersion: v1
kind: ConfigMap
metadata:
name: mysql
labels:
app: mysql
app.kubernetes.io/name: mysql
data:
primary.cnf: |
# Apply this config only on the primary.
[mysqld]
log-bin
replica.cnf: |
# Apply this config only on replicas.
[mysqld]
super-read-only
kubectl apply -f https://k8s.io/examples/application/mysql/mysql-configmap.yaml
Цей ConfigMap надає перевизначення для my.cnf, що дозволяє вам незалежно керувати конфігурацією на головному сервері MySQL та його репліках. У цьому випадку ви хочете, щоб головний сервер міг надавати логи реплікації реплікам, а репліки відхиляли будь-які записи, які надходять не через реплікацію.
Немає нічого особливого у самому ConfigMap, що зумовлює застосування різних частин до різних Podʼів. Кожен Pod вирішує, яку частину дивитися при ініціалізації, на основі інформації, що надає контролер StatefulSet.
Створення Service
Створіть Service із наступного файлу конфігурації YAML:
# Headless service for stable DNS entries of StatefulSet members.
apiVersion: v1
kind: Service
metadata:
name: mysql
labels:
app: mysql
app.kubernetes.io/name: mysql
spec:
ports:
- name: mysql
port: 3306
clusterIP: None
selector:
app: mysql
---
# Client service for connecting to any MySQL instance for reads.
# For writes, you must instead connect to the primary: mysql-0.mysql.
apiVersion: v1
kind: Service
metadata:
name: mysql-read
labels:
app: mysql
app.kubernetes.io/name: mysql
readonly: "true"
spec:
ports:
- name: mysql
port: 3306
selector:
app: mysql
kubectl apply -f https://k8s.io/examples/application/mysql/mysql-services.yaml
Headless Service надає місце для DNS-записів, які контролери StatefulSet створюють для кожного Podʼа, що є частиною набору. Оскільки headless Service називається mysql, Podʼи доступні через розвʼязання імені <pod-name>.mysql з будь-якого іншого Podʼа в тому самому кластері Kubernetes і просторі імен.
Клієнтський Service, з назвою mysql-read, є звичайним Service з власним кластерним IP, який розподіляє підключення між всіма Podʼами MySQL, які повідомляють про готовність. Набір потенційних точок доступу включає головний сервер MySQL та всі репліки.
Зверніть увагу, що лише запити на читання можуть використовувати клієнтський Service з балансуванням навантаження. Оскільки існує лише один головний сервер MySQL, клієнти повинні підключатися безпосередньо до головного Podʼа MySQL (через його DNS-запис у headless Service) для виконання записів.
Створення StatefulSet
Наостанок, створіть StatefulSet із наступного файлу конфігурації YAML:
apiVersion: apps/v1
kind: StatefulSet
metadata:
name: mysql
spec:
selector:
matchLabels:
app: mysql
app.kubernetes.io/name: mysql
serviceName: mysql
replicas: 3
template:
metadata:
labels:
app: mysql
app.kubernetes.io/name: mysql
spec:
initContainers:
- name: init-mysql
image: mysql:5.7
command:
- bash
- "-c"
- |
set -ex
# Generate mysql server-id from pod ordinal index.
[[ $HOSTNAME =~ -([0-9]+)$ ]] || exit 1
ordinal=${BASH_REMATCH[1]}
echo [mysqld] > /mnt/conf.d/server-id.cnf
# Add an offset to avoid reserved server-id=0 value.
echo server-id=$((100 + $ordinal)) >> /mnt/conf.d/server-id.cnf
# Copy appropriate conf.d files from config-map to emptyDir.
if [[ $ordinal -eq 0 ]]; then
cp /mnt/config-map/primary.cnf /mnt/conf.d/
else
cp /mnt/config-map/replica.cnf /mnt/conf.d/
fi
volumeMounts:
- name: conf
mountPath: /mnt/conf.d
- name: config-map
mountPath: /mnt/config-map
- name: clone-mysql
image: gcr.io/google-samples/xtrabackup:1.0
command:
- bash
- "-c"
- |
set -ex
# Skip the clone if data already exists.
[[ -d /var/lib/mysql/mysql ]] && exit 0
# Skip the clone on primary (ordinal index 0).
[[ `hostname` =~ -([0-9]+)$ ]] || exit 1
ordinal=${BASH_REMATCH[1]}
[[ $ordinal -eq 0 ]] && exit 0
# Clone data from previous peer.
ncat --recv-only mysql-$(($ordinal-1)).mysql 3307 | xbstream -x -C /var/lib/mysql
# Prepare the backup.
xtrabackup --prepare --target-dir=/var/lib/mysql
volumeMounts:
- name: data
mountPath: /var/lib/mysql
subPath: mysql
- name: conf
mountPath: /etc/mysql/conf.d
containers:
- name: mysql
image: mysql:5.7
env:
- name: MYSQL_ALLOW_EMPTY_PASSWORD
value: "1"
ports:
- name: mysql
containerPort: 3306
volumeMounts:
- name: data
mountPath: /var/lib/mysql
subPath: mysql
- name: conf
mountPath: /etc/mysql/conf.d
resources:
requests:
cpu: 500m
memory: 1Gi
livenessProbe:
exec:
command: ["mysqladmin", "ping"]
initialDelaySeconds: 30
periodSeconds: 10
timeoutSeconds: 5
readinessProbe:
exec:
# Перевірити, що ми можемо виконувати запити через TCP (skip-networking вимкнено).
command: ["mysql", "-h", "127.0.0.1", "-e", "SELECT 1"]
initialDelaySeconds: 5
periodSeconds: 2
timeoutSeconds: 1
- name: xtrabackup
image: gcr.io/google-samples/xtrabackup:1.0
ports:
- name: xtrabackup
containerPort: 3307
command:
- bash
- "-c"
- |
set -ex
cd /var/lib/mysql
# Determine binlog position of cloned data, if any.
if [[ -f xtrabackup_slave_info && "x$(<xtrabackup_slave_info)" != "x" ]]; then
# XtraBackup already generated a partial "CHANGE MASTER TO" query
# because we're cloning from an existing replica. (Need to remove the tailing semicolon!)
cat xtrabackup_slave_info | sed -E 's/;$//g' > change_master_to.sql.in
# Ignore xtrabackup_binlog_info in this case (it's useless).
rm -f xtrabackup_slave_info xtrabackup_binlog_info
elif [[ -f xtrabackup_binlog_info ]]; then
# We're cloning directly from primary. Parse binlog position.
[[ `cat xtrabackup_binlog_info` =~ ^(.*?)[[:space:]]+(.*?)$ ]] || exit 1
rm -f xtrabackup_binlog_info xtrabackup_slave_info
echo "CHANGE MASTER TO MASTER_LOG_FILE='${BASH_REMATCH[1]}',\
MASTER_LOG_POS=${BASH_REMATCH[2]}" > change_master_to.sql.in
fi
# Check if we need to complete a clone by starting replication.
if [[ -f change_master_to.sql.in ]]; then
echo "Waiting for mysqld to be ready (accepting connections)"
until mysql -h 127.0.0.1 -e "SELECT 1"; do sleep 1; done
echo "Initializing replication from clone position"
mysql -h 127.0.0.1 \
-e "$(<change_master_to.sql.in), \
MASTER_HOST='mysql-0.mysql', \
MASTER_USER='root', \
MASTER_PASSWORD='', \
MASTER_CONNECT_RETRY=10; \
START SLAVE;" || exit 1
# In case of container restart, attempt this at-most-once.
mv change_master_to.sql.in change_master_to.sql.orig
fi
# Start a server to send backups when requested by peers.
exec ncat --listen --keep-open --send-only --max-conns=1 3307 -c \
"xtrabackup --backup --slave-info --stream=xbstream --host=127.0.0.1 --user=root"
volumeMounts:
- name: data
mountPath: /var/lib/mysql
subPath: mysql
- name: conf
mountPath: /etc/mysql/conf.d
resources:
requests:
cpu: 100m
memory: 100Mi
volumes:
- name: conf
emptyDir: {}
- name: config-map
configMap:
name: mysql
volumeClaimTemplates:
- metadata:
name: data
spec:
accessModes: ["ReadWriteOnce"]
resources:
requests:
storage: 10Gi
kubectl apply -f https://k8s.io/examples/application/mysql/mysql-statefulset.yaml
Ви можете спостерігати за процесом запуску, виконавши:
kubectl get pods -l app=mysql --watch
Через деякий час ви повинні побачити, що всі 3 Podʼи стануть Running:
NAME READY STATUS RESTARTS AGE
mysql-0 2/2 Running 0 2m
mysql-1 2/2 Running 0 1m
mysql-2 2/2 Running 0 1m
Натисніть Ctrl+C, щоб скасувати перегляд.
Примітка:
Якщо ви не бачите жодних змін, переконайтеся, що у вас увімкнений динамічний provisioner PersistentVolume, як зазначено у передумовах.Цей маніфест використовує різноманітні техніки для керування Podʼами зі збереженням стану в межах StatefulSet. У наступному розділі підкреслено деякі з цих технік, щоб пояснити, що відбувається під час створення Podʼів StatefulSet.
Розуміння ініціалізації Podʼа зі збереженням стану
Контролер StatefulSet запускає Podʼи по одному, в порядку їх індексів. Він чекає, доки кожен Pod не повідомить про готовність, перш ніж запустити наступний.
Крім того, контролер призначає кожному Podʼу унікальне, стабільне імʼя у формі <statefulset-name>-<ordinal-index>, в результаті отримуємо Podʼи з іменами mysql-0, mysql-1 та mysql-2.
Шаблон Podʼа у вищенаведеному маніфесті StatefulSet використовує ці властивості, щоб здійснити впорядкований запуск реплікації MySQL.
Створення конфігурації
Перед запуском будь-яких контейнерів у специфікації Podʼа, спочатку Pod запускає будь-які контейнери ініціалізації у визначеному порядку.
Перший контейнер ініціалізації, init-mysql, генерує спеціальні конфігураційні файли MySQL на основі порядкового індексу.
Скрипт визначає свій власний порядковий індекс, витягуючи його з кінця імені Podʼа, яке повертається командою hostname. Потім він зберігає порядковий індекс (з числовим зміщенням для уникнення зарезервованих значень) у файлі з назвою server-id.cnf в теці conf.d MySQL. Це перетворює унікальний, стабільний ідентифікатор, наданий StatefulSet, у домен ідентифікаторів серверів MySQL, які вимагають таких же властивостей.
Скрипт у контейнері init-mysql також застосовує або primary.cnf, або replica.cnf з ConfigMap, копіюючи вміст у conf.d. Оскільки у топології цього прикладу є лише один головний сервер MySQL та будь-яка кількість реплік, скрипт призначає порядковий індекс 0 головному серверу, а всі інші — репліками. Разом з гарантією контролера StatefulSet щодо порядку розгортання, це забезпечує готовність головного сервера MySQL перед створенням реплік, щоб вони могли почати реплікацію.
Клонування наявних даних
Загалом, коли новий Pod приєднується до набору як репліка, він повинен припускати, що головний сервер MySQL може вже містити дані. Також він повинен припускати, що логи реплікації можуть не сягати самого початку. Ці консервативні припущення є ключем до того, щоб запущений StatefulSet міг масштабуватися вгору та вниз з часом, а не залишатися фіксованим на своєму початковому розмірі.
Другий контейнер ініціалізації, з назвою clone-mysql, виконує операцію клонування на реплікаційному Podʼі першого разу, коли він запускається на порожньому PersistentVolume. Це означає, що він копіює всі наявні дані з іншого працюючого Podʼа, таким чином, його локальний стан є достатньо консистентним для початку реплікації з головного сервера.
MySQL сам по собі не надає механізму для цього, тому приклад використовує популярний відкритий інструмент — Percona XtraBackup. Під час клонування сервер-джерело MySQL може мати знижену продуктивність. Щоб мінімізувати вплив на головний сервер MySQL, скрипт вказує кожному Podʼу отримувати дані з Podʼа, чий порядковий індекс на одиницю менший. Це працює через те, що контролер StatefulSet завжди гарантує, що Pod N є готовим перед запуском Podʼа N+1.
Початок реплікації
Після успішного завершення контейнерів ініціалізації запускаються звичайні контейнери. Podʼи MySQL складаються з контейнера mysql, в якому працює фактичний сервер mysqld, та контейнера xtrabackup, який діє як sidecar.
Sidecar xtrabackup переглядає клоновані файли даних і визначає, чи необхідно ініціалізувати реплікацію MySQL на репліці. У цьому випадку він чекає, доки mysqld буде готовий, а потім виконує команди CHANGE MASTER TO та START SLAVE з параметрами реплікації, отриманими з клонованих файлів XtraBackup.
Після того як репліка починає реплікацію, вона запамʼятовує свій головний сервер MySQL і автоматично підʼєднується, якщо сервер перезапускається або зʼєднання втрачається. Також, оскільки репліки шукають головний сервер за його стабільним DNS-імʼям (mysql-0.mysql), вони автоматично знаходять головний сервер навіть якщо він отримує новий IP Podʼа через перепланування.
Нарешті, після початку реплікації, контейнер xtrabackup слухає зʼєднання з інших Podʼів, які запитують клон даних. Цей сервер залишається активним нескінченно довго в разі, якщо StatefulSet масштабується вгору, або якщо наступний Pod втрачає свій PersistentVolumeClaim і потрібно повторно виконати клонування.
Надсилання клієнтського трафіку
Ви можете надіслати тестові запити до головного сервера MySQL (хост mysql-0.mysql) запустивши тимчасовий контейнер з образом mysql:5.7 і використовуючи бінарний файл клієнта mysql.
kubectl run mysql-client --image=mysql:5.7 -i --rm --restart=Never --\
mysql -h mysql-0.mysql <<EOF
CREATE DATABASE test;
CREATE TABLE test.messages (message VARCHAR(250));
INSERT INTO test.messages VALUES ('hello');
EOF
Використовуйте хост mysql-read, щоб надіслати тестові запити до будь-якого сервера, який повідомляє про готовність:
kubectl run mysql-client --image=mysql:5.7 -i -t --rm --restart=Never --\
mysql -h mysql-read -e "SELECT * FROM test.messages"
Ви повинні отримати вивід схожий на цей:
Waiting for pod default/mysql-client to be running, status is Pending, pod ready: false
+---------+
| message |
+---------+
| hello |
+---------+
pod "mysql-client" deleted
Щоб продемонструвати, що Service mysql-read розподіляє підключення між
серверами, ви можете запустити SELECT @@server_id у циклі:
kubectl run mysql-client-loop --image=mysql:5.7 -i -t --rm --restart=Never --\
bash -ic "while sleep 1; do mysql -h mysql-read -e 'SELECT @@server_id,NOW()'; done"
Ви повинні бачити, що @@server_id змінюється випадковим чином, оскільки може бути вибрана інша точка доступу при кожній спробі підключення:
+-------------+---------------------+
| @@server_id | NOW() |
+-------------+---------------------+
| 100 | 2006-01-02 15:04:05 |
+-------------+---------------------+
+-------------+---------------------+
| @@server_id | NOW() |
+-------------+---------------------+
| 102 | 2006-01-02 15:04:06 |
+-------------+---------------------+
+-------------+---------------------+
| @@server_id | NOW() |
+-------------+---------------------+
| 101 | 2006-01-02 15:04:07 |
+-------------+---------------------+
Ви можете натиснути Ctrl+C, коли захочете зупинити цикл, але цікаво тримати його запущеним в іншому вікні, щоб бачити ефект від наступних кроків.
Симуляція відмови Podʼа та вузла
Щоб продемонструвати підвищену доступність читання з пулу реплік замість одного сервера, залиште цикл SELECT @@server_id, запущений вище, активним, тоді як ви змушуєте Pod вийти зі стану Ready.
Зламайте пробу готовності
Проба готовності для контейнера mysql виконує команду mysql -h 127.0.0.1 -e 'SELECT 1', щоб переконатися, що сервер запущений і може виконувати запити.
Один зі способів змусити цю пробу готовності не спрацювати — зламати цю команду:
kubectl exec mysql-2 -c mysql -- mv /usr/bin/mysql /usr/bin/mysql.off
Ця дія втручається у файлову систему контейнера Podʼа mysql-2 і перейменовує команду mysql, щоб проба готовності не могла її знайти. Через кілька секунд Pod повинен повідомити про один зі своїх контейнерів як неготовий, що можна перевірити за допомогою:
kubectl get pod mysql-2
Перевірте значення 1/2 у стовпці READY:
NAME READY STATUS RESTARTS AGE
mysql-2 1/2 Running 0 3m
На цьому етапі ви повинні бачити продовження роботи вашого циклу SELECT @@server_id, хоча він більше не повідомляє про 102. Нагадаємо, що скрипт init-mysql визначив server-id як 100 + $ordinal, тож ідентифікатор сервера 102 відповідає Podʼу mysql-2.
Тепер відновіть Pod і він повинен знову зʼявитися у виводі циклу через кілька секунд:
kubectl exec mysql-2 -c mysql -- mv /usr/bin/mysql.off /usr/bin/mysql
Видалення Podʼів
Контролер StatefulSet також створює Podʼи знову, якщо вони видалені, подібно до того, як це робить ReplicaSet для Podʼів без збереження стану.
kubectl delete pod mysql-2
Контролер StatefulSet помічає, що Podʼа mysql-2 більше не існує, і створює новий з тією ж назвою та повʼязаний з тим самим PersistentVolumeClaim. Ви повинні побачити, що ідентифікатор сервера 102 зникне з виводу циклу протягом певного часу і потім повернеться самостійно.
Виконайте drain вузла
Якщо у вашому кластері Kubernetes є кілька вузлів, ви можете симулювати відмову вузла (наприклад, під час оновлення вузлів) за допомогою команди drain.
Спочатку визначте, на якому вузлі знаходиться один із Podʼів MySQL:
kubectl get pod mysql-2 -o wide
Назва вузла повинна зʼявитися у останньому стовпчику:
NAME READY STATUS RESTARTS AGE IP NODE
mysql-2 2/2 Running 0 15m 10.244.5.27 kubernetes-node-9l2t
Потім виконайте drain вузла такою командою: вона виконує cordon вузла, щоб нові Podʼи не могли туди плануватися, а потім виселяє всі наявні Podʼи. Замість <node-name> підставте назву вузла, яку ви знайшли на попередньому кроці.
Увага:
Drain вузла може вплинути на інші робочі навантаження та застосунки, що працюють на тому ж вузлі. Виконуйте наступний крок тільки на тестовому кластері.# Дивіться вище поради щодо впливу на інші робочі навантаження
kubectl drain <node-name> --force --delete-emptydir-data --ignore-daemonsets
Тепер ви можете спостерігати, як Pod переплановується на іншому вузлі:
kubectl get pod mysql-2 -o wide --watch
Це має виглядати приблизно так:
NAME READY STATUS RESTARTS AGE IP NODE
mysql-2 2/2 Terminating 0 15m 10.244.1.56 kubernetes-node-9l2t
[...]
mysql-2 0/2 Pending 0 0s <none> kubernetes-node-fjlm
mysql-2 0/2 Init:0/2 0 0s <none> kubernetes-node-fjlm
mysql-2 0/2 Init:1/2 0 20s 10.244.5.32 kubernetes-node-fjlm
mysql-2 0/2 PodInitializing 0 21s 10.244.5.32 kubernetes-node-fjlm
mysql-2 1/2 Running 0 22s 10.244.5.32 kubernetes-node-fjlm
mysql-2 2/2 Running 0 30s 10.244.5.32 kubernetes-node-fjlm
І знову, ви повинні побачити, що ідентифікатор сервера 102 зник з виводу циклу SELECT @@server_id протягом певного часу, а потім повернувся.
Тепер виконайте uncordon вузла, щоб повернути його до звичайного стану:
kubectl uncordon <node-name>
Масштабування кількості реплік
Коли ви використовуєте реплікацію MySQL, ви можете збільшувати пропускну здатність для запитів на читання, додаючи репліки. Для StatefulSet це можна зробити однією командою:
kubectl scale statefulset mysql --replicas=5
Спостерігайте, як нові Podʼи запускаються, виконавши:
kubectl get pods -l app=mysql --watch
Коли вони будуть готові, ви побачите, що ідентифікатори серверів 103 та 104 починають зʼявлятися у виводі циклу SELECT @@server_id.
Ви також можете перевірити, що ці нові сервери мають дані, які ви додали ще до того, як вони зʼявилися:
kubectl run mysql-client --image=mysql:5.7 -i -t --rm --restart=Never --\
mysql -h mysql-3.mysql -e "SELECT * FROM test.messages"
Waiting for pod default/mysql-client to be running, status is Pending, pod ready: false
+---------+
| message |
+---------+
| hello |
+---------+
pod "mysql-client" deleted
Зменшення кількості реплік так само безпроблемне:
kubectl scale statefulset mysql --replicas=3
Примітка:
Хоча збільшення створює нові PersistentVolumeClaims автоматично, зменшення автоматично не видаляє ці PVC.
Це дає вам можливість залишити ці ініціалізовані PVC для швидшого збільшення, або вилучити дані перед їх видаленням.
Ви можете перевірити це, виконавши:
kubectl get pvc -l app=mysql
Це покаже, що всі 5 PVC все ще існують, попри те, що StatefulSet був зменшений до 3:
NAME STATUS VOLUME CAPACITY ACCESSMODES AGE
data-mysql-0 Bound pvc-8acbf5dc-b103-11e6-93fa-42010a800002 10Gi RWO 20m
data-mysql-1 Bound pvc-8ad39820-b103-11e6-93fa-42010a800002 10Gi RWO 20m
data-mysql-2 Bound pvc-8ad69a6d-b103-11e6-93fa-42010a800002 10Gi RWO 20m
data-mysql-3 Bound pvc-50043c45-b1c5-11e6-93fa-42010a800002 10Gi RWO 2m
data-mysql-4 Bound pvc-500a9957-b1c5-11e6-93fa-42010a800002 10Gi RWO 2m
Якщо ви не збираєтеся повторно використовувати додаткові PVC, ви можете їх видалити:
kubectl delete pvc data-mysql-3
kubectl delete pvc data-mysql-4
Очищення
Припиніть цикл
SELECT @@server_id, натиснувши Ctrl+C в його терміналі або виконавши наступне з іншого терміналу:kubectl delete pod mysql-client-loop --nowВидаліть StatefulSet. Це також розпочне завершення Podʼів.
kubectl delete statefulset mysqlПеревірте, що Podʼи зникають. Завершення їхньої роботи може зайняти деякий час.
kubectl get pods -l app=mysqlВи будете знати, що Podʼи завершилися, коли вищезазначена команда поверне:
No resources found.Видаліть ConfigMap, Services та PersistentVolumeClaims.
kubectl delete configmap,service,pvc -l app=mysqlЯкщо ви вручну надавали PersistentVolumes, вам також потрібно вручну видалити їх, а також звільнити відповідні ресурси. Якщо ви використовували динамічний provisioner, він автоматично видаляє PersistentVolumes, коли бачить, що ви видалили PersistentVolumeClaims. Деякі динамічні provisioners (такі як ті, що стосуються EBS та PD) також звільняють відповідні ресурси при видаленні PersistentVolumes.
Що далі
- Дізнайтеся більше про масштабування StatefulSet.
- Дізнайтеся більше про налагодження StatefulSet.
- Дізнайтеся більше про видалення StatefulSet.
- Дізнайтеся більше про примусове видалення Podʼів StatefulSet.
- Подивіться в репозиторії Helm Charts інші приклади застосунків зі збереженням стану.
6 - Масштабування StatefulSet
Це завдання показує, як масштабувати StatefulSet. Масштабування StatefulSet означає збільшення або зменшення кількості реплік.
Перш ніж ви розпочнете
StatefulSets доступні лише у Kubernetes версії 1.5 або новішій. Щоб перевірити версію Kubernetes, виконайте
kubectl version.Не всі застосунки зі збереженням стану добре масштабуються. Якщо ви не впевнені, чи варто масштабувати ваші StatefulSets, докладніше дивіться в концепції StatefulSet або в навчальному матеріалі про StatefulSet.
Виконуйте масштабування лише тоді, коли впевнені, що кластер вашого застосунку зі збереженням стану повністю справний.
Масштабування StatefulSets
Використання kubectl для масштабування StatefulSets
Спочатку знайдіть StatefulSet, який ви хочете масштабувати.
kubectl get statefulsets <stateful-set-name>
Змініть кількість реплік вашого StatefulSet:
kubectl scale statefulsets <stateful-set-name> --replicas=<new-replicas>
Оновлення ваших StatefulSets на місці
Також можна виконати оновлення на місці ваших StatefulSets.
Якщо ваш StatefulSet спочатку створено за допомогою kubectl apply, оновіть .spec.replicas у маніфестах StatefulSet, а потім виконайте kubectl apply:
kubectl apply -f <stateful-set-file-updated>
Інакше відредагуйте це поле за допомогою kubectl edit:
kubectl edit statefulsets <stateful-set-name>
Або використовуйте kubectl patch:
kubectl patch statefulsets <stateful-set-name> -p '{"spec":{"replicas":<new-replicas>}}'
Усунення несправностей
Зменшення масштабу не працює належним чином
Не можна зменшити масштаб StatefulSet, коли будь-який зі stateful Podʼів, якими він керує, несправний. Зменшення масштабу відбувається лише після того, як ці stateful Podʼи стануть запущеними й готовими.
Якщо spec.replicas > 1, Kubernetes не може визначити причину несправності Podʼа. Це може бути наслідком постійного або тимчасового збою. Тимчасовий збій може бути спричинений перезапуском, потрібним для оновлення або обслуговування.
Якщо Pod несправний через постійний збій, масштабування без усунення збою може призвести до стану, коли кількість членів StatefulSet опуститься нижче певної мінімальної кількості реплік, потрібних для правильної роботи. Це може призвести до недоступності вашого StatefulSet.
Якщо Pod несправний через тимчасовий збій і може знову стати доступним, тимчасова помилка може завадити операції збільшення або зменшення масштабу. Деякі розподілені бази даних мають проблеми, коли вузли приєднуються й виходять одночасно. У таких випадках краще оцінювати операції масштабування на рівні застосунку й виконувати масштабування лише тоді, коли ви впевнені, що кластер вашого застосунку зі збереженням стану повністю справний.
Що далі
- Дізнайтеся більше про видалення StatefulSet.
7 - Видалення StatefulSet
Це завдання показує, як видалити StatefulSet.
Перш ніж ви розпочнете
- Це завдання передбачає, що у вас у кластері працює застосунок, представлений StatefulSet.
Видалення StatefulSet
Ви можете видалити StatefulSet так само, як й інші ресурси в Kubernetes: скористайтеся командою kubectl delete і вкажіть StatefulSet за файлом або за назвою.
kubectl delete -f <file.yaml>
kubectl delete statefulsets <statefulset-name>
Після видалення самого StatefulSet може знадобитися окремо видалити повʼязаний headless Service.
kubectl delete service <service-name>
Під час видалення StatefulSet через kubectl StatefulSet масштабується до 0. Усі Podʼи, що є частиною цього робочого навантаження, також видаляються. Якщо ви хочете видалити лише StatefulSet, а не Podʼи, використовуйте --cascade=orphan. Наприклад:
kubectl delete -f <file.yaml> --cascade=orphan
Якщо передати --cascade=orphan до kubectl delete, Podʼи, якими керує StatefulSet, залишаться навіть після видалення самого обʼєкта StatefulSet. Якщо Podʼи мають мітку app.kubernetes.io/name=MyApp, їх можна видалити так:
kubectl delete pods -l app.kubernetes.io/name=MyApp
Постійні томи
Видалення Podʼів у StatefulSet не призводить до видалення повʼязаних томів. Це зроблено для того, щоб ви мали змогу скопіювати дані з тому перед його видаленням. Видалення PVC після завершення роботи Podʼів може спричинити видалення відповідних постійних томів залежно від класу сховища та політики повторного використання. Ніколи не розраховуйте на доступ до тому після видалення заявки.
Примітка:
Будьте обережні під час видалення PVC, оскільки це може призвести до втрати даних.Повне видалення StatefulSet
Щоб видалити все у StatefulSet, зокрема повʼязані Podʼи, можна виконати серію команд, подібних до наведених нижче:
grace=$(kubectl get pods <stateful-set-pod> --template '{{.spec.terminationGracePeriodSeconds}}')
kubectl delete statefulset -l app.kubernetes.io/name=MyApp
sleep $grace
kubectl delete pvc -l app.kubernetes.io/name=MyApp
У наведеному вище прикладі Podʼи мають мітку app.kubernetes.io/name=MyApp; за потреби підставте власну мітку.
Примусове видалення Podʼів StatefulSet
Якщо деякі Podʼи у вашому StatefulSet тривалий час залишаються у стані 'Terminating' або 'Unknown', може знадобитися втрутитися вручну, щоб примусово видалити Podʼи з API-сервера. Це потенційно небезпечне завдання. Докладніше дивіться в розділі Примусове видалення Podʼів StatefulSet.
Що далі
Дізнайтеся більше про примусове видалення Podʼів StatefulSet.
8 - Примусове видалення Podʼів StatefulSet
На цій сторінці показано, як видаляти Podʼи, що є частиною StatefulSet, і пояснено, що слід враховувати під час цього.
Перш ніж ви розпочнете
- Це досить складне завдання, яке може порушити деякі властивості, притаманні StatefulSet.
- Перш ніж продовжити, ознайомтеся з наведеними нижче міркуваннями.
Міркування щодо StatefulSet
Під час нормальної роботи StatefulSet ніколи немає потреби примусово видаляти Pod StatefulSet. Контролер StatefulSet відповідає за створення, масштабування й видалення членів StatefulSet. Він намагається забезпечити, щоб зазначена кількість Podʼів із порядковими номерами від 0 до N-1 працювала й була готовою. StatefulSet гарантує, що в будь-який момент часу в кластері працює не більше одного Podʼа із заданою ідентичністю. Це називається семантикою щонайбільше один, яку забезпечує StatefulSet.
Примусове видалення вручну слід виконувати обережно, оскільки воно може порушити семантику «щонайбільше один», притаманну StatefulSet. StatefulSets можуть використовуватися для запуску розподілених і кластерних застосунків, яким потрібна стабільна мережева ідентичність і стабільне сховище. Ці застосунки часто мають конфігурацію, що ґрунтується на ансамблі з фіксованої кількості членів із фіксованими ідентичностями. Наявність кількох членів з однаковою ідентичністю може мати катастрофічні наслідки й призвести до втрати даних (наприклад, у сценарії split brain у системах на основі кворуму).
Видалення Podʼів
Ви можете виконати коректне видалення Podʼа за допомогою такої команди:
kubectl delete pods <pod>
Щоб таке видалення призвело до коректного завершення, Pod не повинен задавати pod.Spec.TerminationGracePeriodSeconds зі значенням 0. Практика встановлення pod.Spec.TerminationGracePeriodSeconds на 0 секунд є небезпечною й категорично не рекомендована для Podʼів StatefulSet. Коректне видалення безпечне й гарантує, що Pod коректно завершить роботу до того, як kubelet видалить його назву з API-сервера.
Pod не видаляється автоматично, коли вузол недоступний. Podʼи, що працюють на недоступному вузлі, переходять у стан 'Terminating' або 'Unknown' після тайм-ауту. Podʼи також можуть переходити в ці стани, коли користувач намагається коректно видалити Pod на недоступному вузлі. Pod у такому стані можна вилучити з API-сервера лише такими способами:
- Обʼєкт Node видаляється (вами або контролером вузлів).
- kubelet на вузлі, що не відповідає, знову починає відповідати, завершує Pod і вилучає запис з API-сервера.
- Примусове видалення Podʼа користувачем.
Рекомендована практика — використовувати перший або другий підхід. Якщо підтверджено, що вузол не працює (наприклад, постійно відключений від мережі, вимкнений тощо), видаліть обʼєкт Node. Якщо вузол зазнає розділення мережі, спробуйте усунути проблему або дочекайтеся її усунення. Коли мережу буде відновлено, kubelet завершить видалення Podʼа й звільнить його назву в API-сервері.
Зазвичай система завершує видалення, щойно Pod більше не працює на вузлі або адміністратор видаляє вузол. Ви можете перевизначити це, примусово видаливши Pod.
Примусове видалення
Примусове видалення не чекає від kubelet підтвердження, що Pod завершено. Незалежно від того, чи вдасться примусовому видаленню завершити Pod, воно негайно звільняє його назву в API-сервері. Це дає контролеру StatefulSet змогу створити Pod на заміну з тією самою ідентичністю; це може призвести до дублювання Podʼа, який усе ще працює, і якщо цей Pod усе ще може спілкуватися з іншими членами StatefulSet, це порушить семантику «щонайбільше один», яку StatefulSet має гарантувати.
Коли ви примусово видаляєте Pod StatefulSet, ви стверджуєте, що цей Pod більше ніколи не контактуватиме з іншими Podʼами StatefulSet і його назву можна безпечно звільнити для створення заміни.
Якщо ви хочете примусово видалити Pod за допомогою kubectl версії >= 1.5, виконайте таке:
kubectl delete pods <pod> --grace-period=0 --force
Якщо ви використовуєте будь-яку версію kubectl <= 1.4, пропустіть параметр --force і використайте:
kubectl delete pods <pod> --grace-period=0
Якщо навіть після цих команд Pod залишається у стані Unknown, використайте таку команду, щоб вилучити Pod з кластера:
kubectl patch pod <pod> -p '{"metadata":{"finalizers":null}}'
Завжди виконуйте примусове видалення Podʼів StatefulSet обережно та з повним розумінням ризиків, повʼязаних із цим.
Що далі
Дізнайтеся більше про налагодження StatefulSet.
9 - Покрокове керівництво HorizontalPodAutoscaler
HorizontalPodAutoscaler (скорочено HPA) автоматично оновлює ресурс робочого навантаження (наприклад, Deployment або StatefulSet) з метою автоматичного масштабування робочого навантаження відповідно до попиту.
Горизонтальне масштабування означає, що на збільшене навантаження відповідають розгортанням додаткових Podʼів. Це відрізняється від вертикального масштабування, яке для Kubernetes означало б призначення додаткових ресурсів (наприклад, памʼяті або CPU) Podʼам, що вже працюють для робочого навантаження.
Якщо навантаження зменшується, а кількість Podʼів перевищує налаштований мінімум, HorizontalPodAutoscaler дає ресурсу робочого навантаження (Deployment, StatefulSet або іншому подібному ресурсу) команду зменшити масштаб.
У цьому документі розглянуто приклад увімкнення HorizontalPodAutoscaler для автоматичного керування масштабом прикладного вебзастосунку. Це робоче навантаження — Apache httpd, що виконує певний код PHP.
Перш ніж ви розпочнете
Вам треба мати кластер Kubernetes, а також інструмент командного рядка kubectl має бути налаштований для роботи з вашим кластером. Рекомендується виконувати ці настанови у кластері, що має щонайменше два вузли, які не виконують роль вузлів управління. Якщо у вас немає кластера, ви можете створити його, за допомогою minikube або використовувати одну з цих пісочниць:
Версія вашого Kubernetes сервера має бути не старішою ніж 1.23.Для перевірки версії введіть kubectl version.
Щоб виконати цей посібник, вам також потрібен кластер із розгорнутим і налаштованим Metrics Server. Kubernetes Metrics Server збирає метрики ресурсів із kubelets у вашому кластері й надає ці метрики через Kubernetes API, використовуючи APIService, щоб додати нові види ресурсів, які представляють показники метрик.
Щоб дізнатися, як розгорнути Metrics Server, дивіться документацію metrics-server.
Якщо ви використовуєте Minikube, виконайте таку команду, щоб увімкнути metrics-server:
minikube addons enable metrics-server
Запустіть сервер php-apache і відкрийте до нього доступ
Щоб продемонструвати HorizontalPodAutoscaler, ви спочатку запустите Deployment, який запускає контейнер з образом hpa-example, і відкриєте до нього доступ як до Service за допомогою такого маніфесту:
apiVersion: apps/v1
kind: Deployment
metadata:
name: php-apache
spec:
selector:
matchLabels:
run: php-apache
template:
metadata:
labels:
run: php-apache
spec:
containers:
- name: php-apache
image: registry.k8s.io/hpa-example
ports:
- containerPort: 80
resources:
limits:
cpu: 500m
requests:
cpu: 200m
---
apiVersion: v1
kind: Service
metadata:
name: php-apache
labels:
run: php-apache
spec:
ports:
- port: 80
selector:
run: php-apache
Для цього виконайте таку команду:
kubectl apply -f https://k8s.io/examples/application/php-apache.yaml
deployment.apps/php-apache created
service/php-apache created
Створіть HorizontalPodAutoscaler
Тепер, коли сервер працює, створіть автомасштабувальник за допомогою kubectl. У цьому допоможе підкоманда kubectl autoscale, що є частиною kubectl.
Незабаром ви виконаєте команду, яка створить HorizontalPodAutoscaler, що підтримує від 1 до 10 реплік Podʼів, керованих Deployment php-apache, який ви створили на першому кроці цих інструкцій.
Загалом, контролер HPA збільшуватиме й зменшуватиме кількість реплік (оновлюючи Deployment), щоб підтримувати середнє використання CPU на рівні 50% по всіх Podʼах. Потім Deployment оновлює ReplicaSet — так працюють усі Deployments у Kubernetes — а потім ReplicaSet додає або вилучає Podʼи відповідно до змін у його .spec.
Оскільки кожен Pod запитує 200 мілі-ядер через kubectl run, це означає середнє використання CPU 100 мілі-ядер. Докладніше про алгоритм дивіться в розділі Деталі алгоритму.
Створіть HorizontalPodAutoscaler:
kubectl autoscale deployment php-apache --cpu=50% --min=1 --max=10
horizontalpodautoscaler.autoscaling/php-apache autoscaled
Ви можете перевірити поточний статус щойно створеного HorizontalPodAutoscaler, виконавши:
# Можна використовувати "hpa" або "horizontalpodautoscaler"; працюють обидві назви.
kubectl get hpa
Вивід подібний до такого:
NAME REFERENCE TARGET MINPODS MAXPODS REPLICAS AGE
php-apache Deployment/php-apache/scale 0% / 50% 1 10 1 18s
(якщо ви бачите інші HorizontalPodAutoscalers з іншими назвами, це означає, що вони вже існували, і зазвичай це не проблема).
Зверніть увагу, що поточне споживання CPU становить 0%, оскільки немає клієнтів, що надсилають запити на сервер (стовпець TARGET показує середнє значення по всіх Podʼах, керованих відповідним Deployment).
Збільшення навантаження
Далі подивіться, як автомасштабувальник реагує на збільшене навантаження. Для цього ви запустите інший Pod, який діятиме як клієнт. Контейнер у клієнтському Podʼі працює в нескінченному циклі, надсилаючи запити до сервісу php-apache.
# Виконайте це в окремому терміналі,
# щоб навантаження продовжувалося, і ви могли продовжити роботу з рештою кроків
kubectl run -i --tty load-generator --rm --image=busybox:1.28 --restart=Never -- /bin/sh -c "while sleep 0.01; do wget -q -O- http://php-apache; done"
Тепер виконайте:
# натисніть Ctrl+C, щоб припинити перегляд, коли будете готові
kubectl get hpa php-apache --watch
Приблизно за хвилину ви маєте побачити вище навантаження на CPU; наприклад:
NAME REFERENCE TARGET MINPODS MAXPODS REPLICAS AGE
php-apache Deployment/php-apache/scale 305% / 50% 1 10 1 3m
а потім більше реплік. Наприклад:
NAME REFERENCE TARGET MINPODS MAXPODS REPLICAS AGE
php-apache Deployment/php-apache/scale 305% / 50% 1 10 7 3m
Тут споживання CPU зросло до 305% від запиту. У результаті Deployment було змінено до 7 реплік:
kubectl get deployment php-apache
Ви маєте побачити, що кількість реплік збігається з числом із HorizontalPodAutoscaler
NAME READY UP-TO-DATE AVAILABLE AGE
php-apache 7/7 7 7 19m
Примітка:
Стабілізація кількості реплік може зайняти кілька хвилин. Оскільки обсяг навантаження ніяк не контролюється, кінцева кількість реплік може відрізнятися від цього прикладу.Зупиніть генерування навантаження
Щоб завершити приклад, припиніть надсилати навантаження.
У терміналі, де ви створили Pod з образом busybox, зупиніть генерування навантаження, натиснувши <Ctrl> + C.
Потім перевірте результат (приблизно за хвилину):
# натисніть Ctrl+C, щоб припинити перегляд, коли будете готові
kubectl get hpa php-apache --watch
Вивід подібний до такого:
NAME REFERENCE TARGET MINPODS MAXPODS REPLICAS AGE
php-apache Deployment/php-apache/scale 0% / 50% 1 10 1 11m
і Deployment також показує, що його масштаб зменшився:
kubectl get deployment php-apache
NAME READY UP-TO-DATE AVAILABLE AGE
php-apache 1/1 1 1 27m
Щойно використання CPU впало до 0, HPA автоматично зменшив кількість реплік назад до 1.
Автоматичне масштабування реплік може зайняти кілька хвилин.
Автомасштабування за кількома метриками та власними метриками
Ви можете додати інші метрики для автомасштабування Deployment php-apache, використовуючи версію API autoscaling/v2.
Спочатку отримайте YAML вашого HorizontalPodAutoscaler у формі autoscaling/v2:
kubectl get hpa php-apache -o yaml > /tmp/hpa-v2.yaml
Відкрийте файл /tmp/hpa-v2.yaml у редакторі, і ви побачите такий YAML:
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
name: php-apache
spec:
scaleTargetRef:
apiVersion: apps/v1
kind: Deployment
name: php-apache
minReplicas: 1
maxReplicas: 10
metrics:
- type: Resource
resource:
name: cpu
target:
type: Utilization
averageUtilization: 50
status:
observedGeneration: 1
lastScaleTime: <some-time>
currentReplicas: 1
desiredReplicas: 1
currentMetrics:
- type: Resource
resource:
name: cpu
current:
averageUtilization: 0
averageValue: 0
Зверніть увагу, що поле targetCPUUtilizationPercentage замінено масивом під назвою metrics. Метрика використання CPU є метрикою ресурсу, оскільки вона подана як відсоток ресурсу, вказаного в контейнерах Podʼа. Зверніть увагу, що ви можете вказати інші метрики ресурсів, крім CPU. Стандартно єдина інша підтримувана метрика ресурсу — це memory. Ці ресурси не змінюють назв від кластера до кластера й мають бути доступними завжди, доки доступний API metrics.k8s.io.
Ви також можете вказувати метрики ресурсів у безпосередніх значеннях, а не у відсотках від запитаного значення, використовуючи target.type зі значенням AverageValue замість Utilization і встановлюючи відповідне поле target.averageValue замість target.averageUtilization.
metrics:
- type: Resource
resource:
name: memory
target:
type: AverageValue
averageValue: 500Mi
Є ще два типи метрик, обидва вважаються власними метриками: метрики Podʼів і метрики обʼєктів. Ці метрики можуть мати назви, специфічні для кластера, і потребують розширенішого налаштування моніторингу кластера.
Перший із цих альтернативних типів метрик — це метрики Podʼів. Ці метрики описують Podʼи, усереднюються по Podʼах і порівнюються з цільовим значенням для визначення кількості реплік. Вони працюють майже так само, як метрики ресурсів, за винятком того, що підтримують лише тип target AverageValue.
Метрики Podʼів вказуються за допомогою такого блоку метрики:
type: Pods
pods:
metric:
name: packets-per-second
target:
type: AverageValue
averageValue: 1k
Другий альтернативний тип метрики — це метрики обʼєктів. Ці метрики описують інший обʼєкт у тому самому просторі імен, а не Podʼи. Метрики не обовʼязково отримуються з обʼєкта; вони лише описують його. Метрики обʼєктів підтримують типи target Value і AverageValue. Для Value ціль порівнюється безпосередньо з метрикою, отриманою з API. Для AverageValue значення, отримане з API власних метрик, ділиться на кількість Podʼів перед порівнянням із ціллю. Наведений нижче приклад — це подання метрики requests-per-second у YAML.
type: Object
object:
metric:
name: requests-per-second
describedObject:
apiVersion: networking.k8s.io/v1
kind: Ingress
name: main-route
target:
type: Value
value: 2k
Якщо ви надаєте кілька таких блоків метрик, HorizontalPodAutoscaler розглядатиме кожну метрику по черзі. HorizontalPodAutoscaler обчислить запропоновану кількість реплік для кожної метрики, а потім вибере найбільшу.
Наприклад, якщо ваша система моніторингу збирає метрики мережевого трафіку, ви можете оновити наведене вище визначення за допомогою kubectl edit, щоб воно мало такий вигляд:
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
name: php-apache
spec:
scaleTargetRef:
apiVersion: apps/v1
kind: Deployment
name: php-apache
minReplicas: 1
maxReplicas: 10
metrics:
- type: Resource
resource:
name: cpu
target:
type: Utilization
averageUtilization: 50
- type: Pods
pods:
metric:
name: packets-per-second
target:
type: AverageValue
averageValue: 1k
- type: Object
object:
metric:
name: requests-per-second
describedObject:
apiVersion: networking.k8s.io/v1
kind: Ingress
name: main-route
target:
type: Value
value: 10k
status:
observedGeneration: 1
lastScaleTime: <some-time>
currentReplicas: 1
desiredReplicas: 1
currentMetrics:
- type: Resource
resource:
name: cpu
current:
averageUtilization: 0
averageValue: 0
- type: Object
object:
metric:
name: requests-per-second
describedObject:
apiVersion: networking.k8s.io/v1
kind: Ingress
name: main-route
current:
value: 10k
Тоді ваш HorizontalPodAutoscaler намагатиметься забезпечити, щоб кожен Pod споживав приблизно 50% запитаного CPU, обслуговував 1000 пакетів за секунду, а всі Podʼи за Ingress main-route разом обслуговували 10000 запитів за секунду.
Автомасштабування за конкретнішими метриками
Багато конвеєрів метрик дають змогу описувати метрики або за назвою, або за набором додаткових дескрипторів, які називаються мітками. Для всіх типів метрик, крім метрик ресурсів (Podʼів, обʼєктів і зовнішніх, описаних нижче), ви можете вказати додатковий селектор міток, який передається вашому конвеєру метрик. Наприклад, якщо ви збираєте метрику http_requests з міткою verb, можна вказати такий блок метрики, щоб масштабувати лише за запитами GET:
type: Object
object:
metric:
name: http_requests
selector: {matchLabels: {verb: GET}}
Цей селектор використовує той самий синтаксис, що й повні селектори міток Kubernetes. Конвеєр моніторингу визначає, як згорнути кілька серій в одне значення, якщо назва й селектор відповідають кільком серіям. Селектор є адитивним і не може вибирати метрики, що описують обʼєкти, які не є цільовим обʼєктом (цільові Podʼи для типу Pods та описаний обʼєкт для типу Object).
Автомасштабування за метриками, що не стосуються обʼєктів Kubernetes
Застосунки, що працюють у Kubernetes, можуть потребувати автомасштабування за метриками, які не мають очевидного звʼязку з жодним обʼєктом у кластері Kubernetes, наприклад метриками, що описують розміщений сервіс, який не має прямої кореляції з просторами імен Kubernetes. У Kubernetes 1.10 і новіших версіях цей випадок можна вирішити за допомогою зовнішніх метрик.
Використання зовнішніх метрик потребує знання вашої системи моніторингу; налаштування подібне до потрібного для власних метрик. Зовнішні метрики дають змогу автоматично масштабувати кластер на основі будь-якої метрики, доступної у вашій системі моніторингу. Надайте блок metric з name і selector, як вище, і використовуйте тип метрики External замість Object. Якщо metricSelector відповідає кільком часовим рядам, HorizontalPodAutoscaler використовує суму їхніх значень. Зовнішні метрики підтримують цільові типи Value і AverageValue, які працюють точно так само, як і для типу Object.
Наприклад, якщо ваш застосунок обробляє завдання з розміщеного сервісу черг, ви можете додати такий розділ до маніфесту HorizontalPodAutoscaler, щоб вказати, що потрібен один обробник на кожні 30 невиконаних завдань.
- type: External
external:
metric:
name: queue_messages_ready
selector:
matchLabels:
queue: "worker_tasks"
target:
type: AverageValue
averageValue: 30
Коли це можливо, краще використовувати цільові типи власних метрик замість зовнішніх метрик, оскільки адміністраторам кластера легше захистити API власних метрик. API зовнішніх метрик потенційно дає доступ до будь-якої метрики, тому адміністратори кластера мають бути обережними, відкриваючи доступ до нього.
Додаток: стани статусу Horizontal Pod Autoscaler
Використовуючи форму autoscaling/v2 HorizontalPodAutoscaler, ви зможете бачити стани статусу, які Kubernetes встановлює на HorizontalPodAutoscaler. Ці стани статусу вказують, чи може HorizontalPodAutoscaler масштабуватися і чи є наразі якісь обмеження.
Стани показано в полі status.conditions. Щоб побачити стани, що впливають на HorizontalPodAutoscaler, можна використати kubectl describe hpa:
kubectl describe hpa cm-test
Name: cm-test
Namespace: prom
Labels: <none>
Annotations: <none>
CreationTimestamp: Fri, 16 Jun 2017 18:09:22 +0000
Reference: ReplicationController/cm-test
Metrics: ( current / target )
"http_requests" on pods: 66m / 500m
Min replicas: 1
Max replicas: 4
ReplicationController pods: 1 current / 1 desired
Conditions:
Type Status Reason Message
---- ------ ------ -------
AbleToScale True ReadyForNewScale the last scale time was sufficiently old as to warrant a new scale
ScalingActive True ValidMetricFound the HPA was able to successfully calculate a replica count from pods metric http_requests
ScalingLimited False DesiredWithinRange the desired replica count is within the acceptable range
Events:
Для цього HorizontalPodAutoscaler видно кілька станів у справному статусі. Перший, AbleToScale, вказує, чи може HPA отримувати й оновлювати масштаби, а також чи не завадять масштабуванню умови, повʼязані з backoff. Другий, ScalingActive, вказує, чи увімкнено HPA (тобто кількість реплік цілі не дорівнює нулю) і чи може він обчислювати бажані масштаби. Якщо він False, це зазвичай вказує на проблеми з отриманням метрик. Нарешті, останній стан, ScalingLimited, вказує, що бажаний масштаб обмежено максимумом або мінімумом HorizontalPodAutoscaler. Це ознака того, що вам може знадобитися збільшити або зменшити обмеження мінімальної чи максимальної кількості реплік у вашому HorizontalPodAutoscaler.
Кількості
Усі метрики в HorizontalPodAutoscaler і в API метрик вказуються за допомогою спеціальної нотації цілих чисел, відомої в Kubernetes як кількість. Наприклад, кількість 10500m у десятковій нотації записується як 10.5. API метрик за можливості повертають цілі числа без суфікса, а інакше зазвичай повертають кількості в міліодиницях. Це означає, що значення вашої метрики може коливатися між 1 і 1500m, або між 1 і 1.5 у десятковій нотації.
Інші можливі сценарії
Декларативне створення автомасштабувальника
Замість того щоб створювати HorizontalPodAutoscaler імперативно командою kubectl autoscale, можна створити його декларативно за допомогою такого маніфесту:
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
name: php-apache
spec:
scaleTargetRef:
apiVersion: apps/v1
kind: Deployment
name: php-apache
minReplicas: 1
maxReplicas: 10
metrics:
- type: Resource
resource:
name: cpu
target:
type: Utilization
averageUtilization: 50
Потім створіть автомасштабувальник, виконавши таку команду:
kubectl create -f https://k8s.io/examples/application/hpa/php-apache.yaml
horizontalpodautoscaler.autoscaling/php-apache created
10 - Вказання бюджету порушень для вашого застосунку
На цій сторінці показано, як обмежити кількість одночасних порушень, яких зазнає ваш застосунок, що підвищує доступність і водночас дозволяє адміністратору кластера керувати вузлами кластера.
Перш ніж ви розпочнете
Версія вашого Kubernetes сервера має бути не старішою ніж v1.21.Для перевірки версії введіть kubectl version.
- Ви є власником застосунку, який працює в кластері Kubernetes і потребує високої доступності.
- Вам слід знати, як розгорнути репліковані застосунки без збереження стану та/або репліковані застосунки зі збереженням стану.
- Ви маєте прочитати про порушення Podʼів.
- Вам слід підтвердити з власником кластера або постачальником послуг, що вони дотримуються бюджетів порушень Podʼів.
Захист застосунку за допомогою PodDisruptionBudget
- Визначте, який застосунок ви хочете захистити за допомогою PodDisruptionBudget (PDB).
- Подумайте, як ваш застосунок реагує на порушення.
- Створіть визначення PDB у вигляді файлу YAML.
- Створіть обʼєкт PDB з файлу YAML.
Визначення застосунку для захисту
Найпоширеніший випадок — коли потрібно захистити застосунок, визначений одним із вбудованих контролерів Kubernetes:
- Deployment
- ReplicationController
- ReplicaSet
- StatefulSet
У цьому випадку запишіть .spec.selector контролера; той самий селектор використовується в .spec.selector PDB.
Починаючи з версії 1.15, PDB підтримують власні контролери, у яких увімкнено субресурс масштабування.
Також можна використовувати PDB з Podʼами, які не контролюються одним із наведених вище контролерів, або з довільними групами Podʼів, але є деякі обмеження, описані в розділі Довільні робочі навантаження та довільні селектори.
Подумайте, як ваш застосунок реагує на порушення
Вирішіть, скільки екземплярів може бути вимкнено одночасно протягом короткого часу через добровільне порушення.
- Фронтенди без збереження стану:
- Застереження: не зменшуйте потужність обслуговування більш ніж на 10%.
- Рішення: наприклад, використовуйте PDB з minAvailable 90%.
- Застереження: не зменшуйте потужність обслуговування більш ніж на 10%.
- Одноекземплярний застосунок зі збереженням стану:
- Застереження: не завершуйте цей застосунок, не поговоривши зі мною.
- Можливе рішення 1: не використовуйте PDB і змиріться з випадковими простоями.
- Можливе рішення 2: встановіть PDB з maxUnavailable=0. Домовтеся (поза Kubernetes), що оператор кластера порадиться з вами перед завершенням. Коли оператор кластера звернеться до вас, підготуйтеся до простою, а потім видаліть PDB, щоб показати готовність до порушення. Потім створіть його знову.
- Застереження: не завершуйте цей застосунок, не поговоривши зі мною.
- Багатоекземплярний застосунок зі збереженням стану, такий як Consul, ZooKeeper або etcd:
- Застереження: не зменшуйте кількість екземплярів нижче кворуму, інакше записи завершуватимуться збоєм.
- Можливе рішення 1: встановіть maxUnavailable на 1 (працює зі змінним масштабом застосунку).
- Можливе рішення 2: встановіть minAvailable рівним розміру кворуму (наприклад, 3 за масштабу 5). (Дозволяє більше порушень одночасно).
- Застереження: не зменшуйте кількість екземплярів нижче кворуму, інакше записи завершуватимуться збоєм.
- Пакетний Job із можливістю перезапуску:
- Застереження: Job має завершитися в разі добровільного порушення.
- Можливе рішення: не створюйте PDB. Контролер Job створить Pod на заміну.
- Застереження: Job має завершитися в разі добровільного порушення.
Логіка округлення під час вказання відсотків
Значення для minAvailable або maxUnavailable можуть бути виражені як цілі числа або як відсотки.
- Коли ви вказуєте ціле число, воно означає кількість Podʼів. Наприклад, якщо встановити
minAvailableна 10, завжди мають бути доступними 10 Podʼів, навіть під час порушення. - Коли ви вказуєте відсоток, задаючи значення як рядкове представлення відсотка (наприклад,
"50%"), воно означає відсоток від загальної кількості Podʼів. Наприклад, якщо встановитиminAvailableна"50%", принаймні 50% Podʼів залишаться доступними під час порушення.
Коли ви вказуєте значення як відсоток, воно може не відповідати точній кількості Podʼів. Наприклад, якщо у вас є 7 Podʼів і ви встановите minAvailable на "50%", не одразу очевидно, чи означає це, що мають бути доступними 3 чи 4 Podʼи. Kubernetes округлює вгору до найближчого цілого числа, тому в цьому випадку мають бути доступними 4 Podʼи. Коли ви вказуєте значення maxUnavailable як відсоток, Kubernetes округлює вгору кількість Podʼів, які можуть зазнати порушення. Тому порушення може перевищити визначений вами відсоток maxUnavailable. Ви можете ознайомитися з кодом, який керує такою поведінкою.
Вказання PodDisruptionBudget
PodDisruptionBudget має три поля:
- Селектор міток
.spec.selector, що вказує набір Podʼів, до яких він застосовується. Це поле обовʼязкове. .spec.minAvailable— опис кількості Podʼів із цього набору, які мають залишитися доступними після виселення, навіть за відсутності виселеного Podʼа.minAvailableможе бути абсолютним числом або відсотком..spec.maxUnavailable— опис кількості Podʼів із цього набору, які можуть бути недоступними після виселення. Це також може бути абсолютне число або відсоток.
Примітка:
Порожній селектор ({}) відповідає кожному Podʼу у просторі імен.Ви можете вказати лише одне з полів maxUnavailable і minAvailable в одному PodDisruptionBudget. maxUnavailable можна використовувати лише для контролю виселення Podʼів, якими керує один і той самий повʼязаний контролер. У наведених нижче прикладах «бажані репліки» — це scale контролера, що керує Podʼами, вибраними PodDisruptionBudget.
Приклад 1: із minAvailable 5 виселення дозволяються, доки після них залишається 5 або більше справних Podʼів серед вибраних selector у PodDisruptionBudget.
Приклад 2: із minAvailable 30% виселення дозволяються, доки принаймні 30% від кількості бажаних реплік справні.
Приклад 3: із maxUnavailable 5 виселення дозволяються, доки серед загальної кількості бажаних реплік є не більше 5 несправних реплік.
Приклад 4: із maxUnavailable 30% виселення дозволяються, доки кількість несправних реплік не перевищує 30% від загальної кількості бажаних реплік, округлених вгору до найближчого цілого числа. Якщо загальна кількість бажаних реплік лише одна, ця єдина репліка все одно може зазнати порушення, що фактично означає 100% недоступність.
Зазвичай один бюджет використовується для набору Podʼів, керованих контролером, наприклад Podʼів в одному ReplicaSet або StatefulSet.
Примітка:
Бюджет порушень насправді не гарантує, що вказана кількість або відсоток Podʼів завжди працюватимуть. Наприклад, вузол, на якому розміщено Pod із набору, може вийти з ладу, коли набір має мінімальний розмір, вказаний у бюджеті, і кількість доступних Podʼів із набору стане меншою за вказану. Бюджет може захищати лише від добровільних виселень, а не від усіх причин недоступності.Якщо ви встановите maxUnavailable на 0% або 0 чи minAvailable на 100% або на кількість реплік, ви вимагаєте нуль добровільних виселень. Якщо задати нуль добровільних виселень для обʼєкта робочого навантаження, як-от ReplicaSet, ви не зможете успішно виконати drain вузла, на якому працює один із цих Podʼів. Якщо спробувати виконати drain вузла, де працює Pod, який не можна виселити, drain ніколи не завершиться. Це дозволено семантикою PodDisruptionBudget.
Нижче наведено приклади визначень бюджетів порушень Podʼів. Вони відповідають Podʼам з міткою app: zookeeper.
Приклад PDB з використанням minAvailable:
Приклад PDB з використанням maxUnavailable:
Наприклад, якщо наведений вище обʼєкт zk-pdb вибирає Podʼи StatefulSet розміром 3, обидві специфікації означають те саме. Рекомендовано використовувати maxUnavailable, оскільки він автоматично реагує на зміни кількості реплік відповідного контролера.
Створення обʼєкта PDB
Створити або оновити обʼєкт PDB можна за допомогою kubectl.
kubectl apply -f mypdb.yaml
Перевірка статусу PDB
Використайте kubectl, щоб перевірити, що ваш PDB створено.
Якщо у вашому просторі імен насправді немає Podʼів, що відповідають app: zookeeper, ви побачите щось подібне:
kubectl get poddisruptionbudgets
NAME MIN AVAILABLE MAX UNAVAILABLE ALLOWED DISRUPTIONS AGE
zk-pdb 2 N/A 0 7s
Якщо є відповідні Podʼи (скажімо, 3), ви побачите щось подібне:
kubectl get poddisruptionbudgets
NAME MIN AVAILABLE MAX UNAVAILABLE ALLOWED DISRUPTIONS AGE
zk-pdb 2 N/A 1 7s
Ненульове значення ALLOWED DISRUPTIONS означає, що контролер порушень побачив Podʼи, порахував відповідні Podʼи й оновив статус PDB.
Ви можете отримати більше інформації про статус PDB за допомогою цієї команди:
kubectl get poddisruptionbudgets zk-pdb -o yaml
apiVersion: policy/v1
kind: PodDisruptionBudget
metadata:
annotations:
…
creationTimestamp: "2020-03-04T04:22:56Z"
generation: 1
name: zk-pdb
…
status:
currentHealthy: 3
desiredHealthy: 2
disruptionsAllowed: 1
expectedPods: 3
observedGeneration: 1
Справність Podʼа
Поточна реалізація вважає справними Podʼи, які мають елемент .status.conditions з type="Ready" і status="True". Ці Podʼи відстежуються через поле .status.currentHealthy у статусі PDB.
Політика виселення несправних Podʼів
This is a stable feature in Kubernetes, and has been since the 1.31 release. You can no longer toggle this feature (the associated feature gate has been removed).
PodDisruptionBudget, що захищає застосунок, гарантує, що кількість Podʼів у .status.currentHealthy не опуститься нижче за кількість, вказану в .status.desiredHealthy, не дозволяючи виселення справних Podʼів. За допомогою .spec.unhealthyPodEvictionPolicy ви також можете визначити критерії, за яких несправні Podʼи слід розглядати для виселення. Стандартна поведінка, коли політику не вказано, відповідає політиці IfHealthyBudget.
Політики:
IfHealthyBudget- Запущені (
.status.phase="Running"), але ще несправні Podʼи можна виселити, лише якщо захищений застосунок не зазнає порушення (.status.currentHealthyщонайменше дорівнює.status.desiredHealthy). Ця політика гарантує, що запущені Podʼи застосунку, який уже зазнав порушення, мають найкращий шанс стати справними. Це має негативні наслідки для drain вузлів, який можуть блокувати застосунки з некоректною поведінкою, захищені PDB. Зокрема, застосунки з Podʼами у стані
CrashLoopBackOff(через помилку або неправильну конфігурацію) або Podʼами, яким просто не вдається повідомити про станReady.AlwaysAllow- Запущені (
.status.phase="Running"), але ще несправні Podʼи вважаються такими, що зазнали порушення, і їх можна виселити незалежно від того, чи виконуються критерії PDB. Це означає, що запущені Podʼи застосунку, який зазнав порушення, можуть не отримати шансу стати справними. За допомогою цієї політики менеджери кластера можуть легко виселяти застосунки з некоректною поведінкою, захищені PDB. Зокрема, застосунки з Podʼами у стані
CrashLoopBackOff(через помилку або неправильну конфігурацію) або Podʼами, яким просто не вдається повідомити про станReady.
Примітка:
Podʼи у фазахPending, Succeeded або Failed завжди вважаються кандидатами на виселення.Довільні робочі навантаження та довільні селектори
Цей розділ можна пропустити, якщо ви використовуєте PDB лише з вбудованими ресурсами робочих навантажень (Deployment, ReplicaSet, StatefulSet і ReplicationController) або з власними ресурсами, які реалізують субресурс scale, і де селектор PDB точно відповідає селектору ресурсу-власника Podʼа.
Ви можете використовувати PDB з Podʼами, керованими іншим ресурсом, «оператором», або з окремими Podʼами, але з такими обмеженнями:
- можна використовувати лише
.spec.minAvailable, а не.spec.maxUnavailable. - можна використовувати лише ціле значення з
.spec.minAvailable, а не відсоток.
Інші конфігурації доступності використовувати неможливо, оскільки Kubernetes не може визначити загальну кількість Podʼів без підтримуваного ресурсу-власника.
Ви можете використовувати селектор, який вибирає підмножину або надмножину Podʼів, що належать ресурсу робочого навантаження. Eviction API забороняє виселення будь-якого Podʼа, що підпадає під кілька PDB, тому більшість користувачів захоче уникати селекторів, що перекриваються. Розумне використання PDB, що перекриваються, — коли Podʼи переводяться з одного PDB на інший.
11 - Отримання доступу до API Kubernetes з Podʼа
У цьому посібнику показано, як отримати доступ до API Kubernetes зсередини Podʼа.
Перш ніж ви розпочнете
Вам треба мати кластер Kubernetes, а також інструмент командного рядка kubectl має бути налаштований для роботи з вашим кластером. Рекомендується виконувати ці настанови у кластері, що має щонайменше два вузли, які не виконують роль вузлів управління. Якщо у вас немає кластера, ви можете створити його, за допомогою minikube або використовувати одну з цих пісочниць:
Отримання доступу до API зсередини Podʼа
Під час доступу до API зсередини Podʼа пошук API-сервера й автентифікація на ньому дещо відрізняються від випадку зовнішнього клієнта.
Найпростіший спосіб використовувати API Kubernetes із Podʼа — застосувати одну з офіційних клієнтських бібліотек. Ці бібліотеки можуть автоматично знаходити API-сервер і автентифікуватися.
Використання офіційних клієнтських бібліотек
Зсередини Podʼа рекомендовано підʼєднуватися до API Kubernetes такими способами:
Для клієнта Go використовуйте офіційну клієнтську бібліотеку Go. Функція
rest.InClusterConfig()автоматично виконує виявлення хоста API й автентифікацію. Дивіться приклад тут.Для клієнта Python використовуйте офіційну клієнтську бібліотеку Python. Функція
config.load_incluster_config()автоматично виконує виявлення хоста API й автентифікацію. Дивіться приклад тут.Доступно також багато інших бібліотек, дивіться сторінку Клієнтські бібліотеки.
У кожному випадку для безпечного звʼязку з API-сервером використовуються облікові дані службового облікового запису Podʼа.
Прямий доступ до REST API
Під час роботи в Podʼі ваш контейнер може сформувати HTTPS URL для API-сервера Kubernetes, отримавши змінні середовища KUBERNETES_SERVICE_HOST і KUBERNETES_SERVICE_PORT_HTTPS. Внутрішньокластерну адресу API-сервера також опубліковано в Service з назвою kubernetes у просторі імен default, тож Podʼи можуть використовувати kubernetes.default.svc як DNS-імʼя локального API-сервера.
Примітка:
Kubernetes не гарантує, що API-сервер має дійсний сертифікат для імені хостаkubernetes.default.svc; однак від панелі управління очікується, що вона надасть дійсний сертифікат для імені хоста або IP-адреси, які представляє $KUBERNETES_SERVICE_HOST.Рекомендований спосіб автентифікації на API-сервері — за допомогою облікових даних службового облікового запису. Стандартно Pod повʼязаний зі службовим обліковим записом, а облікові дані (токен) цього запису розміщуються в дереві файлової системи кожного контейнера цього Podʼа, у /var/run/secrets/kubernetes.io/serviceaccount/token.
Якщо доступний, набір сертифікатів розміщується в дереві файлової системи кожного контейнера у /var/run/secrets/kubernetes.io/serviceaccount/ca.crt, і його слід використовувати для перевірки серверного сертифіката API-сервера.
Нарешті, стандартний простір імен для операцій API в межах простору імен розміщується у файлі /var/run/secrets/kubernetes.io/serviceaccount/namespace у кожному контейнері.
Використання kubectl proxy
Якщо ви хочете надсилати запити до API без офіційної клієнтської бібліотеки, можна запустити kubectl proxy як команду нового sidecar-контейнера в Podʼі. Так kubectl proxy автентифікуватиметься в API й відкриє доступ до нього на інтерфейсі localhost Podʼа, щоб інші контейнери в Podʼі могли використовувати його безпосередньо.
Без використання проксі
Можна обійтися без kubectl proxy, передаючи токен автентифікації безпосередньо API-серверу. Внутрішній сертифікат захищає зʼєднання.
# Вказати імʼя хоста внутрішнього API-сервера
APISERVER=https://kubernetes.default.svc
# Шлях до токена ServiceAccount
SERVICEACCOUNT=/var/run/secrets/kubernetes.io/serviceaccount
# Прочитати простір імен цього Podʼа
NAMESPACE=$(cat ${SERVICEACCOUNT}/namespace)
# Прочитати bearer-токен ServiceAccount
TOKEN=$(cat ${SERVICEACCOUNT}/token)
# Вказати внутрішній центр сертифікації (CA)
CACERT=${SERVICEACCOUNT}/ca.crt
# Досліджувати API за допомогою TOKEN
curl --cacert ${CACERT} --header "Authorization: Bearer ${TOKEN}" -X GET ${APISERVER}/api
Вивід подібний до такого:
{
"kind": "APIVersions",
"versions": ["v1"],
"serverAddressByClientCIDRs": [
{
"clientCIDR": "0.0.0.0/0",
"serverAddress": "10.0.1.149:443"
}
]
}