1 - Використання власних ресурсів

2 - Налаштування шару агрегації

Налаштування шару агрегації дає змогу розширити API-сервер Kubernetes додатковими API, які не є частиною основних API Kubernetes.

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

Вам треба мати кластер Kubernetes, а також інструмент командного рядка kubectl має бути налаштований для роботи з вашим кластером. Рекомендується виконувати ці настанови у кластері, що має щонайменше два вузли, які не виконують роль вузлів управління. Якщо у вас немає кластера, ви можете створити його, за допомогою minikube або використовувати одну з цих пісочниць:

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

Примітка:

Щоб шар агрегації працював у вашому середовищі й підтримував взаємну автентифікацію TLS між проксі та API-серверами розширення, потрібно виконати кілька вимог налаштування. Kubernetes і kube-apiserver мають кілька CA, тому переконайтеся, що проксі підписаний CA шару агрегації, а не чимось іншим, як-от загальним CA Kubernetes.

Увага:

Повторне використання того самого CA для різних типів клієнтів може негативно вплинути на роботу кластера. Докладніше дивіться в розділі Повторне використання CA та конфлікти.

Потік автентифікації

На відміну від Custom Resource Definitions (CRD), Aggregation API залучає ще один сервер — ваш API-сервер розширення — на додачу до стандартного API-сервера Kubernetes. API-серверу Kubernetes потрібно взаємодіяти з вашим API-сервером розширення, а вашому API-серверу розширення — з API-сервером Kubernetes. Щоб ця взаємодія була захищеною, API-сервер Kubernetes використовує сертифікати x509 для автентифікації перед API-сервером розширення.

У цьому розділі описано, як працюють потоки автентифікації та авторизації та як їх налаштувати.

Загальний потік такий:

  1. API-сервер Kubernetes: автентифікація користувача, що надсилає запит, і авторизація його прав на запитаний шлях API.
  2. API-сервер Kubernetes: проксіювання запиту до API-сервера розширення
  3. API-сервер розширення: автентифікація запиту від API-сервера Kubernetes
  4. API-сервер розширення: авторизація запиту від початкового користувача
  5. API-сервер розширення: виконання

У решті цього розділу ці кроки описано докладно.

Потік показано на наведеній нижче схемі.

aggregation auth flows

Джерело наведених вище swimlanes можна знайти у вихідному коді цього документа.

Автентифікація та авторизація в API-сервері Kubernetes

Запит до шляху API, який обслуговує API-сервер розширення, починається так само, як і всі запити API: зі звернення до API-сервера Kubernetes. Цей шлях уже зареєстрований в API-сервері Kubernetes API-сервером розширення.

Користувач звертається до API-сервера Kubernetes, запитуючи доступ до шляху. API-сервер Kubernetes використовує стандартну автентифікацію та авторизацію, налаштовану в API-сервері Kubernetes, щоб автентифікувати користувача й авторизувати доступ до конкретного шляху.

Огляд автентифікації в кластері Kubernetes дивіться в розділі «Автентифікація в кластері». Огляд авторизації доступу до ресурсів кластера Kubernetes дивіться в розділі «Огляд авторизації».

До цього моменту все було стандартними запитами API Kubernetes, автентифікацією та авторизацією.

Тепер API-сервер Kubernetes готовий надіслати запит до API-сервера розширення.

API-сервер Kubernetes проксіює запит

Тепер API-сервер Kubernetes надішле, або проксіює, запит до API-сервера розширення, зареєстрованого для обробки цього запиту. Для цього йому потрібно знати кілька речей:

  1. Як API-серверу Kubernetes автентифікуватися в API-сервері розширення, повідомляючи йому, що запит, який надходить мережею, походить від дійсного API-сервера Kubernetes?
  2. Як API-серверу Kubernetes повідомити API-серверу розширення імʼя користувача та групу, для яких було автентифіковано початковий запит?

Щоб забезпечити ці дві речі, потрібно налаштувати API-сервер Kubernetes за допомогою кількох прапорців.

Автентифікація клієнта API-сервера Kubernetes

API-сервер Kubernetes підʼєднується до API-сервера розширення через TLS, автентифікуючись за допомогою клієнтського сертифіката. Під час запуску потрібно надати API-серверу Kubernetes таке за допомогою вказаних прапорців:

  • файл приватного ключа через --proxy-client-key-file
  • підписаний файл клієнтського сертифіката через --proxy-client-cert-file
  • сертифікат CA, який підписав файл клієнтського сертифіката через --requestheader-client-ca-file
  • дійсні значення Common Name (CN) у підписаному клієнтському сертифікаті через --requestheader-allowed-names

API-сервер Kubernetes використовуватиме файли, вказані в --proxy-client-*-file, щоб автентифікуватися в API-сервері розширення. Щоб сумісний API-сервер розширення вважав запит дійсним, мають виконуватися такі умови:

  1. Зʼєднання має бути встановлене за допомогою клієнтського сертифіката, підписаного CA, сертифікат якого міститься в --requestheader-client-ca-file.
  2. Зʼєднання має бути встановлене за допомогою клієнтського сертифіката, CN якого є одним із перелічених у --requestheader-allowed-names.

Примітка:

Ви можете залишити цей параметр порожнім: --requestheader-allowed-names="". Це вкаже API-серверу розширення, що будь-який CN прийнятний.

Після запуску з цими параметрами API-сервер Kubernetes:

  1. Використовуватиме їх для автентифікації в API-сервері розширення.
  2. Створить ConfigMap у просторі імен kube-system з назвою extension-apiserver-authentication, куди помістить сертифікат CA та дозволені CN. Їх, своєю чергою, можуть отримувати API-сервери розширення для перевірки запитів.

Зверніть увагу, що API-сервер Kubernetes використовує той самий клієнтський сертифікат для автентифікації в усіх API-серверах розширення. Він не створює окремий клієнтський сертифікат для кожного API-сервера розширення, а використовує один, щоб автентифікуватися як API-сервер Kubernetes. Той самий сертифікат повторно використовується для всіх запитів до API-серверів розширення.

Імʼя користувача та група початкового запиту

Коли API-сервер Kubernetes проксіює запит до API-сервера розширення, він повідомляє API-серверу розширення імʼя користувача та групу, з якими початковий запит успішно автентифіковано. Він передає їх у заголовках http свого проксійованого запиту. Потрібно вказати API-серверу Kubernetes назви заголовків, які слід використовувати.

  • заголовок, в якому зберігати імʼя користувача через --requestheader-username-headers
  • заголовок, в якому зберігати групу через --requestheader-group-headers
  • префікс, що додається до всіх додаткових заголовків, через --requestheader-extra-headers-prefix

Ці назви заголовків також поміщаються в ConfigMap extension-apiserver-authentication, тож API-сервери розширення можуть отримувати й використовувати їх.

API-сервер розширення автентифікує запит

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

  1. Отримує наведене нижче з ConfigMap у kube-system, як описано вище:
    • Сертифікат CA клієнта
    • Список дозволених імен (CN)
    • Назви заголовків для імені користувача, групи та додаткової інформації
  2. Перевіряє, що зʼєднання TLS автентифіковано за допомогою клієнтського сертифіката, який:
    • Підписаний CA, сертифікат якого збігається з отриманим сертифікатом CA.
    • Має CN зі списку дозволених CN, якщо тільки список не порожній; у такому разі дозволено всі CN.
    • Витягує імʼя користувача та групу з відповідних заголовків

Якщо наведені вище перевірки пройдено, запит є дійсним проксійованим запитом від законного проксі автентифікації, у цьому випадку — API-сервера Kubernetes.

Зверніть увагу, що забезпечити наведене вище має реалізація API-сервера розширення. Багато хто робить це стандартно, використовуючи пакет k8s.io/apiserver/. Інші можуть надавати параметри для перевизначення цього за допомогою параметрів командного рядка.

Щоб мати дозвіл на отримання ConfigMap, API-серверу розширення потрібна відповідна роль. У просторі імен kube-system є стандартна роль extension-apiserver-authentication-reader, яку можна призначити.

API-сервер розширення авторизує запит

Тепер API-сервер розширення може перевірити, що користувач або група, отримані із заголовків, мають дозвіл на виконання цього запиту. Він робить це, надсилаючи стандартний запит SubjectAccessReview до API-сервера Kubernetes.

Щоб API-сервер розширення сам мав право надсилати запит SubjectAccessReview до API-сервера Kubernetes, йому потрібні відповідні дозволи. Kubernetes містить стандартну ClusterRole з назвою system:auth-delegator, що має потрібні дозволи. Її можна надати службовому обліковому запису API-сервера розширення.

API-сервер розширення виконує запит

Якщо SubjectAccessReview проходить, API-сервер розширення виконує запит.

Увімкнення прапорців API-сервера Kubernetes

Увімкніть шар агрегації за допомогою наведених нижче прапорців kube-apiserver. Можливо, про них уже подбав ваш провайдер.

--requestheader-client-ca-file=<path to aggregator CA cert>
--requestheader-allowed-names=front-proxy-client
--requestheader-extra-headers-prefix=X-Remote-Extra-
--requestheader-group-headers=X-Remote-Group
--requestheader-username-headers=X-Remote-User
--proxy-client-cert-file=<path to aggregator proxy cert>
--proxy-client-key-file=<path to aggregator proxy key>

Повторне використання CA та конфлікти

API-сервер Kubernetes має два параметри клієнтського CA:

  • --client-ca-file
  • --requestheader-client-ca-file

Кожен із них працює незалежно, і вони можуть конфліктувати між собою, якщо їх використовувати неправильно.

  • --client-ca-file: коли запит надходить до API-сервера Kubernetes і цей параметр увімкнено, API-сервер Kubernetes перевіряє сертифікат запиту. Якщо він підписаний одним із сертифікатів CA у файлі, на який вказує --client-ca-file, запит вважається законним, користувачем є значення Common Name CN=, а групою — організація O=. Дивіться документацію з автентифікації TLS.
  • --requestheader-client-ca-file: коли запит надходить до API-сервера Kubernetes і цей параметр увімкнено, API-сервер Kubernetes перевіряє сертифікат запиту. Якщо він підписаний одним із сертифікатів CA у файлі, на який вказує --requestheader-client-ca-file, запит вважається потенційно законним. Потім API-сервер Kubernetes перевіряє, чи є Common Name CN= однією з назв у списку, заданому --requestheader-allowed-names. Якщо назву дозволено, запит схвалюється; якщо ні — запит не схвалюється.

Якщо задано обидва параметри --client-ca-file і --requestheader-client-ca-file, запит спочатку перевіряється за CA --requestheader-client-ca-file, а потім за --client-ca-file. Зазвичай для кожного з цих параметрів використовуються різні CA, кореневі або проміжні; звичайні клієнтські запити відповідають --client-ca-file, а запити агрегації — --requestheader-client-ca-file. Однак якщо обидва використовують той самий CA, клієнтські запити, які зазвичай пройшли б через --client-ca-file, завершаться збоєм, бо CA збігатиметься із CA в --requestheader-client-ca-file, але Common Name CN= не збігатиметься з жодним із прийнятних значень у --requestheader-allowed-names. Через це ваші kubelets та інші компоненти панелі управління, а також кінцеві користувачі можуть не змогти автентифікуватися в API-сервері Kubernetes.

Тому використовуйте різні сертифікати CA для параметра --client-ca-file, щоб авторизувати компоненти панелі управління та кінцевих користувачів, і для параметра --requestheader-client-ca-file, щоб авторизувати запити API-сервера агрегації.

Попередження:

Не використовуйте повторно CA, який застосовується в іншому контексті, якщо ви не розумієте ризики та механізми захисту використання CA.

Якщо kube-proxy не працює на хості, де працює API-сервер, потрібно переконатися, що система увімкнена з таким прапорцем kube-apiserver:

--enable-aggregator-routing=true

Реєстрація обʼєктів APIService

Ви можете динамічно налаштовувати, які клієнтські запити проксіюються до API-сервера розширення. Нижче наведено приклад реєстрації:


apiVersion: apiregistration.k8s.io/v1
kind: APIService
metadata:
  name: <name of the registration object>
spec:
  group: <API group name this extension apiserver hosts>
  version: <API version this extension apiserver hosts>
  groupPriorityMinimum: <priority this APIService for this group, see API documentation>
  versionPriority: <prioritizes ordering of this version within a group, see API documentation>
  service:
    namespace: <namespace of the extension apiserver service>
    name: <name of the extension apiserver service>
  caBundle: <pem encoded ca cert that signs the server cert used by the webhook>

Назва обʼєкта APIService має бути дійсною назвою сегмента шляху.

Звʼязок з API-сервером розширення

Коли API-сервер Kubernetes визначив, що запит потрібно надіслати до API-сервера розширення, йому потрібно знати, як із ним звʼязатися.

Блок service — це посилання на сервіс API-сервера розширення. Простір імен і назва сервісу обовʼязкові. Порт необовʼязковий, стандартно 443.

Ось приклад API-сервера розширення, налаштованого на виклики через порт "1234" і перевірку зʼєднання TLS за ServerName my-service-name.my-service-namespace.svc з використанням власного набору CA.

apiVersion: apiregistration.k8s.io/v1
kind: APIService
...
spec:
  ...
  service:
    namespace: my-service-namespace
    name: my-service-name
    port: 1234
  caBundle: "Ci0tLS0tQk...<base64-encoded PEM bundle>...tLS0K"
...

Що далі

3 - Налаштування API-сервера розширення

Налаштування API-сервера розширення для роботи із шаром агрегації дає змогу розширювати API-сервер Kubernetes додатковими API, які не є частиною основних API Kubernetes.

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

Вам треба мати кластер Kubernetes, а також інструмент командного рядка kubectl має бути налаштований для роботи з вашим кластером. Рекомендується виконувати ці настанови у кластері, що має щонайменше два вузли, які не виконують роль вузлів управління. Якщо у вас немає кластера, ви можете створити його, за допомогою minikube або використовувати одну з цих пісочниць:

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

Налаштування API-сервера розширення для роботи із шаром агрегації

Наведені нижче кроки описують налаштування API-сервера розширення на високому рівні. Ці кроки застосовні незалежно від того, чи використовуєте ви конфігурації YAML, чи API. Ми намагаємося окремо вказати всі відмінності між цими двома підходами. Конкретний приклад їх реалізації за допомогою конфігурацій YAML дивіться в sample-apiserver у репозиторії Kubernetes.

Також можна використати наявне стороннє рішення, як-от apiserver-builder, яке має згенерувати каркас і автоматизувати всі наведені нижче кроки за вас.

  1. Переконайтеся, що API APIService увімкнено (перевірте --runtime-config). Стандартно він має бути увімкнений, якщо його свідомо не вимкнули у вашому кластері.
  2. Можливо, вам потрібно створити правило RBAC, яке дозволяє додавати обʼєкти APIService, або попросити про це адміністратора кластера. (Оскільки розширення API впливають на весь кластер, не рекомендовано тестувати, розробляти чи налагоджувати розширення API в робочому кластері.)
  3. Створіть простір імен Kubernetes, у якому ви хочете запустити свій api-service розширення.
  4. Створіть або отримайте сертифікат CA, який використовуватиметься для підпису серверного сертифіката, що його API-сервер розширення використовує для HTTPS.
  5. Створіть серверний сертифікат і ключ, які API-сервер використовуватиме для HTTPS. Цей сертифікат має бути підписаний наведеним вище CA. Він також повинен мати CN з іменем Kube DNS. Це імʼя походить від сервісу Kubernetes і має вигляд <service name>.<service name namespace>.svc
  6. Створіть Secret Kubernetes із серверним сертифікатом і ключем у вашому просторі імен.
  7. Створіть Deployment Kubernetes для API-сервера розширення й переконайтеся, що завантажуєте Secret як том. Він має містити посилання на робочий образ вашого API-сервера розширення. Deployment також має бути у вашому просторі імен.
  8. Переконайтеся, що ваш API-сервер розширення завантажує ці сертифікати з цього тому і що вони використовуються під час рукостискання HTTPS.
  9. Створіть службовий обліковий запис Kubernetes у вашому просторі імен.
  10. Створіть кластерну роль Kubernetes для операцій, які ви хочете дозволити над вашими ресурсами.
  11. Створіть привʼязку кластерної ролі Kubernetes від службового облікового запису у вашому просторі імен до створеної кластерної ролі.
  12. Створіть привʼязку кластерної ролі Kubernetes від службового облікового запису у вашому просторі імен до кластерної ролі system:auth-delegator, щоб делегувати рішення щодо автентифікації основному API-серверу Kubernetes.
  13. Створіть привʼязку ролі Kubernetes від службового облікового запису у вашому просторі імен до ролі extension-apiserver-authentication-reader. Це дає вашому API-серверу розширення доступ до ConfigMap extension-apiserver-authentication.
  14. Створіть apiservice Kubernetes. Наведений вище сертифікат CA має бути закодований у base64, без нових рядків, і використаний як spec.caBundle в apiservice. Він не має належати до простору імен. Якщо ви використовуєте kube-aggregator API, передавайте лише набір CA у кодуванні PEM, оскільки кодування base64 виконується за вас.
  15. Використайте kubectl, щоб отримати ваш ресурс. Під час виконання kubectl має повернути "No resources found.". Це повідомлення вказує, що все спрацювало, але наразі у вас немає створених обʼєктів цього типу ресурсу.

Що далі

4 - Налаштування кількох планувальників

Kubernetes постачається зі стандартним планувальником, описаним тут. Якщо стандартний планувальник не відповідає вашим потребам, ви можете реалізувати власний. Більше того, можна одночасно запускати кілька планувальників поряд зі стандартним і вказувати Kubernetes, який планувальник використовувати для кожного з ваших Podʼів. Розгляньмо на прикладі, як запускати кілька планувальників у Kubernetes.

Докладний опис реалізації планувальника виходить за межі цього документа. Канонічний приклад дивіться в реалізації kube-scheduler у pkg/scheduler у теці вихідного коду Kubernetes.

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

Вам треба мати кластер Kubernetes, а також інструмент командного рядка kubectl має бути налаштований для роботи з вашим кластером. Рекомендується виконувати ці настанови у кластері, що має щонайменше два вузли, які не виконують роль вузлів управління. Якщо у вас немає кластера, ви можете створити його, за допомогою minikube або використовувати одну з цих пісочниць:

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

Упакування планувальника

Упакуйте бінарний файл планувальника в образ контейнера. Для цього прикладу можна використати стандартний планувальник (kube-scheduler) як другий планувальник. Клонуйте вихідний код Kubernetes із GitHub і зберіть його.

git clone https://github.com/kubernetes/kubernetes.git
cd kubernetes
make

Створіть образ контейнера, що містить бінарний файл kube-scheduler. Ось Dockerfile для збирання образу:

FROM busybox
ADD ./_output/local/bin/linux/amd64/kube-scheduler /usr/local/bin/kube-scheduler

Збережіть файл як Dockerfile, зберіть образ і надішліть його до реєстру. У цьому прикладі образ надсилається до Google Container Registry (GCR). Докладніше дивіться в документації GCR. Також можна використовувати docker hub. Докладніше дивіться в документації docker hub.

docker build -t gcr.io/my-gcp-project/my-kube-scheduler:1.0 .     # Назва образу та репозиторій,
gcloud docker -- push gcr.io/my-gcp-project/my-kube-scheduler:1.0 # використані тут, є лише прикладом

Визначення Deployment Kubernetes для планувальника

Тепер, коли ваш планувальник є в образі контейнера, створіть для нього конфігурацію Podʼа й запустіть його у своєму кластері Kubernetes. Але замість створення Podʼа безпосередньо в кластері для цього прикладу можна використати Deployment. Deployment керує ReplicaSet, який, своєю чергою, керує Podʼами, завдяки чому планувальник стійкий до збоїв. Ось конфігурація Deployment. Збережіть її як my-scheduler.yaml:

apiVersion: v1
kind: ServiceAccount
metadata:
  name: my-scheduler
  namespace: kube-system
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: my-scheduler-as-kube-scheduler
subjects:
- kind: ServiceAccount
  name: my-scheduler
  namespace: kube-system
roleRef:
  kind: ClusterRole
  name: system:kube-scheduler
  apiGroup: rbac.authorization.k8s.io
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: my-scheduler-as-volume-scheduler
subjects:
- kind: ServiceAccount
  name: my-scheduler
  namespace: kube-system
roleRef:
  kind: ClusterRole
  name: system:volume-scheduler
  apiGroup: rbac.authorization.k8s.io
---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: my-scheduler-extension-apiserver-authentication-reader
  namespace: kube-system
roleRef:
  kind: Role
  name: extension-apiserver-authentication-reader
  apiGroup: rbac.authorization.k8s.io
subjects:
- kind: ServiceAccount
  name: my-scheduler
  namespace: kube-system
---
apiVersion: v1
kind: ConfigMap
metadata:
  name: my-scheduler-config
  namespace: kube-system
data:
  my-scheduler-config.yaml: |
    apiVersion: kubescheduler.config.k8s.io/v1
    kind: KubeSchedulerConfiguration
    profiles:
      - schedulerName: my-scheduler
    leaderElection:
      leaderElect: false
---
apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    component: scheduler
    tier: control-plane
  name: my-scheduler
  namespace: kube-system
spec:
  selector:
    matchLabels:
      component: scheduler
      tier: control-plane
  replicas: 1
  template:
    metadata:
      labels:
        component: scheduler
        tier: control-plane
        version: second
    spec:
      serviceAccountName: my-scheduler
      containers:
      - command:
        - /usr/local/bin/kube-scheduler
        - --config=/etc/kubernetes/my-scheduler/my-scheduler-config.yaml
        image: gcr.io/my-gcp-project/my-kube-scheduler:1.0
        livenessProbe:
          httpGet:
            path: /healthz
            port: 10259
            scheme: HTTPS
          initialDelaySeconds: 15
        name: kube-second-scheduler
        readinessProbe:
          httpGet:
            path: /healthz
            port: 10259
            scheme: HTTPS
        resources:
          requests:
            cpu: '0.1'
        securityContext:
          privileged: false
        volumeMounts:
          - name: config-volume
            mountPath: /etc/kubernetes/my-scheduler
      hostNetwork: false
      hostPID: false
      volumes:
        - name: config-volume
          configMap:
            name: my-scheduler-config

У наведеному вище маніфесті використано KubeSchedulerConfiguration для налаштування поведінки вашої реалізації планувальника. Цю конфігурацію передано kube-scheduler під час ініціалізації за допомогою параметра --config. Файл конфігурації зберігається в ConfigMap my-scheduler-config. Pod Deployment my-scheduler монтує ConfigMap my-scheduler-config як том.

У згаданій вище конфігурації планувальника ваша реалізація планувальника подана за допомогою KubeSchedulerProfile.

Примітка:

Щоб визначити, чи відповідає планувальник за планування конкретного Podʼа, поле spec.schedulerName у PodTemplate або маніфесті Podʼа має збігатися з полем schedulerName у KubeSchedulerProfile. Усі планувальники, що працюють у кластері, мають мати унікальні назви.

Також зверніть увагу, що ви створюєте окремий службовий обліковий запис my-scheduler і привʼязуєте до нього ClusterRole system:kube-scheduler, щоб він міг отримати ті самі привілеї, що й kube-scheduler.

Докладний опис інших аргументів командного рядка дивіться в документації kube-scheduler, а інших налаштовуваних конфігурацій kube-scheduler — у довіднику з конфігурації планувальника.

Запуск другого планувальника в кластері

Увага:

Перед розгортанням кількох планувальників або профілів планування ознайомтеся з розділом Запуск кількох планувальників, щоб зрозуміти різні стратегії розгортання та уникнути конфліктів планування ресурсів.

Щоб запустити планувальник у кластері Kubernetes, створіть Deployment, вказаний у наведеній вище конфігурації, у кластері Kubernetes:

kubectl create -f my-scheduler.yaml

Переконайтеся, що Pod планувальника працює:

kubectl get pods --namespace=kube-system
NAME                                           READY     STATUS    RESTARTS   AGE
....
my-scheduler-lnf4s-4744f                       1/1       Running   0          2m
...

У цьому списку ви маєте побачити Pod my-scheduler у стані "Running", а також стандартний Pod kube-scheduler.

Увімкнення вибору лідера

Щоб запустити кілька планувальників з увімкненим вибором лідера, потрібно зробити таке:

Оновіть такі поля KubeSchedulerConfiguration у ConfigMap my-scheduler-config у вашому файлі YAML:

  • leaderElection.leaderElect на true
  • leaderElection.resourceNamespace на <lock-object-namespace>
  • leaderElection.resourceName на <lock-object-name>

Примітка:

Панель управління створює обʼєкти блокування для вас, але простір імен вже повинен існувати. Ви можете використовувати простір імен kube-system.

Якщо у вашому кластері увімкнено RBAC, потрібно оновити кластерну роль system:kube-scheduler. Додайте назву вашого планувальника до resourceNames правила, застосованого до ресурсів endpoints і leases, як у наведеному нижче прикладі:

kubectl edit clusterrole system:kube-scheduler
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  annotations:
    rbac.authorization.kubernetes.io/autoupdate: "true"
  labels:
    kubernetes.io/bootstrapping: rbac-defaults
  name: system:kube-scheduler
rules:
  - apiGroups:
      - coordination.k8s.io
    resources:
      - leases
    verbs:
      - create
  - apiGroups:
      - coordination.k8s.io
    resourceNames:
      - kube-scheduler
      - my-scheduler
    resources:
      - leases
    verbs:
      - get
      - update
  - apiGroups:
      - ""
    resourceNames:
      - kube-scheduler
      - my-scheduler
    resources:
      - endpoints
    verbs:
      - delete
      - get
      - patch
      - update

Вказання планувальників для Podʼів

Тепер, коли другий планувальник працює, створіть кілька Podʼів і вкажіть, щоб їх планував або стандартний планувальник, або той, який ви розгорнули. Щоб запланувати певний Pod за допомогою конкретного планувальника, вкажіть назву планувальника у специфікації цього Podʼа. Розгляньмо три приклади.

  • Специфікація Podʼа без назви планувальника

    apiVersion: v1
    kind: Pod
    metadata:
      name: no-annotation
      labels:
        name: multischeduler-example
    spec:
      containers:
      - name: pod-with-no-annotation-container
        image: registry.k8s.io/pause:3.8

    Коли назву планувальника не вказано, Pod автоматично планується за допомогою default-scheduler.

    Збережіть цей файл як pod1.yaml і надішліть його до кластера Kubernetes.

    kubectl create -f pod1.yaml
    
  • Специфікація Podʼа з default-scheduler

    apiVersion: v1
    kind: Pod
    metadata:
      name: annotation-default-scheduler
      labels:
        name: multischeduler-example
    spec:
      schedulerName: default-scheduler
      containers:
      - name: pod-with-default-annotation-container
        image: registry.k8s.io/pause:3.8
    

    Планувальник задається вказанням його назви як значення spec.schedulerName. У цьому випадку ми вказуємо назву стандартного планувальника, тобто default-scheduler.

    Збережіть цей файл як pod2.yaml і надішліть його до кластера Kubernetes.

    kubectl create -f pod2.yaml
    
  • Специфікація Podʼа з my-scheduler

    apiVersion: v1
    kind: Pod
    metadata:
      name: annotation-second-scheduler
      labels:
        name: multischeduler-example
    spec:
      schedulerName: my-scheduler
      containers:
      - name: pod-with-second-annotation-container
        image: registry.k8s.io/pause:3.8
    

    У цьому випадку ми вказуємо, що цей Pod має планувати розгорнутий нами планувальник — my-scheduler. Зверніть увагу, що значення spec.schedulerName має збігатися з назвою планувальника в полі schedulerName відповідного KubeSchedulerProfile.

    Збережіть цей файл як pod3.yaml і надішліть його до кластера Kubernetes.

    kubectl create -f pod3.yaml
    

    Переконайтеся, що всі три Podʼи працюють.

    kubectl get pods
    

Перевірка, що Podʼи були заплановані за допомогою бажаних планувальників

Щоб спростити роботу з цими прикладами, ми не перевіряли, чи справді Podʼи заплановано бажаними планувальниками. Це можна перевірити, змінивши порядок надсилання наведених вище конфігурацій Podʼів і Deployment. Якщо надіслати всі конфігурації Podʼів до кластера Kubernetes раніше за конфігурацію Deployment планувальника, Pod annotation-second-scheduler назавжди залишиться в стані "Pending", тоді як інші два Podʼи буде заплановано. Щойно ви надішлете конфігурацію Deployment планувальника і новий планувальник запрацює, Pod annotation-second-scheduler також буде заплановано.

Також можна переглянути записи "Scheduled" у логах подій, щоб перевірити, що Podʼи заплановано бажаними планувальниками.

kubectl get events

Ви також можете використати власну конфігурацію планувальника або власний образ контейнера для основного планувальника кластера, змінивши його маніфест статичного Podʼа на відповідних вузлах панелі управління.

5 - Використання HTTP-проксі для доступу до Kubernetes API

На цій сторінці показано, як використовувати HTTP-проксі для доступу до Kubernetes API.

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

Вам треба мати кластер Kubernetes, а також інструмент командного рядка kubectl має бути налаштований для роботи з вашим кластером. Рекомендується виконувати ці настанови у кластері, що має щонайменше два вузли, які не виконують роль вузлів управління. Якщо у вас немає кластера, ви можете створити його, за допомогою minikube або використовувати одну з цих пісочниць:

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

Якщо у вашому кластері ще не працює жоден застосунок, запустіть застосунок Hello world, виконавши цю команду:

kubectl create deployment hello-app --image=gcr.io/google-samples/hello-app:2.0 --port=8080

Використання kubectl для запуску проксі-сервера

Ця команда запускає проксі до API-сервера Kubernetes:

kubectl proxy --port=8080

Дослідження Kubernetes API

Коли проксі-сервер працює, ви можете досліджувати API за допомогою curl, wget або браузера.

Отримайте версії API:

curl http://localhost:8080/api/

Вивід має бути подібним до такого:

{
  "kind": "APIVersions",
  "versions": [
    "v1"
  ],
  "serverAddressByClientCIDRs": [
    {
      "clientCIDR": "0.0.0.0/0",
      "serverAddress": "10.0.2.15:8443"
    }
  ]
}

Отримайте список Podʼів:

curl http://localhost:8080/api/v1/namespaces/default/pods

Вивід має бути подібним до такого:

{
  "kind": "PodList",
  "apiVersion": "v1",
  "metadata": {
    "resourceVersion": "33074"
  },
  "items": [
    {
      "metadata": {
        "name": "kubernetes-bootcamp-2321272333-ix8pt",
        "generateName": "kubernetes-bootcamp-2321272333-",
        "namespace": "default",
        "uid": "ba21457c-6b1d-11e6-85f7-1ef9f1dab92b",
        "resourceVersion": "33003",
        "creationTimestamp": "2016-08-25T23:43:30Z",
        "labels": {
          "pod-template-hash": "2321272333",
          "run": "kubernetes-bootcamp"
        },
        ...
}

Що далі

Дізнайтеся більше про kubectl proxy.

6 - Використання SOCKS5-проксі для доступу до Kubernetes API

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

На цій сторінці показано, як використовувати SOCKS5-проксі для доступу до API віддаленого кластера Kubernetes. Це корисно, коли кластер, до якого ви хочете отримати доступ, не відкриває свій API безпосередньо в публічному інтернеті.

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

Вам треба мати кластер Kubernetes, а також інструмент командного рядка kubectl має бути налаштований для роботи з вашим кластером. Рекомендується виконувати ці настанови у кластері, що має щонайменше два вузли, які не виконують роль вузлів управління. Якщо у вас немає кластера, ви можете створити його, за допомогою minikube або використовувати одну з цих пісочниць:

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

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

Вам потрібне клієнтське програмне забезпечення SSH (інструмент ssh) і сервіс SSH, що працює на віддаленому сервері. Ви повинні мати змогу увійти в сервіс SSH на віддаленому сервері.

Контекст завдання

Примітка:

У цьому прикладі трафік тунелюється через SSH, а клієнт і сервер SSH діють як SOCKS-проксі. Натомість можна використовувати будь-який інший вид проксі SOCKS5.

Схема 1 показує, чого ви досягнете в цьому завданні.

  • У вас є клієнтський компʼютер, який у наступних кроках називається локальним, з якого ви надсилатимете запити до Kubernetes API.
  • Сервер Kubernetes/API розміщений на віддаленому сервері.
  • Ви використаєте клієнтське й серверне програмне забезпечення SSH, щоб створити захищений тунель SOCKS5 між локальним і віддаленим сервером. Трафік HTTPS між клієнтом і Kubernetes API проходитиме через тунель SOCKS5, який сам тунелюється через SSH.

graph LR;

  subgraph local[Локальний клієнтський компʼютер]
  client([клієнт])-. локальний 
трафік .-> local_ssh[Локальний SSH
SOCKS5 проксі]; end local_ssh[SSH
SOCKS5
проксі]-- SSH-тунель -->sshd subgraph remote[Віддалений сервер] sshd[SSH
сервер]-- локальний трафік -->service1; end client([клієнт])-. проксійований HTTPS-трафік
проходить через проксі .->service1[Kubernetes API]; classDef plain fill:#ddd,stroke:#fff,stroke-width:4px,color:#000; classDef k8s fill:#326ce5,stroke:#fff,stroke-width:4px,color:#fff; classDef cluster fill:#fff,stroke:#bbb,stroke-width:2px,color:#326ce5; class ingress,service1,service2,pod1,pod2,pod3,pod4 k8s; class client plain; class cluster cluster;
Схема 1. Компоненти навчального матеріалу про SOCKS5

Використання ssh для створення SOCKS5-проксі

Наведена нижче команда запускає SOCKS5-проксі між вашим клієнтським компʼютером і віддаленим SOCKS-сервером:

# SSH-тунель продовжує працювати на передньому плані після виконання цієї команди
ssh -D 1080 -q -N username@kubernetes-remote-server.example

SOCKS5-проксі дає змогу підʼєднуватися до API-сервера вашого кластера на основі такої конфігурації:

  • -D 1080: відкриває SOCKS-проксі на локальному порту :1080.
  • -q: тихий режим. Приглушує більшість попереджень і діагностичних повідомлень.
  • -N: не виконувати віддалені команди. Корисно для простого пересилання портів.
  • username@kubernetes-remote-server.example: віддалений SSH-сервер, за яким працює кластер Kubernetes (наприклад, bastion host).

Конфігурація клієнта

Щоб отримати доступ до API-сервера Kubernetes через проксі, потрібно вказати kubectl надсилати запити через створений раніше проксі SOCKS. Зробіть це, встановивши відповідну змінну середовища або атрибут proxy-url у файлі kubeconfig. Використання змінної середовища:

export HTTPS_PROXY=socks5://localhost:1080

Щоб завжди використовувати це налаштування в конкретному контексті kubectl, вкажіть атрибут proxy-url у відповідному записі cluster у файлі ~/.kube/config. Наприклад:

apiVersion: v1
clusters:
- cluster:
    certificate-authority-data: LRMEMMW2 # скорочено для читабельності
    server: https://<API_SERVER_IP_ADDRESS>:6443  # сервер "Kubernetes API", тобто IP-адреса kubernetes-remote-server.example
    proxy-url: socks5://localhost:1080   # "SSH SOCKS5 проксі" на діаграмі вище
  name: default
contexts:
- context:
    cluster: default
    user: default
  name: default
current-context: default
kind: Config
preferences: {}
users:
- name: default
  user:
    client-certificate-data: LS0tLS1CR== # скорочено для читабельності
    client-key-data: LS0tLS1CRUdJT=      # скорочено для читабельності

Після створення тунелю згаданою вище командою ssh і визначення змінної середовища або атрибута proxy-url ви можете взаємодіяти з кластером через цей проксі. Наприклад:

kubectl get pods
NAMESPACE     NAME                                     READY   STATUS      RESTARTS   AGE
kube-system   coredns-85cb69466-klwq8                  1/1     Running     0          5m46s

Примітка:

  • До версії kubectl 1.24 більшість команд kubectl працювали із socks-проксі, за винятком kubectl exec.

  • kubectl підтримує змінні середовища HTTPS_PROXY і https_proxy. Їх використовують інші програми, що підтримують SOCKS, як-от curl. Тому в деяких випадках краще визначити змінну середовища в командному рядку:

    HTTPS_PROXY=socks5://localhost:1080 kubectl get pods
    
  • Якщо використовується proxy-url, проксі застосовується лише для відповідного контексту kubectl, тоді як змінна середовища впливає на всі контексти.

  • Імʼя хоста API-сервера k8s можна додатково захистити від витоку DNS, використовуючи назву протоколу socks5h замість ширше відомого протоколу socks5, показаного вище. У цьому випадку kubectl попросить проксі-сервер (наприклад, ssh bastion) розвʼязати доменне імʼя API-сервера k8s замість того, щоб розвʼязувати його в системі, де працює kubectl. Зауважте також, що з socks5h URL API-сервера k8s, як-от https://localhost:6443/api, не вказує на ваш локальний клієнтський компʼютер. Натомість він вказує на localhost, відомий на проксі-сервері (наприклад, ssh bastion).

Очищення

Зупиніть процес пересилання портів ssh, натиснувши CTRL+C у терміналі, де він працює.

Введіть unset https_proxy у терміналі, щоб припинити пересилання http-трафіку через проксі.

Додаткові матеріали

7 - Налаштування служби Konnectivity

Служба Konnectivity надає проксі на рівні TCP для звʼязку панелі управління з кластером.

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

Вам потрібен кластер Kubernetes, а інструмент командного рядка kubectl має бути налаштований на звʼязок із вашим кластером. Рекомендовано виконувати цей навчальний матеріал на кластері щонайменше з двома вузлами, які не є хостами панелі управління. Якщо у вас ще немає кластера, ви можете створити його за допомогою minikube.

Налаштування служби Konnectivity

Для виконання наведених нижче кроків потрібна конфігурація egress, наприклад:

apiVersion: apiserver.k8s.io/v1beta1
kind: EgressSelectorConfiguration
egressSelections:
# Since we want to control the egress traffic to the cluster, we use the
# "cluster" as the name. Other supported values are "etcd", and "controlplane".
- name: cluster
  connection:
    # This controls the protocol between the API Server and the Konnectivity
    # server. Supported values are "GRPC" and "HTTPConnect". There is no
    # end user visible difference between the two modes. You need to set the
    # Konnectivity server to work in the same mode.
    proxyProtocol: GRPC
    transport:
      # This controls what transport the API Server uses to communicate with the
      # Konnectivity server. UDS is recommended if the Konnectivity server
      # locates on the same machine as the API Server. You need to configure the
      # Konnectivity server to listen on the same UDS socket.
      # The other supported transport is "tcp". You will need to set up TLS 
      # config to secure the TCP transport.
      uds:
        udsName: /etc/kubernetes/konnectivity-server/konnectivity-server.socket

Потрібно налаштувати API-сервер на використання служби Konnectivity і спрямування мережевого трафіку на вузли кластера:

  1. Переконайтеся, що у вашому кластері увімкнено можливість проєкції томів токенів службових облікових записів. Вона стандартно увімкнена з версії Kubernetes v1.20.

  2. Створіть файл конфігурації egress, наприклад admin/konnectivity/egress-selector-configuration.yaml.

  3. Встановіть прапорець --egress-selector-config-file API-сервера на шлях до файлу конфігурації egress API-сервера.

  4. Якщо ви використовуєте зʼєднання UDS, додайте конфігурацію томів до kube-apiserver:

    spec:
      containers:
        volumeMounts:
        - name: konnectivity-uds
          mountPath: /etc/kubernetes/konnectivity-server
          readOnly: false
      volumes:
      - name: konnectivity-uds
        hostPath:
          path: /etc/kubernetes/konnectivity-server
          type: DirectoryOrCreate
    

Згенеруйте або отримайте сертифікат і kubeconfig для konnectivity-server. Наприклад, можна використати інструмент командного рядка OpenSSL, щоб видати сертифікат X.509 за допомогою сертифіката CA кластера /etc/kubernetes/pki/ca.crt з хоста панелі управління.

openssl req -subj "/CN=system:konnectivity-server" -new -newkey rsa:2048 -noenc -out konnectivity.csr -keyout konnectivity.key
openssl x509 -req -in konnectivity.csr -CA /etc/kubernetes/pki/ca.crt -CAkey /etc/kubernetes/pki/ca.key -CAcreateserial -out konnectivity.crt -days 375 -sha256
SERVER=$(kubectl config view -o jsonpath='{.clusters..server}')
kubectl --kubeconfig /etc/kubernetes/konnectivity-server.conf config set-credentials system:konnectivity-server --client-certificate konnectivity.crt --client-key konnectivity.key --embed-certs=true
kubectl --kubeconfig /etc/kubernetes/konnectivity-server.conf config set-cluster kubernetes --server "$SERVER" --certificate-authority /etc/kubernetes/pki/ca.crt --embed-certs=true
kubectl --kubeconfig /etc/kubernetes/konnectivity-server.conf config set-context system:konnectivity-server@kubernetes --cluster kubernetes --user system:konnectivity-server
kubectl --kubeconfig /etc/kubernetes/konnectivity-server.conf config use-context system:konnectivity-server@kubernetes
rm -f konnectivity.crt konnectivity.key konnectivity.csr

Далі потрібно розгорнути сервер Konnectivity та агентів. kubernetes-sigs/apiserver-network-proxy — це еталонна реалізація.

Розгорніть сервер Konnectivity на вузлі панелі управління. Наданий маніфест konnectivity-server.yaml передбачає, що компоненти Kubernetes розгорнуто як статичний Pod у вашому кластері. Якщо ні, сервер Konnectivity можна розгорнути як DaemonSet.

apiVersion: v1
kind: Pod
metadata:
  name: konnectivity-server
  namespace: kube-system
spec:
  priorityClassName: system-cluster-critical
  hostNetwork: true
  containers:
  - name: konnectivity-server-container
    image: registry.k8s.io/kas-network-proxy/proxy-server:v0.0.37
    command: ["/proxy-server"]
    args: [
            "--logtostderr=true",
            # This needs to be consistent with the value set in egressSelectorConfiguration.
            "--uds-name=/etc/kubernetes/konnectivity-server/konnectivity-server.socket",
            "--delete-existing-uds-file",
            # The following two lines assume the Konnectivity server is
            # deployed on the same machine as the apiserver, and the certs and
            # key of the API Server are at the specified location.
            "--cluster-cert=/etc/kubernetes/pki/apiserver.crt",
            "--cluster-key=/etc/kubernetes/pki/apiserver.key",
            # This needs to be consistent with the value set in egressSelectorConfiguration.
            "--mode=grpc",
            "--server-port=0",
            "--agent-port=8132",
            "--admin-port=8133",
            "--health-port=8134",
            "--agent-namespace=kube-system",
            "--agent-service-account=konnectivity-agent",
            "--kubeconfig=/etc/kubernetes/konnectivity-server.conf",
            "--authentication-audience=system:konnectivity-server"
            ]
    livenessProbe:
      httpGet:
        scheme: HTTP
        host: 127.0.0.1
        port: 8134
        path: /healthz
      initialDelaySeconds: 30
      timeoutSeconds: 60
    ports:
    - name: agentport
      containerPort: 8132
      hostPort: 8132
    - name: adminport
      containerPort: 8133
      hostPort: 8133
    - name: healthport
      containerPort: 8134
      hostPort: 8134
    volumeMounts:
    - name: k8s-certs
      mountPath: /etc/kubernetes/pki
      readOnly: true
    - name: kubeconfig
      mountPath: /etc/kubernetes/konnectivity-server.conf
      readOnly: true
    - name: konnectivity-uds
      mountPath: /etc/kubernetes/konnectivity-server
      readOnly: false
  volumes:
  - name: k8s-certs
    hostPath:
      path: /etc/kubernetes/pki
  - name: kubeconfig
    hostPath:
      path: /etc/kubernetes/konnectivity-server.conf
      type: FileOrCreate
  - name: konnectivity-uds
    hostPath:
      path: /etc/kubernetes/konnectivity-server
      type: DirectoryOrCreate

Потім розгорніть агентів Konnectivity у вашому кластері:

apiVersion: apps/v1
# Як альтернативу, ви можете розгорнути агентів як Deployment. Не обовʼязково
# мати агента на кожному вузлі.
kind: DaemonSet
metadata:
  labels:
    addonmanager.kubernetes.io/mode: Reconcile
    k8s-app: konnectivity-agent
  namespace: kube-system
  name: konnectivity-agent
spec:
  selector:
    matchLabels:
      k8s-app: konnectivity-agent
  template:
    metadata:
      labels:
        k8s-app: konnectivity-agent
    spec:
      priorityClassName: system-cluster-critical
      tolerations:
        - key: "CriticalAddonsOnly"
          operator: "Exists"
      containers:
        - image: us.gcr.io/k8s-artifacts-prod/kas-network-proxy/proxy-agent:v0.0.37
          name: konnectivity-agent
          command: ["/proxy-agent"]
          args: [
                  "--logtostderr=true",
                  "--ca-cert=/var/run/secrets/kubernetes.io/serviceaccount/ca.crt",
                  # Оскільки сервер konnectivity працює з hostNetwork=true,
                  # це IP-адреса master-машини.
                  "--proxy-server-host=35.225.206.7",
                  "--proxy-server-port=8132",
                  "--admin-server-port=8133",
                  "--health-server-port=8134",
                  "--service-account-token-path=/var/run/secrets/tokens/konnectivity-agent-token"
                  ]
          volumeMounts:
            - mountPath: /var/run/secrets/tokens
              name: konnectivity-agent-token
          livenessProbe:
            httpGet:
              port: 8134
              path: /healthz
            initialDelaySeconds: 15
            timeoutSeconds: 15
      serviceAccountName: konnectivity-agent
      volumes:
        - name: konnectivity-agent-token
          projected:
            sources:
              - serviceAccountToken:
                  path: konnectivity-agent-token
                  audience: system:konnectivity-server

Нарешті, якщо RBAC увімкнено у вашому кластері, створіть відповідні правила RBAC:

apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: system:konnectivity-server
  labels:
    kubernetes.io/cluster-service: "true"
    addonmanager.kubernetes.io/mode: Reconcile
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: system:auth-delegator
subjects:
  - apiGroup: rbac.authorization.k8s.io
    kind: User
    name: system:konnectivity-server
---
apiVersion: v1
kind: ServiceAccount
metadata:
  name: konnectivity-agent
  namespace: kube-system
  labels:
    kubernetes.io/cluster-service: "true"
    addonmanager.kubernetes.io/mode: Reconcile