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
  1. Створіть Deployment на основі файлу YAML:

    kubectl apply -f https://k8s.io/examples/application/deployment.yaml
    
  2. Виведіть інформацію про 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.
    
  3. Перегляньте 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
    
  4. Виведіть інформацію про 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
  1. Застосуйте новий файл YAML:

    kubectl apply -f https://k8s.io/examples/application/deployment-update.yaml
    
  2. Спостерігайте, як 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
  1. Застосуйте новий файл YAML:

    kubectl apply -f https://k8s.io/examples/application/deployment-scale.yaml
    
  2. Перевірте, що 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.

Що далі

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

Що далі

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

Що далі

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
  1. Розгорніть PV та PVC з файлу YAML:

    kubectl apply -f https://k8s.io/examples/application/mysql/mysql-pv.yaml
    
  2. Розгорніть вміст файлу YAML:

    kubectl apply -f https://k8s.io/examples/application/mysql/mysql-deployment.yaml
    
  3. Виведіть інформацію про 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
    
  4. Перегляньте Podʼи, створені Deployment:

    kubectl get pods -l app=mysql
    

    Вивід подібний до такого:

    NAME                   READY     STATUS    RESTARTS   AGE
    mysql-63082529-2z3ki   1/1       Running   0          3m
    
  5. Перевірте 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.

Що далі

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

Очищення

  1. Припиніть цикл SELECT @@server_id, натиснувши Ctrl+C в його терміналі або виконавши наступне з іншого терміналу:

    kubectl delete pod mysql-client-loop --now
    
  2. Видаліть StatefulSet. Це також розпочне завершення Podʼів.

    kubectl delete statefulset mysql
    
  3. Перевірте, що Podʼи зникають. Завершення їхньої роботи може зайняти деякий час.

    kubectl get pods -l app=mysql
    

    Ви будете знати, що Podʼи завершилися, коли вищезазначена команда поверне:

    No resources found.
    
  4. Видаліть ConfigMap, Services та PersistentVolumeClaims.

    kubectl delete configmap,service,pvc -l app=mysql
    
  5. Якщо ви вручну надавали PersistentVolumes, вам також потрібно вручну видалити їх, а також звільнити відповідні ресурси. Якщо ви використовували динамічний provisioner, він автоматично видаляє PersistentVolumes, коли бачить, що ви видалили PersistentVolumeClaims. Деякі динамічні provisioners (такі як ті, що стосуються EBS та PD) також звільняють відповідні ресурси при видаленні PersistentVolumes.

Що далі

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 несправний через тимчасовий збій і може знову стати доступним, тимчасова помилка може завадити операції збільшення або зменшення масштабу. Деякі розподілені бази даних мають проблеми, коли вузли приєднуються й виходять одночасно. У таких випадках краще оцінювати операції масштабування на рівні застосунку й виконувати масштабування лише тоді, коли ви впевнені, що кластер вашого застосунку зі збереженням стану повністю справний.

Що далі

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.

Якщо ви використовуєте старіший випуск Kubernetes, зверніться до версії документації для цього випуску (дивіться доступні версії документації).

Щоб виконати цей посібник, вам також потрібен кластер із розгорнутим і налаштованим 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 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 - Вказання бюджету порушень для вашого застосунку

СТАН ФУНКЦІОНАЛУ: GA since Kubernetes v1.21

На цій сторінці показано, як обмежити кількість одночасних порушень, яких зазнає ваш застосунок, що підвищує доступність і водночас дозволяє адміністратору кластера керувати вузлами кластера.

Перш ніж ви розпочнете

Версія вашого Kubernetes сервера має бути не старішою ніж v1.21.

Для перевірки версії введіть kubectl version.

Захист застосунку за допомогою PodDisruptionBudget

  1. Визначте, який застосунок ви хочете захистити за допомогою PodDisruptionBudget (PDB).
  2. Подумайте, як ваш застосунок реагує на порушення.
  3. Створіть визначення PDB у вигляді файлу YAML.
  4. Створіть обʼєкт PDB з файлу YAML.

Визначення застосунку для захисту

Найпоширеніший випадок — коли потрібно захистити застосунок, визначений одним із вбудованих контролерів Kubernetes:

  • Deployment
  • ReplicationController
  • ReplicaSet
  • StatefulSet

У цьому випадку запишіть .spec.selector контролера; той самий селектор використовується в .spec.selector PDB.

Починаючи з версії 1.15, PDB підтримують власні контролери, у яких увімкнено субресурс масштабування.

Також можна використовувати PDB з Podʼами, які не контролюються одним із наведених вище контролерів, або з довільними групами Podʼів, але є деякі обмеження, описані в розділі Довільні робочі навантаження та довільні селектори.

Подумайте, як ваш застосунок реагує на порушення

Вирішіть, скільки екземплярів може бути вимкнено одночасно протягом короткого часу через добровільне порушення.

  • Фронтенди без збереження стану:
    • Застереження: не зменшуйте потужність обслуговування більш ніж на 10%.
      • Рішення: наприклад, використовуйте PDB з minAvailable 90%.
  • Одноекземплярний застосунок зі збереженням стану:
    • Застереження: не завершуйте цей застосунок, не поговоривши зі мною.
      • Можливе рішення 1: не використовуйте PDB і змиріться з випадковими простоями.
      • Можливе рішення 2: встановіть PDB з maxUnavailable=0. Домовтеся (поза Kubernetes), що оператор кластера порадиться з вами перед завершенням. Коли оператор кластера звернеться до вас, підготуйтеся до простою, а потім видаліть PDB, щоб показати готовність до порушення. Потім створіть його знову.
  • Багатоекземплярний застосунок зі збереженням стану, такий як Consul, ZooKeeper або etcd:
    • Застереження: не зменшуйте кількість екземплярів нижче кворуму, інакше записи завершуватимуться збоєм.
      • Можливе рішення 1: встановіть maxUnavailable на 1 (працює зі змінним масштабом застосунку).
      • Можливе рішення 2: встановіть minAvailable рівним розміру кворуму (наприклад, 3 за масштабу 5). (Дозволяє більше порушень одночасно).
  • Пакетний Job із можливістю перезапуску:
    • Застереження: Job має завершитися в разі добровільного порушення.
      • Можливе рішення: не створюйте PDB. Контролер Job створить Pod на заміну.

Логіка округлення під час вказання відсотків

Значення для 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:

apiVersion: policy/v1
kind: PodDisruptionBudget
metadata:
  name: zk-pdb
spec:
  minAvailable: 2
  selector:
    matchLabels:
      app: zookeeper

Приклад PDB з використанням maxUnavailable:

apiVersion: policy/v1
kind: PodDisruptionBudget
metadata:
  name: zk-pdb
spec:
  maxUnavailable: 1
  selector:
    matchLabels:
      app: zookeeper

Наприклад, якщо наведений вище обʼєкт 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 такими способами:

У кожному випадку для безпечного звʼязку з 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"
    }
  ]
}