Цей розділ документації Kubernetes містить сторінки, які показують, як виконувати окремі завдання. Сторінка завдання показує, як виконати одну дію, зазвичай за допомогою короткої послідовності кроків.
Налаштування інструментів Kubernetes на вашому компʼютері.
Примітка:
Щоб налаштувати середовище для практики, дивіться сторінку Навчальне середовище.
kubectl
Інструмент командного рядка Kubernetes, kubectl, дозволяє виконувати команди в кластерах Kubernetes. За допомогою kubectl можна розгортати застосунки, оглядати ресурси кластера й керувати ними, а також переглядати логи. Докладніше, зокрема повний перелік операцій kubectl, дивіться в довідковій документації kubectl.
kubectl можна встановити на різних платформах Linux, macOS і Windows. Виберіть свою операційну систему нижче.
Подібно до kind, minikube — це інструмент, який дозволяє запускати Kubernetes локально. minikube запускає локальний кластер Kubernetes «все в одному» або багатовузловий кластер на вашому персональному компʼютері (зокрема на ПК з Windows, macOS і Linux), щоб ви могли випробувати Kubernetes або використовувати його для щоденної розробки.
Якщо ваша мета — встановити інструмент, скористайтеся офіційним посібником Get Started!.
Ви можете використовувати інструмент kubeadm для створення кластерів Kubernetes і керування ними. Він виконує дії, потрібні для зручного запуску мінімально життєздатного захищеного кластера.
1.1 - Встановлення та налаштування kubectl у Linux
Перш ніж ви розпочнете
Вам потрібно використовувати версію kubectl, яка має мінорну версію, що відрізняється не більше ніж на одиницю від мінорної версії вашого кластера. Наприклад, клієнт v1.37 може співпрацювати з панелями управління v1.36, v1.37 та v1.38. Використання останньої сумісної версії kubectl допомагає уникнути непередбачуваних проблем.
Встановлення kubectl у Linux
Існують наступні методи встановлення kubectl у Linux:
Якщо у вас немає прав root на цільовій системі, все одно можна встановити
kubectl у теку ~/.local/bin:
chmod +x kubectl
mkdir -p ~/.local/bin
mv ./kubectl ~/.local/bin/kubectl
# а потім додайте (в початок чи кінець) ~/.local/bin до $PATH
Перевірте, щоб переконатися, що встановлена вами версія є актуальною:
kubectl version --client
Або скористайтеся цим для детального перегляду версії:
kubectl version --client --output=yaml
Встановлення за допомогою стандартного пакетного менеджера
Оновіть індекс пакунків apt та встановіть пакунки, необхідні для використання репозиторію apt Kubernetes:
sudo apt-get update
# apt-transport-https може бути макетним пакетом; якщо так, ви можете пропустити цей пакетsudo apt-get install -y apt-transport-https ca-certificates curl gnupg
Завантажте публічний ключ підпису для репозиторіїв пакунків Kubernetes. Той самий ключ підпису використовується для всіх репозиторіїв, тому ви можете проігнорувати версію в URL:
# Якщо тека `/etc/apt/keyrings` не існує, її слід створити перед запуском curl, прочитайте примітку нижче.# sudo mkdir -p -m 755 /etc/apt/keyringscurl -fsSL https://pkgs.k8s.io/core:/stable:/v1.37/deb/Release.key | sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg
sudo chmod 644 /etc/apt/keyrings/kubernetes-apt-keyring.gpg # дозволяє непривілейованим програмам APT читати цей ключ
Примітка:
У випусках, старіших за Debian 12 і Ubuntu 22.04, тека /etc/apt/keyrings типово не існує, її слід створити перед запуском команди curl.
Додайте відповідний репозиторій Kubernetes apt. Якщо ви хочете використовувати версію Kubernetes, відмінну від v1.37, замініть v1.37 на потрібну мінорну версію в команді нижче:
# Це перезапише будь-яку існуючу конфігурацію в /etc/apt/sources.list.d/kubernetes.listecho'deb [signed-by=/etc/apt/keyrings/kubernetes-apt-keyring.gpg] https://pkgs.k8s.io/core:/stable:/v1.37/deb/ /'| sudo tee /etc/apt/sources.list.d/kubernetes.list
sudo chmod 644 /etc/apt/sources.list.d/kubernetes.list # допомагає правильно працювати з такими інструментами, як command-not-found
Примітка:
Щоб оновити kubectl до іншого мінорного випуску, вам потрібно буде збільшити версію в /etc/apt/sources.list.d/kubernetes.list перед виконанням apt-get update та apt-get upgrade. Цю процедуру більш докладно описано в Зміні репозиторію пакунків Kubernetes.
Оновіть індекс пакунків apt, а потім встановіть kubectl:
Додайте репозиторій Kubernetes yum. Якщо ви хочете використовувати версію Kubernetes, відмінну від v1.37, замініть v1.37 на потрібну мінорну версію в команді нижче.
# Це перезапише будь-яку існуючу конфігурацію у /etc/yum.repos.d/kubernetes.repocat <<EOF | sudo tee /etc/yum.repos.d/kubernetes.repo
[kubernetes]
name=Kubernetes
baseurl=https://pkgs.k8s.io/core:/stable:/v1.37/rpm/
enabled=1
gpgcheck=1
gpgkey=https://pkgs.k8s.io/core:/stable:/v1.37/rpm/repodata/repomd.xml.key
EOF
Примітка:
Щоб оновити kubectl до іншого мінорного випуску, вам потрібно буде збільшити версію в /etc/yum.repos.d/kubernetes.repo перед виконанням dnf update. Цю процедуру більш докладно описано в Зміні репозиторію пакунків Kubernetes.
Встановіть kubectl за допомогою dnf:
sudo dnf install -y kubectl
Додайте репозиторій Kubernetes zypper. Якщо ви хочете використовувати версію Kubernetes, відмінну від v1.37, замініть v1.37 на потрібну мінорну версію в команді нижче.
# Це перезапише будь-яку існуючу конфігурацію у /etc/zypp/repos.d/kubernetes.repocat <<EOF | sudo tee /etc/zypp/repos.d/kubernetes.repo
[kubernetes]
name=Kubernetes
baseurl=https://pkgs.k8s.io/core:/stable:/v1.37/rpm/
enabled=1
gpgcheck=1
gpgkey=https://pkgs.k8s.io/core:/stable:/v1.37/rpm/repodata/repomd.xml.key
EOF
Примітка:
Щоб оновити kubectl до іншого мінорного випуску, вам потрібно буде збільшити версію в /etc/zypp/repos.d/kubernetes.repo перед виконанням zypper update. Цю процедуру більш докладно описано в
Зміні репозиторію пакунків Kubernetes.
Оновіть zypper і підтвердіть додавання нового репозиторію:
sudo zypper update
Коли зʼявиться таке повідомлення, натисніть 't' або 'a':
New repository or package signing key received:
Repository: Kubernetes
Key Fingerprint: 1111 2222 3333 4444 5555 6666 7777 8888 9999 AAAA
Key Name: isv:kubernetes OBS Project <isv:kubernetes@build.opensuse.org>
Key Algorithm: RSA 2048
Key Created: Thu 25 Aug 2022 01:21:11 PM -03
Key Expires: Sat 02 Nov 2024 01:21:11 PM -03 (expires in 85 days)
Rpm Name: gpg-pubkey-9a296436-6307a177
Note: Signing data enables the recipient to verify that no modifications occurred after the data
were signed. Accepting data with no, wrong or unknown signature can lead to a corrupted system
and in extreme cases even to a system compromise.
Note: A GPG pubkey is clearly identified by its fingerprint. Do not rely on the key's name. If
you are not sure whether the presented key is authentic, ask the repository provider or check
their web site. Many providers maintain a web page showing the fingerprints of the GPG keys they
are using.
Do you want to reject the key, trust temporarily, or trust always? [r/t/a/?] (r): a
Встановіть kubectl, використовуючи zypper:
sudo zypper install -y kubectl
Встановлення за допомогою іншого пакетного менеджера
Якщо ви користуєтеся Ubuntu або іншим дистрибутивом Linux, який підтримує менеджер пакунків snap, kubectl доступний як застосунок snap.
snap install kubectl --classic
kubectl version --client
Якщо ви користуєтеся Linux і використовуєте пакетний менеджер Homebrew, kubectl доступний для встановлення.
brew install kubectl
kubectl version --client
Перевірка конфігурації kubectl
Щоб kubectl міг знайти кластер Kubernetes і отримати до нього доступ, йому потрібен файл kubeconfig, який створюється автоматично, коли ви створюєте кластер за допомогою kube-up.sh або успішно розгортаєте кластер Minikube. Стандартно конфігурація kubectl міститься в ~/.kube/config.
Перевірте, що kubectl правильно налаштований, отримавши стан кластера:
kubectl cluster-info
Якщо у відповідь ви бачите URL, kubectl правильно налаштований для доступу до вашого кластера.
Якщо ви бачите повідомлення, подібне до наведеного нижче, kubectl налаштований неправильно або не може підʼєднатися до кластера Kubernetes.
The connection to the server <server-name:port> was refused - did you specify the right host or port?
Наприклад, якщо ви плануєте запускати кластер Kubernetes на своєму ноутбуці (локально), спочатку потрібно встановити інструмент на кшталт Minikube, а потім повторно виконати наведені вище команди.
Якщо kubectl cluster-info повертає у відповідь URL, але ви не можете отримати доступ до кластера, перевірте, чи він правильно налаштований, за допомогою такої команди:
kubectl cluster-info dump
Усунення несправностей із повідомленням про помилку 'No Auth Provider Found'
У Kubernetes 1.26 з kubectl вилучено вбудовану автентифікацію для керованих сервісів Kubernetes таких хмарних провайдерів. Ці провайдери випустили втулки kubectl, що забезпечують автентифікацію для їхніх хмар. Інструкції дивіться в документації провайдера:
Те саме повідомлення про помилку може мати й інші причини, не повʼязані з цією зміною.
Необовʼязкові налаштування та втулки kubectl
Увімкнення автодоповнення оболонки
kubectl надає підтримку автодоповнення для оболонок Bash, Zsh, Fish та PowerShell, що може зекономити вам багато часу на набір тексту.
Нижче наведені процедури для налаштування автодоповнення для оболонок Bash, Fish та Zsh.
Вступ
Скрипт автодоповнення kubectl для Bash можна згенерувати командою kubectl completion bash. Підключення цього скрипта у вашій оболонці вмикає автодоповнення kubectl.
Однак скрипт автодоповнення залежить від bash-completion, тому спочатку потрібно встановити це програмне забезпечення (ви можете перевірити, чи вже встановлено bash-completion, виконавши type _init_completion).
Встановлення bash-completion
bash-completion є в багатьох менеджерах пакунків (див. тут). Ви можете встановити його за допомогою apt-get install bash-completion, dnf install bash-completion тощо.
Наведені вище команди створюють /usr/share/bash-completion/bash_completion, основний скрипт bash-completion. Залежно від вашого менеджера пакунків може знадобитися вручну підключити цей файл у файлі ~/.bashrc.
Щоб це зʼясувати, перезавантажте оболонку й виконайте type _init_completion. Якщо команда виконується успішно, усе вже налаштовано; інакше додайте наведене нижче до файлу ~/.bashrc:
source /usr/share/bash-completion/bash_completion
Перезавантажте оболонку й перевірте, що bash-completion правильно встановлено, виконавши type _init_completion.
Увімкнення автодоповнення kubectl
Bash
Тепер потрібно забезпечити підключення скрипта автодоповнення kubectl в усіх сеансах оболонки. Це можна зробити двома способами:
Якщо у вас є псевдонім для kubectl, ви можете розширити автодоповнення оболонки, щоб воно працювало з цим псевдонімом:
echo'alias k=kubectl' >>~/.bashrc
echo'complete -o default -F __start_kubectl k' >>~/.bashrc
Примітка:
bash-completion підключає всі скрипти автодоповнення з /etc/bash_completion.d.
Обидва підходи рівноцінні. Після перезавантаження оболонки автодоповнення kubectl має працювати. Щоб увімкнути автодоповнення bash у поточному сеансі оболонки, підключіть файл ~/.bashrc:
source ~/.bashrc
Примітка:
Автодоповнення для Fish потребує kubectl версії 1.23 або новішої.
Скрипт автодоповнення kubectl для Fish можна згенерувати командою kubectl completion fish. Підключення цього скрипта у вашій оболонці вмикає автодоповнення kubectl.
Щоб зробити це в усіх сеансах оболонки, додайте такий рядок до файлу ~/.config/fish/config.fish:
kubectl completion fish |source
Після перезавантаження оболонки автодоповнення kubectl має працювати.
Скрипт автодоповнення kubectl для Zsh можна згенерувати командою kubectl completion zsh. Підключення цього скрипта у вашій оболонці вмикає автодоповнення kubectl.
Щоб зробити це в усіх сеансах оболонки, додайте наведене нижче до файлу ~/.zshrc:
source <(kubectl completion zsh)
Якщо у вас є псевдонім для kubectl, автодоповнення kubectl автоматично працюватиме з ним.
Після перезавантаження оболонки автодоповнення kubectl має працювати.
Якщо ви отримуєте помилку на кшталт 2: command not found: compdef, додайте наведене нижче на початок файлу ~/.zshrc:
autoload -Uz compinit
compinit
Налаштування kuberc
Дивіться kuberc для отримання докладної інформації.
Встановлення втулка kubectl convert
Втулок для інструмента командного рядка Kubernetes kubectl, який дозволяє конвертувати маніфести між різними версіями API. Це може бути особливо корисно для міграції маніфестів на незастарілу версію API в новіших випусках Kubernetes. Докладніше дивіться в розділі перехід на незастарілі API.
Завантажте останній випуск за допомогою наступної команди:
1.2 - Встановлення та налаштування kubectl у macOS
Перш ніж ви розпочнете
Вам потрібно використовувати версію kubectl, яка має мінорну версію, що відрізняється не більше ніж на одиницю від мінорної версії вашого кластера. Наприклад, клієнт v1.37 може співпрацювати з панелями управління v1.36, v1.37 та v1.38. Використання останньої сумісної версії kubectl допомагає уникнути непередбачуваних проблем.
Встановлення kubectl у macOS
Існують наступні методи встановлення kubectl у macOS:
Переконайтеся, що /usr/local/bin є у вашій змінній середовища PATH.
Перевірте, що встановлена версія kubectl актуальна:
kubectl version --client
Або використовуйте це для детального перегляду версії:
kubectl version --client --output=yaml
Після встановлення та перевірки kubectl видаліть файл контрольної суми:
rm kubectl.sha256
Встановлення за допомогою Homebrew у macOS
Якщо ви користуєтеся macOS і пакетним менеджером Homebrew, ви можете встановити kubectl за допомогою Homebrew.
Виконайте команду встановлення:
brew install kubectl
або
brew install kubernetes-cli
Перевірте, що встановлена версія актуальна:
kubectl version --client
Встановлення за допомогою Macports у macOS
Якщо ви користуєтеся macOS і пакетним менеджером Macports, ви можете встановити kubectl за допомогою Macports.
Виконайте команду встановлення:
sudo port selfupdate
sudo port install kubectl
Перевірте, що встановлена версія актуальна:
kubectl version --client
Перевірка конфігурації kubectl
Щоб kubectl міг знайти кластер Kubernetes і отримати до нього доступ, йому потрібен файл kubeconfig, який створюється автоматично, коли ви створюєте кластер за допомогою kube-up.sh або успішно розгортаєте кластер Minikube. Стандартно конфігурація kubectl міститься в ~/.kube/config.
Перевірте, що kubectl правильно налаштований, отримавши стан кластера:
kubectl cluster-info
Якщо у відповідь ви бачите URL, kubectl правильно налаштований для доступу до вашого кластера.
Якщо ви бачите повідомлення, подібне до наведеного нижче, kubectl налаштований неправильно або не може підʼєднатися до кластера Kubernetes.
The connection to the server <server-name:port> was refused - did you specify the right host or port?
Наприклад, якщо ви плануєте запускати кластер Kubernetes на своєму ноутбуці (локально), спочатку потрібно встановити інструмент на кшталт Minikube, а потім повторно виконати наведені вище команди.
Якщо kubectl cluster-info повертає у відповідь URL, але ви не можете отримати доступ до кластера, перевірте, чи він правильно налаштований, за допомогою такої команди:
kubectl cluster-info dump
Усунення несправностей із повідомленням про помилку 'No Auth Provider Found'
У Kubernetes 1.26 з kubectl вилучено вбудовану автентифікацію для керованих сервісів Kubernetes таких хмарних провайдерів. Ці провайдери випустили втулки kubectl, що забезпечують автентифікацію для їхніх хмар. Інструкції дивіться в документації провайдера:
Те саме повідомлення про помилку може мати й інші причини, не повʼязані з цією зміною.
Необовʼязкові налаштування та втулки kubectl
Увімкнення автодоповнення оболонки
kubectl надає підтримку автодоповнення для оболонок Bash, Zsh, Fish та PowerShell, що може значно зекономити ваш час при введенні команд.
Нижче подані процедури для налаштування автодоповнення для оболонок Bash, Fish та Zsh.
Вступ
Скрипт автодоповнення kubectl для Bash можна згенерувати командою kubectl completion bash. Підключення цього скрипта у вашій оболонці вмикає автодоповнення kubectl.
Однак скрипт автодоповнення kubectl залежить від bash-completion, який потрібно встановити заздалегідь.
Попередження:
Існують дві версії bash-completion: v1 і v2. V1 призначена для Bash 3.2 (стандартна версія в macOS), а v2 — для Bash 4.1+. Скрипт автодоповнення kubectl не працює правильно з bash-completion v1 і Bash 3.2. Він потребує bash-completion v2 і Bash 4.1+. Отже, щоб правильно використовувати автодоповнення kubectl у macOS, потрібно встановити й використовувати Bash 4.1+ (інструкції). Наведені нижче інструкції передбачають, що ви використовуєте Bash 4.1+ (тобто будь-яку версію Bash 4.1 або новішу).
Оновлення Bash
Ці інструкції передбачають, що ви використовуєте Bash 4.1+. Перевірити версію Bash можна, виконавши:
echo$BASH_VERSION
Якщо вона надто стара, ви можете встановити або оновити її за допомогою Homebrew:
brew install bash
Перезавантажте оболонку й перевірте, що використовується потрібна версія:
echo$BASH_VERSION$SHELL
Зазвичай Homebrew встановлює його в /usr/local/bin/bash.
Встановлення bash-completion
Примітка:
Як уже зазначалося, ці інструкції передбачають використання Bash 4.1+, тобто ви встановлюватимете bash-completion v2 (на відміну від Bash 3.2 і bash-completion v1, де автодоповнення kubectl не працюватиме).
Ви можете перевірити, чи вже встановлено bash-completion v2, за допомогою type _init_completion. Якщо ні, встановіть його за допомогою Homebrew:
brew install bash-completion@2
Як зазначено у виводі цієї команди, додайте наведене нижче до файлу ~/.bash_profile:
Якщо у вас є псевдонім для kubectl, ви можете розширити автодоповнення оболонки, щоб воно працювало з цим псевдонімом:
echo'alias k=kubectl' >>~/.bash_profile
echo'complete -o default -F __start_kubectl k' >>~/.bash_profile
Якщо ви встановили kubectl за допомогою Homebrew (як пояснено тут), скрипт автодоповнення kubectl вже має бути в /usr/local/etc/bash_completion.d/kubectl. У цьому випадку нічого робити не потрібно.
Примітка:
Установлення bash-completion v2 через Homebrew підключає всі файли з теки BASH_COMPLETION_COMPAT_DIR, тому два останні способи працюють.
У будь-якому разі після перезавантаження оболонки автодоповнення kubectl має працювати.
Примітка:
Автодоповнення для Fish потребує kubectl версії 1.23 або новішої.
Скрипт автодоповнення kubectl для Fish можна згенерувати командою kubectl completion fish. Підключення цього скрипта у вашій оболонці вмикає автодоповнення kubectl.
Щоб зробити це в усіх сеансах оболонки, додайте такий рядок до файлу ~/.config/fish/config.fish:
kubectl completion fish |source
Після перезавантаження оболонки автодоповнення kubectl має працювати.
Скрипт автодоповнення kubectl для Zsh можна згенерувати командою kubectl completion zsh. Підключення цього скрипта у вашій оболонці вмикає автодоповнення kubectl.
Щоб зробити це в усіх сеансах оболонки, додайте наведене нижче до файлу ~/.zshrc:
source <(kubectl completion zsh)
Якщо у вас є псевдонім для kubectl, автодоповнення kubectl автоматично працюватиме з ним.
Після перезавантаження оболонки автодоповнення kubectl має працювати.
Якщо ви отримуєте помилку на кшталт 2: command not found: compdef, додайте наведене нижче на початок файлу ~/.zshrc:
autoload -Uz compinit
compinit
Налаштування kuberc
Дивіться kuberc для отримання докладної інформації.
Встановлення втулка kubectl convert
Втулок для інструмента командного рядка Kubernetes kubectl, який дозволяє конвертувати маніфести між різними версіями API. Це може бути особливо корисно для міграції маніфестів на незастарілу версію API в новіших випусках Kubernetes. Докладніше дивіться в розділі перехід на незастарілі API.
1.3 - Встановлення та налаштування kubectl у Windows
Перш ніж ви розпочнете
Вам потрібно використовувати версію kubectl, яка має мінорну версію, що відрізняється не більше ніж на одиницю від мінорної версії вашого кластера. Наприклад, клієнт v1.37 може співпрацювати з панелями управління v1.36, v1.37 та v1.38. Використання останньої сумісної версії kubectl допомагає уникнути непередбачуваних проблем.
Встановлення kubectl у Windows
Існують наступні методи встановлення kubectl у Windows:
Встановлення бінарного файлу kubectl у Windows (через пряме завантаження або curl)
У вас є два варіанти встановлення kubectl на вашому пристрої з Windows
Безпосереднє завантаження:
Завантажте останню версію 1.37 патчу безпосередньо для вашої архітектури, відвідавши сторінку випуску Kubernetes. Переконайтеся, що вибрано правильний двійковий файл для вашої архітектури (наприклад, amd64, arm64 тощо).
Використовуючи curl:
Якщо у вас встановлено curl, використайте цю команду:
Додайте на початок чи в кінець змінної середовища PATH шлях до теки з kubectl.
Перевірте, що версія kubectl збігається з завантаженою:
kubectl version --client
Або використайте це для детального перегляду версії:
kubectl version --client --output=yaml
Примітка:
Docker Desktop for Windows додає свою власну версію kubectl до PATH. Якщо ви вже встановили Docker Desktop раніше, можливо, вам потрібно розмістити свій шлях в PATH перед тим, який додається інсталятором Docker Desktop, або видалити kubectl Docker Desktop.
Встановлення у Windows за допомогою Chocolatey, Scoop або winget
Для встановлення kubectl у Windows ви можете використовувати пакетний менеджер Chocolatey, командний інсталятор Scoop, або менеджер пакунків winget.
chocoinstallkubernetes-cli
scoopinstallkubectl
wingetinstall-e--idKubernetes.kubectl
Перевірте, що встановлена версія актуальна:
kubectlversion--client
Перейдіть до вашої домашньої теки:
# Якщо ви використовуєте cmd.exe, виконайте: cd %USERPROFILE%cd ~
Створіть теку .kube:
mkdir.kube
Перейдіть до теки .kube, що ви щойно створили:
cd .kube
Налаштуйте kubectl для використання віддаленого кластера Kubernetes:
New-Itemconfig-typefile
Примітка:
Редагуйте файл конфігурації за допомогою текстового редактора на ваш вибір, наприклад, Notepad.
Перевірка конфігурації kubectl
Щоб kubectl міг знайти кластер Kubernetes і отримати до нього доступ, йому потрібен файл kubeconfig, який створюється автоматично, коли ви створюєте кластер за допомогою kube-up.sh або успішно розгортаєте кластер Minikube. Стандартно конфігурація kubectl міститься в ~/.kube/config.
Перевірте, що kubectl правильно налаштований, отримавши стан кластера:
kubectl cluster-info
Якщо у відповідь ви бачите URL, kubectl правильно налаштований для доступу до вашого кластера.
Якщо ви бачите повідомлення, подібне до наведеного нижче, kubectl налаштований неправильно або не може підʼєднатися до кластера Kubernetes.
The connection to the server <server-name:port> was refused - did you specify the right host or port?
Наприклад, якщо ви плануєте запускати кластер Kubernetes на своєму ноутбуці (локально), спочатку потрібно встановити інструмент на кшталт Minikube, а потім повторно виконати наведені вище команди.
Якщо kubectl cluster-info повертає у відповідь URL, але ви не можете отримати доступ до кластера, перевірте, чи він правильно налаштований, за допомогою такої команди:
kubectl cluster-info dump
Усунення несправностей із повідомленням про помилку 'No Auth Provider Found'
У Kubernetes 1.26 з kubectl вилучено вбудовану автентифікацію для керованих сервісів Kubernetes таких хмарних провайдерів. Ці провайдери випустили втулки kubectl, що забезпечують автентифікацію для їхніх хмар. Інструкції дивіться в документації провайдера:
Ця команда генеруватиме скрипт автодоповнення під час кожного запуску PowerShell. Ви також можете додати згенерований скрипт безпосередньо до файлу $PROFILE.
Щоб додати згенерований скрипт до файлу $PROFILE, виконайте такий рядок у командному рядку PowerShell:
kubectlcompletionpowershell>>$PROFILE
Після перезавантаження оболонки автодоповнення kubectl має працювати.
Налаштування kuberc
Дивіться kuberc для отримання докладної інформації.
Встановлення втулка kubectl convert
Втулок для інструмента командного рядка Kubernetes kubectl, який дозволяє конвертувати маніфести між різними версіями API. Це може бути особливо корисно для міграції маніфестів на незастарілу версію API в новіших випусках Kubernetes. Докладніше дивіться в розділі перехід на незастарілі API.
Завдання в цьому розділі призначені для тих, хто адмініструє наявний кластер:
2.1.1 - Оновлення вузлів Linux
Ця сторінка пояснює, як оновити робочі вузли Linux, створені за допомогою kubeadm.
Перш ніж ви розпочнете
Вам потрібен доступ до оболонки на всіх вузлах, а інструмент командного рядка kubectl має бути налаштований для звʼязку з вашим кластером. Рекомендується виконувати цей підручник у кластері, що має принаймні два вузли, які не є вузлами панелі управління.
Якщо ви використовуєте репозиторії пакунків, що належать спільноті (pkgs.k8s.io), вам потрібно увімкнути репозиторій пакунків для потрібного мінорного релізу Kubernetes. Це пояснено в документі Зміна репозиторію пакунків Kubernetes.
Примітка: Сховища застарілих пакунків (apt.kubernetes.io та yum.kubernetes.io) визнані
застарілими та заморожені станом на 13 вересня 2023.
Наполегливо рекомендується використання нових репозиторіїв пакунків, розміщених за адресою pkgs.k8s.io,
які є обовʼязковими для встановлення версій Kubernetes, випущених після 13 вересня 2023 року.
Застарілі репозиторії та їх вміст можуть бути видалені у будь-який момент у майбутньому без попереднього повідомлення.
Нові репозиторії пакунків надають можливість завантаження версій Kubernetes, починаючи з v1.24.0.
Оновлення робочих вузлів
Оновлення kubeadm та kubectl
Оновіть kubeadm та kubectl:
Примітка:
kubectl має бути в межах однієї мінорної версії від kube-apiserver згідно з політикою розбіжності версій. Якщо ви оновлюєте панель управління через кілька мінорних версій перед оновленням робочих вузлів, локальний kubectl на вузлі може вийти за межі дозволеної розбіжності. Оновлення kubectl разом з kubeadm тут гарантує, що він залишається в межах підтримуваного діапазону версій протягом усього процесу оновлення вузла.
# замініть x у 1.37.x-* на останню версію патчаsudo apt-mark unhold kubeadm kubectl &&\
sudo apt-get update && sudo apt-get install -y kubeadm='1.37.x-*'kubectl='1.37.x-*'&&\
sudo apt-mark hold kubeadm kubectl
Для систем з DNF4 (Fedora < 41, RHEL/CentOS < 10):
# замініть x у 1.37.x-* на останню версію патчаsudo dnf install -y kubeadm-'1.37.x-*' kubectl-'1.37.x-*' --disableexcludes=kubernetes
Для систем з DNF5:
# замініть x у 1.37.x-* на останню версію патчаsudo dnf install -y kubeadm-'1.37.x-*' kubectl-'1.37.x-*' --setopt=disable_excludes=kubernetes
Виклик "kubeadm upgrade"
Для робочих вузлів це оновлює локальну конфігурацію kubelet:
sudo kubeadm upgrade node
Виконайте drain вузла
Підготуйте вузол до обслуговування, позначивши його як недоступний для планування та виселивши робочі навантаження:
# виконайте цю команду на вузлі панелі управління# замініть <node-to-drain> імʼям вузла, для якого ви виконуєте drainkubectl drain <node-to-drain> --ignore-daemonsets
Оновлення kubelet
Оновіть kubelet:
# замініть x у 1.37.x-* на останню версію патчаsudo apt-mark unhold kubelet &&\
sudo apt-get update && sudo apt-get install -y kubelet='1.37.x-*'&&\
sudo apt-mark hold kubelet
Для систем з DNF4 (Fedora < 41, RHEL/CentOS < 10):
# замініть x у 1.37.x-* на останню версію патчаsudo dnf install -y kubelet-'1.37.x-*' --disableexcludes=kubernetes
Для систем з DNF5:
# замініть x у 1.37.x-* на останню версію патчаsudo dnf install -y kubelet-'1.37.x-*' --setopt=disable_excludes=kubernetes
Ця сторінка пояснює, як оновити вузол Windows, створений за допомогою kubeadm.
Перш ніж ви розпочнете
Вам потрібен доступ до оболонки на всіх вузлах, а інструмент командного рядка kubectl має бути налаштований для звʼязку з вашим кластером. Рекомендується виконувати цей підручник у кластері, що має принаймні два вузли, які не є вузлами панелі управління.
Версія вашого Kubernetes сервера має бути не старішою ніж 1.17.
# замініть 1.37.0 на вашу бажану версіюcurl.exe-Lo<path-to-kubeadm.exe>"https://dl.k8s.io/v1.37.0/bin/windows/amd64/kubeadm.exe"
Виконайте drain вузла
З машини з доступом до API Kubernetes підготуйте вузол до обслуговування, позначивши його як недоступний для планування та виселивши робочі навантаження:
# замініть <node-to-drain> імʼям вашого вузла, для якого ви виконуєте drainkubectl drain <node-to-drain> --ignore-daemonsets
Якщо ви запускаєте kube-proxy в контейнері HostProcess всередині Podʼа, а не як службу Windows, ви можете оновити kube-proxy, застосувавши нову версію ваших маніфестів kube-proxy.
Виконайте uncordon вузла
З машини з доступом до API Kubernetes поверніть вузол в роботу, позначивши його як придатний для планування:
Цей розділ містить інформацію, яку вам потрібно знати під час міграції з dockershim на інші середовища виконання контейнерів.
Після оголошення про застарілість dockershim в Kubernetes 1.20, виникли питання, як це вплине на різні робочі навантаження та розгортання самого Kubernetes. Наш Dockershim Removal FAQ допоможе вам краще зрозуміти проблему.
Dockershim був видалений з Kubernetes з випуском v1.24. Якщо ви використовуєте Docker Engine через dockershim як своє середовище виконання контейнерів і хочете оновитись до v1.24, рекомендується або мігрувати на інше середовище виконання, або знайти альтернативний спосіб отримання підтримки Docker Engine. Ознайомтеся з розділом середовище виконання контейнерів, щоб дізнатися про ваші варіанти.
Версія Kubernetes з dockershim (1.23) вийшла зі стану підтримки, а v1.24 скоро вийде зі стану підтримки. Переконайтеся, що повідомляєте про проблеми з міграцією, щоб проблеми могли бути вчасно виправлені, і ваш кластер був готовий до видалення dockershim. Після виходу v1.24 зі стану підтримки вам доведеться звертатися до вашого постачальника Kubernetes за підтримкою або оновлювати кілька версій одночасно, якщо є критичні проблеми, які впливають на ваш кластер.
Ваш кластер може мати більше одного типу вузлів, хоча така конфігурація не є поширеною.
Якщо ви знайшли дефект або іншу технічну проблему, повʼязану з відмовою від dockershim, ви можете повідомити про проблему проєкту Kubernetes.
2.3 - Керування ресурсами памʼяті, CPU та API
2.4 - Встановлення постачальника мережевої політики
2.5 - Розробка Cloud Controller Manager
СТАН ФУНКЦІОНАЛУ:Beta since Kubernetes v1.11
Cloud Controller Manager (cloud-controller-manager) є компонент панелі управління Kubernetes, що вбудовує логіку управління, специфічну для хмари. Cloud controller manager дозволяє звʼязувати ваш кластер з API хмарного провайдера та відокремлює компоненти, що взаємодіють із хмарною платформою, від компонентів, які взаємодіють тільки з вашим кластером.
Відокремлюючи логіку сумісності між Kubernetes і базовою хмарною інфраструктурою, компонент cloud-controller-manager дає змогу хмарним провайдерам випускати функції з іншою швидкістю порівняно з основним проєктом Kubernetes.
Контекст
Оскільки хмарні постачальники розробляють і випускають свої продукти в іншому темпі, ніж проєкт Kubernetes, винесення специфічного для постачальника коду в окремий бінарний файл cloud-controller-manager дає змогу хмарним постачальникам розвиватися незалежно від основного коду Kubernetes.
Проєкт Kubernetes надає кістяк коду cloud-controller-manager з інтерфейсами Go, щоб дозволити вам (або вашому постачальнику хмар) додати свої власні реалізації. Це означає, що постачальник хмар може реалізувати cloud-controller-manager, імпортуючи пакунки з ядра Kubernetes; кожен постачальник хмар буде реєструвати свій власний код, викликаючи cloudprovider.RegisterCloudProvider, щоб оновити глобальну змінну доступних постачальників хмар.
Розробка
Зовнішня реалізація
Для створення зовнішнього cloud-controller-manager для вашої хмари:
Використовуйте main.go у cloud-controller-manager з ядра Kubernetes як шаблон для свого main.go. Як зазначено вище, єдина відмінність полягатиме у пакунку хмари, який буде імпортуватися.
Багато постачальників хмар публікують код свого менеджера контролерів як відкритий код. Якщо ви створюєте новий cloud-controller-manager з нуля, за відправну точку можна взяти наявний зовнішній cloud-controller-manager.
2.6 - Посилення безпеки динамічного виділення ресурсів у вашому кластері
Ця сторінка показує адміністраторам кластера, як посилити авторизацію для динамічного виділення ресурсів (DRA) з акцентом на доступ з мінімальними привілеями для оновлень статусу ResourceClaim.
Перш ніж ви розпочнете
Вам треба мати кластер Kubernetes, а також інструмент командного рядка kubectl має бути налаштований для роботи з вашим кластером. Рекомендується виконувати ці настанови у кластері, що має щонайменше два вузли, які не виконують роль вузлів управління. Якщо у вас немає кластера, ви можете створити його, за допомогою minikube або використовувати одну з цих пісочниць:
Створіть обʼєкти ClusterRoleBinding для кожної ідентичності компонента та уникайте спільного використання широкої ролі між не повʼязаними між собою компонентами DRA.
Обмежте правила resourceclaims/driver за допомогою resourceNames, де це можливо, щоб ідентичність могла оновлювати статус лише для конкретного драйвера DRA, яким вона керує.
Перевірка та моніторинг
Перевірте, що кожна ідентичність має лише необхідні дієслова та субресурси.
Підтвердіть, що оновлення статусу DRA працюють після розгортання.
Спостерігайте за подіями аудиту API-сервера щодо відхилених запитів resourceclaims/binding та resourceclaims/driver.
Ця сторінка описує процес оновлення CoreDNS та як встановити CoreDNS.
Перш ніж ви розпочнете
Вам треба мати кластер Kubernetes, а також інструмент командного рядка kubectl має бути налаштований для роботи з вашим кластером. Рекомендується виконувати ці настанови у кластері, що має щонайменше два вузли, які не виконують роль вузлів управління. Якщо у вас немає кластера, ви можете створити його, за допомогою minikube або використовувати одну з цих пісочниць:
Версія вашого Kubernetes сервера має бути не старішою ніж v1.9.
Для перевірки версії введіть kubectl version.
Про CoreDNS
CoreDNS — це гнучкий, розширюваний DNS-сервер, який є стандартною реалізацією DNS кластера Kubernetes. Як і Kubernetes, проєкт CoreDNS розміщено в CNCF.
Встановлення CoreDNS
Для ручного розгортання дивіться документацію на вебсайті CoreDNS.
Оновлення CoreDNS
Ви можете перевірити версію CoreDNS, яку kubeadm встановлює для кожної версії Kubernetes на сторінці Версія CoreDNS у Kubernetes.
CoreDNS можна оновити вручну, якщо ви хочете оновити лише CoreDNS або використати власний образ. Для плавного оновлення доступні корисні рекомендації та покрокова інструкція. Переконайтеся, що під час оновлення кластера наявна конфігурація CoreDNS ("Corefile") зберігається.
Якщо ви оновлюєте свій кластер за допомогою інструменту kubeadm, kubeadm може самостійно зберегти поточну конфігурацію CoreDNS.
Налаштування CoreDNS
Коли використання ресурсів має значення, може бути корисно налаштувати конфігурацію CoreDNS. Докладніше дивіться документацію з масштабування CoreDNS.
Що далі
Ви можете налаштувати CoreDNS для підтримки багатьох сценаріїв, окрім базового розвʼязання імен Service, змінивши конфігурацію CoreDNS ("Corefile"). Докладніше дивіться документацію втулка CoreDNS kubernetes або прочитайте Custom DNS Entries for Kubernetes у блозі CoreDNS.
3 - Налаштування Podʼів та контейнерів
Виконайте поширені завдання налаштування Podʼів і контейнерів.
3.1 - Призначення пристроїв Podʼам та контейнерам
Призначення інфраструктурних ресурсів для ваших робочих навантажень Kubernetes.
3.1.1 - Налаштування DRA у кластері
СТАН ФУНКЦІОНАЛУ:GA since Kubernetes v1.35
More information about this feature
This is a stable feature in Kubernetes, and has been since version v1.35. It was first available in the v1.30 release. You can no longer disable or opt out of this feature or behavior (it is locked); if you explicitly set a value for the associated feature gate DynamicResourceAllocation, Kubernetes ignores it but does not report any error.
На цій сторінці показано, як налаштувати динамічне виділення ресурсів (DRA) у кластері Kubernetes шляхом активації груп API та налаштування класів пристроїв. Ці інструкції призначені для адміністраторів кластерів.
Про DRA
Можливість Kubernetes, яка дозволяє запитувати ресурси та спільно використовувати їх між Podʼами. Часто такими ресурсами є приєднані пристрої, як-от апаратні прискорювачі.
З DRA драйвери пристроїв і адміністратори кластера визначають класи пристроїв, які робочі навантаження можуть запитувати (claim). Kubernetes виділяє відповідні пристрої конкретним запитам (claims) і розміщує відповідні Podʼи на вузлах, які мають доступ до виділених пристроїв.
Вам треба мати кластер Kubernetes, а також інструмент командного рядка kubectl має бути налаштований для роботи з вашим кластером. Рекомендується виконувати ці настанови у кластері, що має щонайменше два вузли, які не виконують роль вузлів управління. Якщо у вас немає кластера, ви можете створити його, за допомогою minikube або використовувати одну з цих пісочниць:
Версія вашого Kubernetes сервера має бути не старішою ніж v1.34.
Для перевірки версії введіть kubectl version.
Підключіть пристрої до вашого кластера безпосередньо або опосередковано. Щоб уникнути можливих проблем із драйверами, дочекайтеся налаштування функції DRA для вашого кластера перед встановленням драйверів.
Опціонально: увімкніть додаткові групи API DRA
Загалом DRA є стабільною функцією в Kubernetes, проте деякі її аспекти можуть бути ще в стадії альфа- або бета-тестування. Якщо ви хочете використовувати будь-який аспект DRA, який ще не є стабільним, а повʼязана з ним функція залежить від спеціального типу API, тоді ви повинні увімкнути відповідні групи альфа- або бета-API.
Деякі старі драйвери або робочі навантаження DRA можуть все ще потребувати API v1beta1 з Kubernetes 1.30 або v1beta2 з Kubernetes 1.32. Тільки якщо потрібна підтримка цих версій, увімкніть наступні групи API:
Щоб перевірити правильність налаштування кластера, спробуйте вивести список DeviceClasses:
kubectl get deviceclasses
Якщо конфігурація компонентів була правильною, ви побачите подібний результат:
No resources found
Якщо DRA налаштовано неправильно, результат виконання попередньої команди буде схожий на:
error: the server doesn't have a resource type "deviceclasses"
Наприклад, це може статися, коли група API resource.k8s.io була вимкнена. Аналогічна перевірка застосовується до типів верхнього рівня якості альфа або бета.
Спробуйте наступні кроки для усунення несправностей:
Переконфігуруйте та перезапустіть компонент kube-apiserver.
Якщо повне поле .spec.resourceClaims видаляється з Podʼів, або якщо Podʼи плануються без урахування ResourceClaims, перевірте, чи не вимкнено функціональну можливість DynamicResourceAllocation для kube-apiserver, kube-controller-manager, kube-scheduler або kubelet.
Встановіть драйвери пристроїв
Після активації DRA для вашого кластера ви можете встановити драйвери для підключених пристроїв. Інструкції шукайте у документації власника пристрою або проєкту, що підтримує драйвери пристроїв. Встановлені драйвери мають бути сумісні з DRA.
Щоб перевірити роботу встановлених драйверів, виведіть список ResourceSlices у кластері:
kubectl get resourceslices
Вивід буде схожий на:
NAME NODE DRIVER POOL AGE
00000-driver.example.com-cluster-1-node-1-abcde cluster-1-node-1 driver.example.com cluster-1-device-pool-1-r1gc 7s
00000-driver.example.com-cluster-1-node-2-fghij cluster-1-node-2 driver.example.com cluster-1-device-pool-2-446z 8s
Спробуйте наступні кроки для усунення несправностей:
Перевірте стан драйвера DRA та шукайте повідомлення про помилки щодо публікації ResourceSlices у виводі його логів. Постачальник драйвера може надати додаткові інструкції щодо встановлення та усунення несправностей.
Створіть DeviceClasses
Ви можете визначити категорії пристроїв, які оператори ваших застосунків можуть запитувати у робочих навантаженнях, створюючи DeviceClasses. Деякі постачальники драйверів пристроїв також можуть вказати вам створити DeviceClasses під час встановлення драйверів.
ResourceSlices, які публікує ваш драйвер, містять інформацію про пристрої, якими керує драйвер, такі як ємність, метадані та атрибути. Ви можете використовувати Common Expression Language для фільтрації властивостей у DeviceClasses, що спрощує пошук пристроїв для операторів навантажень.
Щоб знайти властивості пристрою, які можна вибирати у DeviceClasses за допомогою виразів CEL, отримайте специфікацію ResourceSlice:
kubectl get resourceslice <resourceslice-name> -o yaml
Вивід буде схожий на:
apiVersion:resource.k8s.io/v1kind:ResourceSlice# рядки пропущено для ясностіspec:devices:- attributes:type:string:gpucapacity:memory:value:64Giname:gpu-0- attributes:type:string:gpucapacity:memory:value:64Giname:gpu-1driver:driver.example.comnodeName:cluster-1-node-1# рядки пропущено для ясності
Ви також можете переглянути документацію постачальника драйверів для доступних властивостей і значень.
Ознайомтеся з прикладом маніфесту DeviceClass, який вибирає будь-який пристрій, керований драйвером пристроїв driver.example.com:
3.1.2 - Виділення пристроїв робочим навантаженням за допомогою DRA
СТАН ФУНКЦІОНАЛУ:GA since Kubernetes v1.35
More information about this feature
This is a stable feature in Kubernetes, and has been since version v1.35. It was first available in the v1.30 release. You can no longer disable or opt out of this feature or behavior (it is locked); if you explicitly set a value for the associated feature gate DynamicResourceAllocation, Kubernetes ignores it but does not report any error.
На цій сторінці показано, як виділяти пристрої вашим Podʼам за допомогою динамічного виділення ресурсів (DRA). Ці інструкції призначені для операторів робочих навантажень. Перед прочитанням цієї сторінки ознайомтеся з принципами роботи DRA та термінами DRA, такими як ResourceClaims і ResourceClaimTemplates. Докладніше дивіться у розділі Динамічне виділення ресурсів (DRA).
Про виділення пристроїв за допомогою DRA
Як оператор робочих навантажень, ви можете запитувати пристрої для своїх навантажень, створюючи ResourceClaims або ResourceClaimTemplates. Під час розгортання навантаження Kubernetes і драйвери пристроїв знаходять доступні пристрої, виділяють їх вашим Podʼам і розміщують Podʼи на вузлах, які мають доступ до цих пристроїв.
Перш ніж ви розпочнете
Вам треба мати кластер Kubernetes, а також інструмент командного рядка kubectl має бути налаштований для роботи з вашим кластером. Рекомендується виконувати ці настанови у кластері, що має щонайменше два вузли, які не виконують роль вузлів управління. Якщо у вас немає кластера, ви можете створити його, за допомогою minikube або використовувати одну з цих пісочниць:
Версія вашого Kubernetes сервера має бути не старішою ніж v1.34.
Для перевірки версії введіть kubectl version.
Переконайтеся, що адміністратор вашого кластера налаштував DRA, підключив пристрої та встановив драйвери. Докладніше дивіться у розділі Налаштування DRA у кластері.
Визначення пристроїв для подання заявок на них
Адміністратор вашого кластера або драйвери пристроїв створюють DeviceClasses, які визначають категорії пристроїв. Ви можете запитувати пристрої, використовуючи Common Expression Language для фільтрації за конкретними властивостями пристроїв.
Отримайте список DeviceClasses у кластері:
kubectl get deviceclasses
Вивід буде схожим на наступний:
NAME AGE
driver.example.com 16m
Якщо ви отримали помилку доступу, можливо, у вас немає прав для перегляду DeviceClasses. Зверніться до адміністратора кластера або постачальника драйверів щодо доступних властивостей пристроїв.
Запитування ресурсів
Ви можете запитувати ресурси з DeviceClass за допомогою ResourceClaims. Щоб створити ResourceClaim, виконайте одну з наступних дій:
Створіть ResourceClaim вручну, якщо ви хочете, щоб декілька Podʼів мали спільний доступ до одних і тих самих пристроїв, або якщо ви хочете, щоб заявка існувала довше, ніж Pod.
Використовуйте ResourceClaimTemplate, щоб Kubernetes генерував і керував ResourceClaims для кожного Podʼа. Створіть ResourceClaimTemplate, якщо ви хочете, щоб кожен Pod мав доступ до окремих пристроїв із подібними конфігураціями. Наприклад, вам може знадобитися одночасний доступ до пристроїв для Podʼів у Job, який використовує паралельне виконання.
Якщо ви безпосередньо посилаєтеся на конкретний ResourceClaim у Podʼі, цей ResourceClaim вже має існувати у кластері. Якщо зазначений ResourceClaim не існує, Pod залишатиметься у стані очікування, доки ResourceClaim не буде створено. Ви можете посилатися на автоматично згенерований ResourceClaim у Podʼі, але це не рекомендується, оскільки автоматично згенеровані ResourceClaims привʼязані до часу життя Podʼа, який спричинив їх створення.
Щоб створити робоче навантаження, яке запитує ресурси, виберіть одну з наступних опцій:
Запит пристроїв у робочих навантаженнях за допомогою DRA
Щоб запросити виділення пристроїв, вкажіть ResourceClaim або ResourceClaimTemplate у полі resourceClaims специфікації Podʼа. Потім запросіть конкретну заявку за назвою у полі resources.claims контейнера цього Podʼа. Ви можете вказати декілька записів у полі resourceClaims та використовувати конкретні заявки у різних контейнерах.
Коли робоче навантаження не запускається, як очікувалося, пройдіть ланцюжком від Job до Podʼів і до ResourceClaims та перевірте обʼєкти на кожному рівні за допомогою kubectl describe, щоб дізнатися, чи є якісь поля статусу або події, які можуть пояснити, чому робоче навантаження не запускається.
Коли створення Podʼа не вдається з must specify one of: resourceClaimName, resourceClaimTemplateName, перевірте, що всі записи в pod.spec.resourceClaims мають точно одне з цих полів. Якщо так, то можливо, що в кластері встановлено модифікуючий вебхук Podʼа, який був створений для API Kubernetes < 1.32. Попросіть адміністратора кластера перевірити це.
Очищення
Щоб видалити обʼєкти Kubernetes, створені у цьому завданні, виконайте наступні кроки:
Ця сторінка показує, як отримати доступ до метаданих пристроїв з контейнерів, які використовують динамічне виділення ресурсів (DRA). Метадані пристроїв дозволяють робочим навантаженням дізнаватися інформацію про виділені пристрої, таку як атрибути пристроїв або деталі мережевого інтерфейсу, шляхом читання JSON-файлів за відомими шляхами всередині контейнера.
Вам треба мати кластер Kubernetes, а також інструмент командного рядка kubectl має бути налаштований для роботи з вашим кластером. Рекомендується виконувати ці настанови у кластері, що має щонайменше два вузли, які не виконують роль вузлів управління. Якщо у вас немає кластера, ви можете створити його, за допомогою minikube або використовувати одну з цих пісочниць:
Переконайтесь, що адміністратор вашого кластера налаштував DRA, підключив пристрої та встановив драйвери. Для отримання додаткової інформації дивіться Налаштування DRA в кластері.
Переконайтесь, що драйвер DRA, розгорнутий у вашому кластері, підтримує метадані пристроїв. Автори драйверів, які використовують втулок kubelet DRA, вмикають підтримку за допомогою EnableDeviceMetadata та повинні включити metadata.resource.k8s.io/v1beta1 у вибрані версії. Драйвер також може видавати v1alpha1 для сумісності зі старішими споживачами.
Доступ до метаданих пристроїв за допомогою ResourceClaim
Коли ви використовуєте безпосередньо вказаний ResourceClaim для виділення пристроїв, файли метаданих пристроїв зʼявляються всередині контейнера за шляхом:
Файл метаданих — це JSON-потік. Він містить один обʼєкт для кожної версії API, вибраної драйвером, у порядку, налаштованому драйвером. Драйвери повинні розміщувати найновішу версію першою. Обʼєкти містять еквівалентні метадані пристрою, тому команда може вивести більше ніж один JSON-обʼєкт.
Вивід містить атрибути пристрою, такі як модель, версія драйвера та UUID пристрою. Ємності пристроїв не є частиною схеми метаданих. Дивіться схему метаданих для деталей структури JSON.
Доступ до метаданих пристроїв за допомогою ResourceClaimTemplate
Коли ви використовуєте ResourceClaimTemplate, Kubernetes генерує ResourceClaim для кожного Podʼа. Оскільки згенерована назва заявки непередбачувана, файли метаданих натомість зʼявляються за шляхом, який використовує імʼя посилання на заявку в Podʼі:
Цей маніфест створює ResourceClaimTemplate та Pod. Кожен Pod отримує власний згенерований ResourceClaim. Шлях до метаданих використовує імʼя посилання на заявку в Podʼі — my-gpu.
Пакунок k8s.io/dynamic-resource-allocation/devicemetadata надає готові функції для читання файлів метаданих. Ці функції автоматично обробляють узгодження версій, декодують потік метаданих і перетворюють його на внутрішні типи, щоб ваш код працював з різними версіями схеми без ручної перевірки версій. Вони пропускають обʼєкти з невідомими версіями API та повертають перший сумісний обʼєкт.
Функції, які читають усі драйвери, повертають *metadata.DeviceMetadata з обʼєднаними запитами та атрибутами кожного пристрою. Функції, які приймають імʼя драйвера, повертають повний обʼєкт метаданих із файлу цього драйвера.
Допоміжні функції читання декодують метадані без перевірки. Щоб увімкнути перевірку, відкрийте файл і використайте DecodeMetadataFromStream:
Декодування та перевірка мають окремі результати. Помилка перевірки не заважає декодеру заповнювати deviceMetadata. Перевірка корисна, коли метадані надходять від власного драйвера, оскільки втулок kubelet DRA не перевіряє обʼєкти перед їх записом.
Застосунки іншими мовами можуть декодувати JSON-потік по одному обʼєкту за раз, перевіряти кожен apiVersion, пропускати невідомі версії та використовувати першу версію, яку вони підтримують.
Для отримання додаткової інформації про дизайн див. KEP-5304.
3.2 - Встановлення прав доступу на том emptyDir
СТАН ФУНКЦІОНАЛУ:Alpha since Kubernetes v1.37; (стандартно вимкнено)
More information about this feature
To use this feature, you (or a cluster administrator) will need to enable the EmptyDirVolumeMode feature gate for all relevant components in your cluster.
Ця сторінка показує, як встановити біти прав доступу Unix на теці тому emptyDir за допомогою поля mode.
Перш ніж ви розпочнете
Вам треба мати кластер Kubernetes, а також інструмент командного рядка kubectl має бути налаштований для роботи з вашим кластером. Рекомендується виконувати ці настанови у кластері, що має щонайменше два вузли, які не виконують роль вузлів управління. Якщо у вас немає кластера, ви можете створити його, за допомогою minikube або використовувати одну з цих пісочниць:
Вам потрібно, щоб функціональна можливість EmptyDirVolumeMode була увімкнена на API-сервері та на kubelet.
Створення Podʼа, який використовує том emptyDir з власними правами доступу
Поле emptyDir.mode дозволяє встановити біти прав доступу Unix (від 0000 до 01777 у вісімковій системі) на теці тому. Якщо не вказано, тека створюється зі стандартними правами 0777.
Наприклад, щоб створити спільну теку /tmp зі встановленим sticky bit, щоб лише власники файлів могли видаляти свої файли:
3.3 - Забезпечення стандартів безпеки Podʼів шляхом конфігурування вбудованого контролера допуску
Kubernetes надає вбудований контролер допуску для забезпечення дотримання стандартів безпеки Podʼів. Цей контролер допуску можна налаштувати, щоб задати стандартні значення для всього кластера та винятки.
Перш ніж ви розпочнете
Після альфа-випуску в Kubernetes v1.22 Pod Security Admission стала стандартно доступною в Kubernetes v1.23 як бета-можливість. Починаючи з версії 1.25, Pod Security Admission загальнодоступна (GA).
Для перевірки версії введіть kubectl version.
Якщо ви використовуєте не Kubernetes 1.37, можна перейти до перегляду цієї сторінки в документації для версії Kubernetes, яку ви використовуєте.
Налаштування контролера допуску
Примітка:
Конфігурація pod-security.admission.config.k8s.io/v1 потребує v1.25+. Для v1.23 і v1.24 використовуйте v1beta1. Для v1.22 використовуйте v1alpha1.
apiVersion:apiserver.config.k8s.io/v1kind:AdmissionConfigurationplugins:- name:PodSecurityconfiguration:apiVersion:pod-security.admission.config.k8s.io/v1# див. примітку про сумісністьkind:PodSecurityConfiguration# Стандартні значення, які застосовуються, коли мітка режиму не встановлена.## Значення мітки рівня повинні бути одним з:# - "privileged" (стандартно)# - "baseline"# - "restricted"## Значення мітки версії повинні бути одним з:# - "latest" (стандартно)# - конкретна версія, наприклад "v1.37"defaults:enforce:"privileged"enforce-version:"latest"audit:"privileged"audit-version:"latest"warn:"privileged"warn-version:"latest"exemptions:# Масив імен автентифікованих користувачів, на які поширюється виняток.usernames:[]# Масив імен RuntimeClass, на які поширюється виняток.runtimeClasses:[]# Масив просторів імен, на які поширюється виняток.namespaces:[]
Примітка:
Наведений вище маніфест потрібно передати kube-apiserver через --admission-control-config-file.
4 - Моніторинг, логування та налагодження
Налаштуйте моніторинг та логування для розвʼязання проблем кластера або налагодження контейнеризованих застосунків.
Іноді трапляються неприємності. Цей посібник допоможе вам зібрати необхідну інформацію та вирішити проблеми. Він складається з чотирьох розділів:
Налагодження вашого застосунку — корисно для користувачів, які розгортають код у Kubernetes та цікавляться причиною його непрацездатності.
Налагодження вашого кластера — корисно для адміністраторів та операторів кластерів, які усувають несправності у самому кластері Kubernetes.
Логи в Kubernetes — корисно для адміністраторів кластерів, які хочуть налаштувати та керувати логами у Kubernetes.
Моніторинг в Kubernetes — корисно для адміністраторів кластерів, які хочуть увімкнути моніторинг у кластері Kubernetes.
Вам також слід перевірити відомі проблеми для випуску, який ви використовуєте.
Отримання допомоги
Якщо жоден із наведених вище посібників не відповідає на ваше питання, є різні способи отримати допомогу від спільноти Kubernetes.
Питання
Документацію на цьому сайті структуровано так, щоб відповідати на широке коло питань. Концепції пояснюють архітектуру Kubernetes і роботу кожного компонента, а Налаштування містить практичні інструкції для початку роботи. Завдання показують, як виконувати поширені завдання, а Навчальні матеріали — це докладніші покрокові розбори реальних, галузевих або наскрізних сценаріїв розробки. Розділ Довідник містить докладну документацію з API Kubernetes та інтерфейсів командного рядка (CLI), таких як kubectl.
Допоможіть! Моє питання не розглянуто! Мені потрібна допомога зараз!
Stack Exchange, Stack Overflow або Server Fault
Якщо у вас є питання, повʼязане з розробкою програмного забезпечення для вашого контейнеризованого застосунку, ви можете задати його на Stack Overflow.
Якщо у вас є питання про Kubernetes, повʼязані з керуванням кластером або конфігурацією, ви можете поставити їх на Server Fault.
Також існують кілька більш конкретних сайтів мережі Stack Exchange, які можуть бути відповідним місцем для питань про Kubernetes в таких областях, як DevOps, Software Engineering або InfoSec.
Можливо, хтось зі спільноти вже ставив схоже питання або може допомогти з вашою проблемою.
Команда Kubernetes також слідкуватиме за постами з теґом Kubernetes. Якщо немає наявних питань, які можуть допомогти, будь ласка, переконайтеся, що ваше питання відповідає правилам Stack Overflow, Server Fault або сайту мережі Stack Exchange, на якому ви його ставите, і ознайомтеся з інструкцією як поставити нове питання, перед тим як задавати нове!
Slack
Багато людей зі спільноти Kubernetes спілкуються у Kubernetes Slack в каналі #kubernetes-users. Slack потребує реєстрації; ви можете надіслати запит на запрошення, реєстрація відкрита для всіх. Запрошуємо приходити й ставити будь-які питання. Після реєстрації відкрийте організацію Kubernetes у Slack у браузері або у власному застосунку Slack.
Після реєстрації переглядайте список каналів для різних тем. Наприклад, люди, які тільки вчаться Kubernetes, також можуть приєднатися до каналу #kubernetes-novice. Як ще один приклад, розробникам корисно приєднатися до каналу #kubernetes-contributors.
Також існують багато каналів, специфічних для країн / мов. Запрошуємо приєднатися до цих каналів для локалізованої підтримки та інформації:
Перш ніж створювати issue, пошукайте серед наявних issue, чи вашу проблему вже описано.
Якщо ви повідомляєте про помилку, додайте докладну інформацію про те, як відтворити проблему, наприклад:
Версія Kubernetes: kubectl version
Хмарний провайдер, дистрибутив ОС, конфігурація мережі та версія середовища виконання контейнерів
Кроки для відтворення проблеми
4.1 - Логи в Kubernetes
Архітектура логування та системні логи.
На цій сторінці наведено ресурси про логування в Kubernetes. Ви можете дізнатися, як збирати, переглядати й аналізувати логи за допомогою вбудованих інструментів і популярних стеків логування:
На цій сторінці наведено ресурси про моніторинг у Kubernetes. Ви можете дізнатися, як збирати системні метрики й трасування для системних компонентів Kubernetes:
Налагодження поширених проблем контейнеризованих застосунків.
Цей розділ містить набір ресурсів для виправлення проблем із контейнеризованими застосунками. Він охоплює поширені проблеми з ресурсами Kubernetes (як-от Pods, Services або StatefulSets), поради щодо розуміння повідомлень про завершення контейнерів і способи налагодження запущених контейнерів.
4.3.1 - Налагодження Podʼів
Цей посібник допоможе користувачам налагодити застосунки, які розгорнуті в Kubernetes і поводяться некоректно. Це не посібник для тих, хто хоче налагодити свій кластер. Для цього ознайомтеся з цим посібником.
Діагностика проблеми
Перший крок в усуненні несправностей — первинна оцінка. У чому проблема? У ваших Podʼах, ReplicationController чи Service?
Перший крок у налагодженні Podʼа — переглянути його. Перевірте поточний стан Podʼа й останні події такою командою:
kubectl describe pods ${POD_NAME}
Перегляньте стан контейнерів у Podʼі. Чи всі вони в стані Running? Чи були нещодавні перезапуски?
Продовжуйте налагодження залежно від стану Podʼів.
Мій Pod залишається в стані Pending
Якщо Pod застряг у стані Pending, це означає, що його не можна призначити на вузол. Зазвичай це стається через нестачу ресурсів того чи іншого типу, яка заважає плануванню. Перегляньте вивід команди kubectl describe ... вище. Там мають бути повідомлення від планувальника про те, чому він не може запланувати ваш Pod. Можливі причини:
У вас недостатньо ресурсів: можливо, ви вичерпали запас CPU або памʼяті в кластері; у такому разі потрібно видалити Podʼи, скоригувати запити ресурсів або додати нові вузли до кластера. Докладніше дивіться документ про обчислювальні ресурси.
Ви використовуєте hostPort: коли ви привʼязуєте Pod до hostPort, кількість місць, де можна запланувати цей Pod, обмежена. У більшості випадків hostPort не потрібен, спробуйте використати обʼєкт Service, щоб відкрити доступ до вашого Podʼа. Якщо hostPort вам усе ж потрібен, ви зможете запланувати лише стільки Podʼів, скільки вузлів у вашому кластері Kubernetes.
Мій Pod залишається у стані Waiting
Якщо Pod застряг у стані Waiting, його вже призначено на робочий вузол, але він не може працювати на цій машині. Знову ж таки, корисну інформацію має дати вивід kubectl describe .... Найпоширеніша причина Podʼів у стані Waiting — помилка завантаження образу. Перевірте три речі:
Переконайтеся, що ви правильно вказали імʼя образу.
Чи надіслали ви образ до реєстру?
Спробуйте вручну завантажити образ, щоб перевірити, чи його можна завантажити. Наприклад, якщо ви використовуєте Docker на своєму ПК, виконайте docker pull <image>.
Мій Pod залишається у стані Terminating
Якщо Pod застряг у стані Terminating, це означає, що для Podʼа надіслано запит на видалення, але панель управління не може видалити обʼєкт Pod.
Зазвичай таке стається, якщо Pod має завершувач, а в кластері встановлено вебхук допуску, який не дає панелі управління вилучити завершувач.
Щоб виявити такий сценарій, перевірте, чи є у вашому кластері ValidatingWebhookConfiguration або MutatingWebhookConfiguration, спрямовані на операції UPDATE для ресурсів pods.
Якщо вебхук надає третя сторона:
Переконайтеся, що ви використовуєте найновішу версію.
Вимкніть вебхук для операцій UPDATE.
Повідомте про проблему відповідному постачальнику.
Якщо ви автор вебхука:
Для змінювального вебхука переконайтеся, що він ніколи не змінює незмінні поля під час операцій UPDATE. Наприклад, зміни контейнерів зазвичай не дозволені.
Для валідаційного вебхука переконайтеся, що ваші політики валідації застосовуються лише до нових змін. Іншими словами, слід пропускати Podʼи з наявними порушеннями. Це дозволяє Podʼам, створеним до встановлення валідаційного вебхука, і далі працювати.
Мій Pod виходить з ладу або несправний іншим чином
Мій Pod працює, але не робить того, що я йому вказав
Якщо ваш Pod поводиться не так, як ви очікували, можливо, в описі Podʼа (наприклад, у файлі mypod.yaml на вашому локальному компʼютері) була помилка, яку мовчки проігнорували під час створення Podʼа. Часто якийсь розділ опису Podʼа вкладено неправильно або імʼя ключа написано з помилкою, тож ключ ігнорується. Наприклад, якщо ви написали command як commnd, Pod буде створено, але він не використовуватиме командний рядок, який ви задумали.
Насамперед видаліть свій Pod і спробуйте створити його знову з параметром --validate. Наприклад, виконайте kubectl apply --validate -f mypod.yaml. Якщо ви написали command як commnd, ви отримаєте помилку на кшталт такої:
I0805 10:43:25.129850 46757 schema.go:126] unknown field: commnd
I0805 10:43:25.129973 46757 schema.go:129] this may be a false alarm, see https://github.com/kubernetes/kubernetes/issues/6842
pods/mypod
Далі перевірте, чи збігається Pod на API-сервері з Podʼом, який ви хотіли створити (наприклад, з YAML-файлом на вашому локальному компʼютері). Наприклад, виконайте kubectl get pods/mypod -o yaml > mypod-on-apiserver.yaml, а потім вручну порівняйте початковий опис Podʼа, mypod.yaml, з тим, що ви отримали від API-сервера, mypod-on-apiserver.yaml. Зазвичай у версії з API-сервера будуть рядки, яких немає в початковій версії. Це очікувано. Однак якщо в початковому описі є рядки, яких немає у версії з API-сервера, це може свідчити про проблему зі специфікацією вашого Podʼа.
Налагодження ReplicationController
ReplicationController досить прості. Вони або можуть створювати Podʼи, або не можуть. Якщо вони не можуть створювати Podʼи, скористайтеся інструкціями вище, щоб налагодити свої Podʼи.
Також можна використати kubectl describe rc ${CONTROLLER_NAME}, щоб переглянути події, повʼязані з ReplicationController.
Налагодження Service
Service забезпечують балансування навантаження між набором Podʼів. Є кілька поширених проблем, через які Service можуть працювати неправильно. Наведені нижче інструкції допоможуть налагодити проблеми з Service.
Спершу переконайтеся, що для Service є точки доступу. Для кожного обʼєкта Service API-сервер робить доступними один або кілька ресурсів EndpointSlice.
Переглянути ці ресурси можна так:
kubectl get endpointslices -l kubernetes.io/service-name=${SERVICE_NAME}
Переконайтеся, що точки доступу в EndpointSlice відповідають кількості Podʼів, які мають входити до вашого Service. Наприклад, якщо ваш Service призначено для контейнера nginx з 3 репліками, ви маєте побачити три різні IP-адреси в EndpointSlice цього Service.
У моєму Service бракує точок доступу
Якщо точок доступу бракує, спробуйте вивести перелік Podʼів за мітками із селектора Service. Наприклад, у вас є Service з таким селектором:
...spec:selector:name:nginxtype:frontend
Можна використати:
kubectl get pods --selector=name=nginx,type=frontend
щоб вивести перелік Podʼів, які відповідають цьому селектору. Перевірте, чи список збігається з Podʼами, які мають обслуговувати ваш Service. Перевірте, чи containerPort Podʼа збігається з targetPort Service.
Якщо жоден із наведених вище кроків не розвʼязав вашої проблеми, виконайте інструкції з документа про налагодження Service, щоб переконатися, що ваш Service працює, має Endpoints, а ваші Podʼи справді обслуговують запити; що DNS працює, правила iptables встановлено, а kube-proxy поводиться правильно.
Це завдання показує, як налагоджувати StatefulSet.
Перш ніж ви розпочнете
Вам потрібен кластер Kubernetes, та інструмент командного рядка kubectl повинен бути налаштований на звʼязок з вашим кластером.
У вас має бути запущений StatefulSet, який ви хочете дослідити.
Налагодження StatefulSet
Щоб вивести список усіх Podʼів, які належать до StatefulSet і мають мітку app.kubernetes.io/name=MyApp, можна використати таку команду:
kubectl get pods -l app.kubernetes.io/name=MyApp
Якщо ви бачите, що якісь із перелічених Podʼів тривалий час перебувають у стані Unknown або Terminating, зверніться до завдання Видалення Podʼів StatefulSet за інструкціями, що з ними робити. Налагоджувати окремі Podʼи у StatefulSet можна за допомогою посібника Налагодження Podʼів.
Ця сторінка пояснює, як налагоджувати Podʼи, що працюють (або аварійно завершуються) на вузлі.
Перш ніж ви розпочнете
Ваш Pod уже має бути запланований і запущений. Якщо ваш Pod ще не запущений, почніть з Налагодження Podʼів.
Для деяких з розширених кроків налагодження вам потрібно знати, на якому вузлі запущений Pod, і мати доступ до оболонки для виконання команд на цьому вузлі. Вам не потрібен такий доступ для виконання стандартних кроків налагодження, що використовують kubectl.
Використання kubectl describe pod для отримання деталей про Podʼи
У цьому прикладі ми використаємо Deployment для створення двох Podʼів, подібно до попереднього прикладу.
NAME READY STATUS RESTARTS AGE
nginx-deployment-67d4bdd6f5-cx2nz 1/1 Running 0 13s
nginx-deployment-67d4bdd6f5-w6kd7 1/1 Running 0 13s
Набагато більше інформації про кожен із цих Podʼів можна отримати за допомогою kubectl describe pod. Наприклад:
kubectl describe pod nginx-deployment-67d4bdd6f5-w6kd7
Name: nginx-deployment-67d4bdd6f5-w6kd7
Namespace: default
Priority: 0
Node: kube-worker-1/192.168.0.113
Start Time: Thu, 17 Feb 2022 16:51:01 -0500
Labels: app=nginx
pod-template-hash=67d4bdd6f5
Annotations: <none>
Status: Running
IP: 10.88.0.3
IPs:
IP: 10.88.0.3
IP: 2001:db8::1
Controlled By: ReplicaSet/nginx-deployment-67d4bdd6f5
Containers:
nginx:
Container ID: containerd://5403af59a2b46ee5a23fb0ae4b1e077f7ca5c5fb7af16e1ab21c00e0e616462a
Image: nginx
Image ID: docker.io/library/nginx@sha256:2834dc507516af02784808c5f48b7cbe38b8ed5d0f4837f16e78d00deb7e7767
Port: 80/TCP
Host Port: 0/TCP
State: Running
Started: Thu, 17 Feb 2022 16:51:05 -0500
Ready: True
Restart Count: 0
Limits:
cpu: 500m
memory: 128Mi
Requests:
cpu: 500m
memory: 128Mi
Environment: <none>
Mounts:
/var/run/secrets/kubernetes.io/serviceaccount from kube-api-access-bgsgp (ro)
Conditions:
Type Status
Initialized True
Ready True
ContainersReady True
PodScheduled True
Volumes:
kube-api-access-bgsgp:
Type: Projected (a volume that contains injected data from multiple sources)
TokenExpirationSeconds: 3607
ConfigMapName: kube-root-ca.crt
ConfigMapOptional: <nil>
DownwardAPI: true
QoS Class: Guaranteed
Node-Selectors: <none>
Tolerations: node.kubernetes.io/not-ready:NoExecute op=Exists for 300s
node.kubernetes.io/unreachable:NoExecute op=Exists for 300s
Events:
Type Reason Age From Message
---- ------ ---- ---- -------
Normal Scheduled 34s default-scheduler Successfully assigned default/nginx-deployment-67d4bdd6f5-w6kd7 to kube-worker-1
Normal Pulling 31s kubelet Pulling image "nginx"
Normal Pulled 30s kubelet Successfully pulled image "nginx" in 1.146417389s
Normal Created 30s kubelet Created container nginx
Normal Started 30s kubelet Started container nginx
Тут ви можете побачити інформацію про конфігурацію контейнерів і Podʼа (мітки, вимоги до ресурсів тощо), а також інформацію про статус контейнерів і Podʼа (стан, готовність, кількість перезапусків, події тощо).
Стан контейнера — Waiting, Running або Terminated. Залежно від стану надається додаткова інформація: тут видно, що для контейнера в стані Running система повідомляє, коли контейнер запустився.
Ready показує, чи пройшов контейнер останню пробу готовності. (У цьому випадку контейнер не має налаштованої проби готовності; вважається, що контейнер готовий, якщо проба готовності не налаштована.)
Restart Count показує, скільки разів контейнер перезапускався; ця інформація може бути корисною для виявлення циклів аварійного перезапуску в контейнерах з політикою перезапуску Always.
Наразі єдиний стан (Condition), повʼязаний з Podʼом, — двійковий стан Ready, який показує, що Pod може обслуговувати запити й має бути доданий до пулів балансування навантаження всіх відповідних Service.
Нарешті, ви бачите журнал останніх подій, повʼязаних з вашим Podʼом. "From" вказує на компонент, який записує подію в лог. "Reason" і "Message" пояснюють, що сталося.
Приклад: налагодження Podʼів у стані Pending
Поширений сценарій, який можна виявити за допомогою подій, — коли ви створили Pod, що не вміщується на жодному вузлі. Наприклад, Pod може запитувати більше ресурсів, ніж вільно на будь-якому вузлі, або вказувати селектор міток, якому не відповідає жоден вузол. Скажімо, ми створили попередній Deployment з 5 репліками (замість 2), які запитують 600 мілі-ядер замість 500, у кластері з чотирьох вузлів, де кожна (віртуальна) машина має 1 CPU. У такому разі один з Podʼів не вдасться запланувати. (Зверніть увагу, що через Podʼи надбудов кластера, такі як fluentd, skydns тощо, які працюють на кожному вузлі, якби ми запросили 1000 мілі-ядер, жоден з Podʼів не вдалося б запланувати.)
kubectl get pods
NAME READY STATUS RESTARTS AGE
nginx-deployment-1006230814-6winp 1/1 Running 0 7m
nginx-deployment-1006230814-fmgu3 1/1 Running 0 7m
nginx-deployment-1370807587-6ekbw 1/1 Running 0 1m
nginx-deployment-1370807587-fg172 0/1 Pending 0 1m
nginx-deployment-1370807587-fz9sd 0/1 Pending 0 1m
Щоб дізнатися, чому Pod nginx-deployment-1370807587-fz9sd не працює, можна виконати kubectl describe pod для Podʼа в стані Pending і переглянути його події:
kubectl describe pod nginx-deployment-1370807587-fz9sd
Name: nginx-deployment-1370807587-fz9sd
Namespace: default
Node: /
Labels: app=nginx,pod-template-hash=1370807587
Status: Pending
IP:
Controllers: ReplicaSet/nginx-deployment-1370807587
Containers:
nginx:
Image: nginx
Port: 80/TCP
QoS Tier:
memory: Guaranteed
cpu: Guaranteed
Limits:
cpu: 1
memory: 128Mi
Requests:
cpu: 1
memory: 128Mi
Environment Variables:
Volumes:
default-token-4bcbi:
Type: Secret (a volume populated by a Secret)
SecretName: default-token-4bcbi
Events:
FirstSeen LastSeen Count From SubobjectPath Type Reason Message
--------- -------- ----- ---- ------------- -------- ------ -------
1m 48s 7 {default-scheduler } Warning FailedScheduling pod (nginx-deployment-1370807587-fz9sd) failed to fit in any node
fit failure on node (kubernetes-node-6ta5): Node didn't have enough resource: CPU, requested: 1000, used: 1420, capacity: 2000
fit failure on node (kubernetes-node-wul5): Node didn't have enough resource: CPU, requested: 1000, used: 1100, capacity: 2000
Тут видно подію, створену планувальником, яка повідомляє, що Pod не вдалося запланувати з причиною FailedScheduling (і, можливо, з іншими). Повідомлення каже, що на жодному з вузлів не було достатньо ресурсів для Podʼа.
Щоб виправити ситуацію, можна за допомогою kubectl scale оновити Deployment і вказати чотири або менше реплік. (Або можна залишити один Pod у стані Pending, це нешкідливо.)
Події, подібні до тих, що ви бачили в кінці виводу kubectl describe pod, зберігаються в etcd і дають загальне уявлення про те, що відбувається в кластері. Щоб вивести всі події, можна використати
kubectl get events
але памʼятайте, що події належать до простору імен. Це означає, що якщо вас цікавлять події для обʼєкта в просторі імен (наприклад, що сталося з Podʼами в просторі імен my-namespace), потрібно явно вказати простір імен у команді:
kubectl get events --namespace=my-namespace
Щоб побачити події з усіх просторів імен, ви можете використовувати аргумент --all-namespaces.
Крім kubectl describe pod, ще один спосіб отримати додаткову інформацію про Pod (понад ту, що надає kubectl get pod) — передати команді kubectl get pod прапорець формату виводу -o yaml. Так ви отримаєте у форматі YAML ще більше інформації, ніж від kubectl describe pod, — фактично всю інформацію, яку система має про Pod. Тут ви побачите, зокрема, анотації (метадані у вигляді пар ключ-значення без обмежень, що діють для міток, які внутрішньо використовують компоненти системи Kubernetes), політику перезапуску, порти й томи.
kubectl get pod nginx-deployment-1006230814-6winp -o yaml
Налагодження за допомогою виконання команд у контейнері
Якщо образ контейнера містить утиліти для налагодження, як-от образи, зібрані на основі базових образів ОС Linux і Windows, можна виконувати команди в конкретному контейнері за допомогою kubectl exec:
Налагодження за допомогою ефемерного контейнера налагодження
СТАН ФУНКЦІОНАЛУ:GA since Kubernetes v1.25
Ефемерні контейнери корисні для інтерактивного усунення несправностей, коли kubectl exec недостатньо, тому що контейнер аварійно завершився або образ контейнера не містить утиліт налагодження, як, наприклад, образи distroless.
Дозволи для ефемерних контейнерів
З міркувань безпеки для додавання ефемерного контейнера до запущеного Podʼа використовується підресурс ephemeralcontainers цього Podʼа. На рівні API це запит update до pods/ephemeralcontainers. Самого лише дозволу на patch Podʼа недостатньо, щоб користувачі могли додавати до нього ефемерні контейнери.
Якщо запустити kubectl debug, щоб додати ефемерний контейнер, без потрібного дозволу, ви побачите помилку, подібну до такої:
Error from server (Forbidden): pods "example" is forbidden: User "alice" cannot
patch resource "pods/ephemeralcontainers" in API group "" in the namespace "example-ns"
Якщо ви керуєте доступом до кластера і ваш кластер використовує RBAC Kubernetes, цей дозвіл можна надати одним із двох способів.
Щоб розширити вбудовані ClusterRole edit і admin для всього кластера, створіть агреговану ClusterRole з міткою для агрегації ClusterRole. Достатньо мітки aggregate-to-edit, оскільки стандартна ClusterRole edit сама агрегується в admin:
Щоб надати дозвіл лише певним користувачам або групам (наприклад, окремій групі для налагодження або SRE), створіть вужчу ClusterRole і привʼяжіть її безпосередньо:
Ефемерні контейнери перевіряються механізмом Pod Security admission на відповідність тим самим стандартам безпеки Podʼів, що й звичайні контейнери. Надаючи дозвіл на додавання ефемерних контейнерів до Podʼів, на які поширюється політика baseline або restricted, виберіть відповідний профіль налагодження, наприклад --profile=baseline або --profile=restricted для kubectl debug.
Вебхуки допуску або політики допуску у вашому кластері, які не перевіряють поле ephemeralContainers, також може знадобитися оновити, щоб вони перехоплювали ресурс pods/ephemeralcontainers і перевіряли поле ephemeralContainers у специфікації Podʼа.
Приклад налагодження за допомогою ефемерних контейнерів
Ви можете використовувати команду kubectl debug, щоб додати ефемерні контейнери до запущеного Podʼа. Спочатку створіть Pod для прикладу:
kubectl run ephemeral-demo --image=registry.k8s.io/pause:3.1 --restart=Never
Приклади в цьому розділі використовують образ контейнера pause, оскільки він не містить утиліт налагодження, але цей метод працює з усіма образами контейнерів.
Якщо ви спробуєте використати kubectl exec для створення оболонки, ви побачите помилку, оскільки в цьому образі контейнера немає оболонки.
kubectl exec -it ephemeral-demo -- sh
OCI runtime exec failed: exec failed: container_linux.go:346: starting container process caused "exec: \"sh\": executable file not found in $PATH": unknown
Натомість можна додати контейнер налагодження за допомогою kubectl debug. Якщо вказати аргумент -i/--interactive, kubectl автоматично підʼєднається до консолі ефемерного контейнера.
Defaulting debug container name to debugger-8xzrl.
If you don't see a command prompt, try pressing enter.
/ #
Ця команда додає новий контейнер busybox і підʼєднується до нього. Параметр --target вказує на простір імен процесів іншого контейнера. Він потрібен тут, тому що kubectl run не вмикає спільний простір імен процесів у Podʼі, який створює.
Примітка:
Параметр --target має підтримуватися середовищем виконання контейнерів. Якщо його не підтримано, ефемерний контейнер може не запуститися або запуститися з ізольованим простором імен процесів, і ps не показуватиме процеси в інших контейнерах.
Стан новоствореного ефемерного контейнера можна переглянути за допомогою kubectl describe:
Коли закінчите, видаліть Pod за допомогою kubectl delete:
kubectl delete pod ephemeral-demo
Налагодження за допомогою копії Podʼа
Іноді параметри конфігурації Podʼа ускладнюють усунення несправностей у певних ситуаціях. Наприклад, не можна виконати kubectl exec, щоб усунути несправності контейнера, якщо образ контейнера не містить оболонки або якщо ваш застосунок аварійно завершується під час запуску. У таких ситуаціях можна за допомогою kubectl debug створити копію Podʼа зі зміненими значеннями конфігурації, що полегшують налагодження.
Копіювання Podʼа з додаванням нового контейнера
Додавання нового контейнера може бути корисним, коли ваш застосунок працює, але поводиться не так, як ви очікуєте, і ви хочете додати до Podʼа додаткові утиліти для усунення несправностей.
Наприклад, можливо, образи контейнерів вашого застосунку зібрані на основі busybox, але вам потрібні утиліти налагодження, яких немає в busybox. Цей сценарій можна змоделювати за допомогою kubectl run:
kubectl run myapp --image=busybox:1.28 --restart=Never -- sleep 1d
Виконайте цю команду, щоб створити копію myapp з назвою myapp-debug, яка додає новий контейнер Ubuntu для налагодження:
Defaulting debug container name to debugger-w7xmf.
If you don't see a command prompt, try pressing enter.
root@myapp-debug:/#
Примітка:
kubectl debug автоматично генерує назву контейнера, якщо ви не задали її прапорцем --container.
Прапорець -i стандартно змушує kubectl debug підʼєднатися до нового контейнера. Щоб цього уникнути, вкажіть --attach=false. Якщо сесію буде розірвано, можна знову підʼєднатися за допомогою kubectl attach.
Можна за допомогою kubectl debug створити копію цього Podʼа з командою, заміненою на інтерактивну оболонку:
kubectl debug myapp -it --copy-to=myapp-debug --container=myapp -- sh
If you don't see a command prompt, try pressing enter.
/ #
Тепер у вас є інтерактивна оболонка, яку ви можете використовувати для виконання завдань, таких як перевірка шляхів файлової системи або виконання команди контейнера вручну.
Примітка:
Щоб змінити команду для конкретного контейнера, вам потрібно вказати його назву за допомогою --container, інакше kubectl debug створить новий контейнер для виконання вказаної вами команди.
Прапорець -i стандартно змушує kubectl debug підʼєднатися до контейнера. Щоб цього уникнути, вкажіть --attach=false. Якщо сесію буде розірвано, можна знову підʼєднатися за допомогою kubectl attach.
Не забудьте прибрати Pod для налагодження, коли ви закінчите:
kubectl delete pod myapp myapp-debug
Копіювання Podʼа з заміною образів контейнерів
У деяких ситуаціях вам може знадобитися замінити звичайні робочі образи контейнерів Podʼа, що поводиться неправильно, на образ зі збіркою для налагодження або з додатковими утилітами.
Наприклад, створіть Pod за допомогою kubectl run:
kubectl run myapp --image=busybox:1.28 --restart=Never -- sleep 1d
Тепер за допомогою kubectl debug створіть копію та змініть її образ контейнера на ubuntu:
Синтаксис --set-image використовує той самий синтаксис container_name=image, що й kubectl set image. *=ubuntu означає зміну образу всіх контейнерів на ubuntu.
Не забудьте прибрати Pod для налагодження, коли ви закінчите:
kubectl delete pod myapp myapp-debug
Налагодження через оболонку на вузлі
Якщо жоден з цих підходів не працює, ви можете знайти вузол, на якому працює Pod, і створити Pod, який буде виконуватися на цьому вузлі. Щоб створити інтерактивну оболонку на вузлі за допомогою kubectl debug, виконайте:
kubectl debug node/mynode -it --image=ubuntu
Creating debugging pod node-debugger-mynode-pdx84 with container debugger on node mynode.
If you don't see a command prompt, try pressing enter.
root@ek8s:/#
Створюючи сесію налагодження на вузлі, памʼятайте, що:
kubectl debug автоматично генерує назву нового Podʼа на основі назви вузла.
Коренева файлова система вузла буде змонтована в /host.
Контейнер працює в просторах імен IPC, Network і PID хоста, хоча Pod не привілейований, тому читання деякої інформації про процеси може не вдатися, і chroot /host може не спрацювати.
Якщо вам потрібен привілейований Pod, створіть його вручну або використайте прапорець --profile=sysadmin.
Не забудьте прибрати Pod для налагодження, коли ви закінчите з ним:
kubectl delete pod node-debugger-mynode-pdx84
Захоплення та аналіз трафіку вузла/Podʼа
Під час налагодження проблем з мережею захоплення та аналіз мережевого трафіку з вузлів/Podʼів може дати цінну інформацію про проблеми зі зʼєднанням, збої розвʼязання DNS або неочікувану поведінку мережі.
Ви можете використовувати kubectl debug з прапорцем --profile=sysadmin, щоб запускати інструменти захоплення мережевого трафіку на вузлі. Спочатку створіть сесію налагодження на вузлі, де працює ваш Pod:
Потім виконайте ту саму команду tcpdump у контейнері налагодження, щоб захопити трафік з мережевого простору імен Podʼа.
Налагодження Podʼа або вузла із застосуванням профілю
Коли ви використовуєте kubectl debug для налагодження вузла через Pod налагодження, Podʼа через ефемерний контейнер або скопійованого Podʼа, до них можна застосувати профіль. Застосування профілю встановлює певні властивості, такі як securityContext, що дає змогу пристосуватися до різних сценаріїв. Є два типи профілів: static і custom.
Застосування профілю static
Профіль static — це набір наперед визначених властивостей, які можна застосувати за допомогою прапорця --profile. Доступні такі профілі:
Профіль
Опис
legacy
Набір властивостей для зворотної сумісності з поведінкою 1.22
general
Обґрунтований набір загальних властивостей для будь-якого налагодження
Набір властивостей, включаючи привілеї адміністратора мережі
sysadmin
Набір властивостей, включаючи привілеї системного адміністратора (root)
Примітка:
Якщо ви не вкажете --profile, стандартно використовується профіль legacy, але його планується найближчим часом визнати застарілим. Тому рекомендується використовувати інші профілі, такі як general.
Припустимо, що ви створюєте Pod і налагоджуєте його. Спочатку створіть Pod з назвою myapp, наприклад:
kubectl run myapp --image=busybox:1.28 --restart=Never -- sleep 1d
Потім налагодьте Pod за допомогою ефемерного контейнера. Якщо ефемерному контейнеру потрібні привілеї, можна використати профіль sysadmin:
Targeting container "myapp". If you don't see processes from this container it may be because the container runtime doesn't support this feature.
Defaulting debug container name to debugger-6kg4x.
If you don't see a command prompt, try pressing enter.
/ #
Перевірте можливості процесу ефемерного контейнера, виконавши таку команду в контейнері:
Це означає, що завдяки профілю sysadmin процесу контейнера надано всі можливості, як привілейованому контейнеру. Докладніше про можливості.
Ви також можете перевірити, що ефемерний контейнер був створений як привілейований контейнер:
kubectl get pod myapp -o jsonpath='{.spec.ephemeralContainers[0].securityContext}'
{"privileged":true}
Приберіть Pod, коли закінчите з ним:
kubectl delete pod myapp
Застосування профілю custom
СТАН ФУНКЦІОНАЛУ:GA since Kubernetes v1.32
Можна визначити часткову специфікацію контейнера для налагодження як профіль custom у форматі YAML або JSON і застосувати його за допомогою прапорця --custom.
Примітка:
Профіль custom підтримує лише зміну специфікації контейнера, але зміни полів name, image, command, lifecycle і volumeDevices специфікації контейнера не дозволені. Зміну специфікації Podʼа він не підтримує.
Створіть Pod з назвою myapp, наприклад:
kubectl run myapp --image=busybox:1.28 --restart=Never -- sleep 1d
Створіть профіль custom у форматі YAML або JSON. Тут створимо файл у форматі YAML з назвою custom-profile.yaml:
Іноді під час налагодження корисно переглянути стан вузла — наприклад, тому що ви помітили дивну поведінку Podʼа, який працює на вузлі, або щоб зʼясувати, чому Pod не призначається на вузол. Як і для Podʼів, для отримання детальної інформації про вузли можна використовувати kubectl describe node і kubectl get node -o yaml. Наприклад, ось що ви побачите, якщо вузол не працює (відʼєднаний від мережі, або kubelet завершився й не перезапускається тощо). Зверніть увагу на події, які показують, що вузол у стані NotReady, а також на те, що Podʼи більше не працюють (їх буде виселено після пʼяти хвилин у стані NotReady).
kubectl get nodes
NAME STATUS ROLES AGE VERSION
kube-worker-1 NotReady <none> 1h v1.23.3
kubernetes-node-bols Ready <none> 1h v1.23.3
kubernetes-node-st6x Ready <none> 1h v1.23.3
kubernetes-node-unaj Ready <none> 1h v1.23.3
kubectl describe node kube-worker-1
Name: kube-worker-1
Roles: <none>
Labels: beta.kubernetes.io/arch=amd64
beta.kubernetes.io/os=linux
kubernetes.io/arch=amd64
kubernetes.io/hostname=kube-worker-1
kubernetes.io/os=linux
node.alpha.kubernetes.io/ttl: 0
volumes.kubernetes.io/controller-managed-attach-detach: true
CreationTimestamp: Thu, 17 Feb 2022 16:46:30 -0500
Taints: node.kubernetes.io/unreachable:NoExecute
node.kubernetes.io/unreachable:NoSchedule
Unschedulable: false
Lease:
HolderIdentity: kube-worker-1
AcquireTime: <unset>
RenewTime: Thu, 17 Feb 2022 17:13:09 -0500
Conditions:
Type Status LastHeartbeatTime LastTransitionTime Reason Message
---- ------ ----------------- ------------------ ------ -------
NetworkUnavailable False Thu, 17 Feb 2022 17:09:13 -0500 Thu, 17 Feb 2022 17:09:13 -0500 WeaveIsUp Weave pod has set this
MemoryPressure Unknown Thu, 17 Feb 2022 17:12:40 -0500 Thu, 17 Feb 2022 17:13:52 -0500 NodeStatusUnknown Kubelet stopped posting node status.
DiskPressure Unknown Thu, 17 Feb 2022 17:12:40 -0500 Thu, 17 Feb 2022 17:13:52 -0500 NodeStatusUnknown Kubelet stopped posting node status.
PIDPressure Unknown Thu, 17 Feb 2022 17:12:40 -0500 Thu, 17 Feb 2022 17:13:52 -0500 NodeStatusUnknown Kubelet stopped posting node status.
Ready Unknown Thu, 17 Feb 2022 17:12:40 -0500 Thu, 17 Feb 2022 17:13:52 -0500 NodeStatusUnknown Kubelet stopped posting node status.
Addresses:
InternalIP: 192.168.0.113
Hostname: kube-worker-1
Capacity:
cpu: 2
ephemeral-storage: 15372232Ki
hugepages-2Mi: 0
memory: 2025188Ki
pods: 110
Allocatable:
cpu: 2
ephemeral-storage: 14167048988
hugepages-2Mi: 0
memory: 1922788Ki
pods: 110
System Info:
Machine ID: 9384e2927f544209b5d7b67474bbf92b
System UUID: aa829ca9-73d7-064d-9019-df07404ad448
Boot ID: 5a295a03-aaca-4340-af20-1327fa5dab5c
Kernel Version: 5.13.0-28-generic
OS Image: Ubuntu 21.10
Operating System: linux
Architecture: amd64
Container Runtime Version: containerd://1.5.9
Kubelet Version: v1.23.3
Kube-Proxy Version: v1.23.3
Non-terminated Pods: (4 in total)
Namespace Name CPU Requests CPU Limits Memory Requests Memory Limits Age
--------- ---- ------------ ---------- --------------- ------------- ---
default nginx-deployment-67d4bdd6f5-cx2nz 500m (25%) 500m (25%) 128Mi (6%) 128Mi (6%) 23m
default nginx-deployment-67d4bdd6f5-w6kd7 500m (25%) 500m (25%) 128Mi (6%) 128Mi (6%) 23m
kube-system kube-proxy-dnxbz 0 (0%) 0 (0%) 0 (0%) 0 (0%) 28m
kube-system weave-net-gjxxp 100m (5%) 0 (0%) 200Mi (10%) 0 (0%) 28m
Allocated resources:
(Total limits may be over 100 percent, i.e., overcommitted.)
Resource Requests Limits
-------- -------- ------
cpu 1100m (55%) 1 (50%)
memory 456Mi (24%) 256Mi (13%)
ephemeral-storage 0 (0%) 0 (0%)
hugepages-2Mi 0 (0%) 0 (0%)
Events:
...
kubectl get node kube-worker-1 -o yaml
apiVersion:v1kind:Nodemetadata:annotations:node.alpha.kubernetes.io/ttl:"0"volumes.kubernetes.io/controller-managed-attach-detach:"true"creationTimestamp:"2022-02-17T21:46:30Z"labels:beta.kubernetes.io/arch:amd64beta.kubernetes.io/os:linuxkubernetes.io/arch:amd64kubernetes.io/hostname:kube-worker-1kubernetes.io/os:linuxname:kube-worker-1resourceVersion:"4026"uid:98efe7cb-2978-4a0b-842a-1a7bf12c05f8spec:{}status:addresses:- address:192.168.0.113type:InternalIP- address:kube-worker-1type:Hostnameallocatable:cpu:"2"ephemeral-storage:"14167048988"hugepages-2Mi:"0"memory:1922788Kipods:"110"capacity:cpu:"2"ephemeral-storage:15372232Kihugepages-2Mi:"0"memory:2025188Kipods:"110"conditions:- lastHeartbeatTime:"2022-02-17T22:20:32Z"lastTransitionTime:"2022-02-17T22:20:32Z"message:Weave pod has set thisreason:WeaveIsUpstatus:"False"type:NetworkUnavailable- lastHeartbeatTime:"2022-02-17T22:20:15Z"lastTransitionTime:"2022-02-17T22:13:25Z"message:kubelet has sufficient memory availablereason:KubeletHasSufficientMemorystatus:"False"type:MemoryPressure- lastHeartbeatTime:"2022-02-17T22:20:15Z"lastTransitionTime:"2022-02-17T22:13:25Z"message:kubelet has no disk pressurereason:KubeletHasNoDiskPressurestatus:"False"type:DiskPressure- lastHeartbeatTime:"2022-02-17T22:20:15Z"lastTransitionTime:"2022-02-17T22:13:25Z"message:kubelet has sufficient PID availablereason:KubeletHasSufficientPIDstatus:"False"type:PIDPressure- lastHeartbeatTime:"2022-02-17T22:20:15Z"lastTransitionTime:"2022-02-17T22:15:15Z"message:kubelet is posting ready statusreason:KubeletReadystatus:"True"type:ReadydaemonEndpoints:kubeletEndpoint:Port:10250nodeInfo:architecture:amd64bootID:22333234-7a6b-44d4-9ce1-67e31dc7e369containerRuntimeVersion:containerd://1.5.9kernelVersion:5.13.0-28-generickubeProxyVersion:v1.23.3kubeletVersion:v1.23.3machineID:9384e2927f544209b5d7b67474bbf92boperatingSystem:linuxosImage:Ubuntu 21.10systemUUID:aa829ca9-73d7-064d-9019-df07404ad448
Аналіз логів
Наразі для глибшого дослідження кластера потрібно входити на відповідні машини. Ось розташування відповідних файлів логів. У системах на основі systemd замість перегляду файлів логів може знадобитися journalctl.
Вузли панелі управління
/var/log/kube-apiserver.log — API-сервер, відповідальний за обслуговування API
/var/log/kube-scheduler.log — планувальник, відповідальний за ухвалення рішень щодо планування
/var/log/kube-controller-manager.log — компонент, який запускає більшість вбудованих контролерів Kubernetes, за помітним винятком планування (плануванням займається kube-scheduler).
Робочі вузли
/var/log/kubelet.log — логи kubelet, відповідального за запуск контейнерів на вузлі
/var/log/kube-proxy.log — логи kube-proxy, відповідального за спрямування трафіку до точок доступу Service
Режими відмови кластера
Це неповний перелік того, що може піти не так, і того, як змінити налаштування кластера, щоб помʼякшити проблеми.
Причини відмов
Вимкнення віртуальних машин
Розділення мережі всередині кластера або між кластером і користувачами
Збої програмного забезпечення Kubernetes
Втрата даних або недоступність постійного сховища (наприклад, томів GCE PD або AWS EBS)
Помилка оператора, наприклад, неправильно налаштоване програмне забезпечення Kubernetes або застосунків
Конкретні сценарії
Вимкнення віртуальної машини API-сервера або збій apiserver
Результати
не вдається зупинити, оновити чи запустити нові Podʼи, Service, ReplicationController
наявні Podʼи та Service мають і далі працювати нормально, якщо вони не залежать від API Kubernetes
Втрата сховища, що лежить в основі API-сервера
Результати
компонент kube-apiserver не може успішно запуститися й стати справним
kubelet не зможуть звʼязатися з ним, але й далі запускатимуть ті самі Podʼи та забезпечуватимуть те саме проксіювання Service
перед перезапуском apiserver необхідно вручну відновити або відтворити його стан
Вимкнення віртуальних машин або збої допоміжних сервісів (контролер вузлів, менеджер контролерів реплікації, планувальник тощо)
наразі вони розміщені разом з apiserver, і їхня недоступність має схожі наслідки, як і недоступність apiserver
у майбутньому вони також будуть репліковані й можуть розміщуватися окремо
вони не мають власного постійного стану
Вимкнення окремого вузла (віртуальної або фізичної машини)
Результати
Podʼи на цьому вузлі припиняють роботу
Розділення мережі
Результати
розділ A вважає, що вузли в розділі B не працюють; розділ B вважає, що не працює apiserver. (За умови, що master VM опиниться в розділі A.)
Збій програмного забезпечення kubelet
Результати
kubelet, що аварійно завершився, не може запускати нові Podʼи на вузлі
kubelet може видаляти Podʼи або ні
вузол позначається як несправний
ReplicationController запускають нові Podʼи в інших місцях
Помилка оператора кластера
Результати
втрата Podʼів, Service тощо
втрата сховища, що лежить в основі apiserver
користувачі не можуть читати API
тощо
Помʼякшення
Дія: використовуйте можливість автоматичного перезапуску віртуальних машин IaaS-провайдера для віртуальних машин IaaS
Помʼякшує: вимкнення віртуальної машини apiserver або збій apiserver
Помʼякшує: вимкнення віртуальних машин або збої допоміжних сервісів
Дія: використовуйте надійне сховище IaaS-провайдера (наприклад, томи GCE PD або AWS EBS) для віртуальних машин з apiserver+etcd
Помʼякшує: втрату сховища, що лежить в основі apiserver
Для Kubernetes Metrics API пропонує базовий набір метрик для підтримки автоматичного масштабування та подібних випадків використання. Це API робить доступною інформацію про використання ресурсів вузлами й Podʼами, зокрема метрики CPU та памʼяті. Якщо ви розгорнете Metrics API у своєму кластері, клієнти API Kubernetes зможуть запитувати цю інформацію, а ви зможете використовувати механізми контролю доступу Kubernetes для керування дозволами на це.
HorizontalPodAutoscaler (HPA) і VerticalPodAutoscaler (VPA) використовують дані з Metrics API, щоб коригувати кількість реплік і ресурси робочих навантажень відповідно до попиту користувачів.
Ви також можете переглядати метрики ресурсів, використовуючи команду kubectl top.
Примітка:
Metrics API та конвеєр метрик, який воно уможливлює, надають лише мінімальний набір метрик CPU та памʼяті для автоматичного масштабування за допомогою HPA та / або VPA. Якщо ви хочете надати повніший набір метрик, ви можете доповнити простіший Metrics API, розгорнувши другий конвеєр метрик, який використовує Custom Metrics API.
flowchart RL
subgraph cluster[Кластер]
direction RL
S[
]
A[Сервер- метрик]
subgraph B[Вузли]
direction TB
D[cAdvisor] --> C[kubelet]
E[Середовище виконання контейнерів] --> D
E1[Середовище виконання контейнерів] --> D
P[Дані Podʼа] -.- C
end
L[API-сервер]
W[HPA]
C ---->|метрики ресурсів на рівні вузла| A -->|Metrics API| L --> W
end
L ---> K[kubectl top]
classDef box fill:#fff,stroke:#000,stroke-width:1px,color:#000;
class W,B,P,K,cluster,D,E,E1 box
classDef spacewhite fill:#ffffff,stroke:#fff,stroke-width:0px,color:#000
class S spacewhite
classDef k8s fill:#326ce5,stroke:#fff,stroke-width:1px,color:#fff;
class A,L,C k8s
Схема 1. Конвеєр метрик ресурсів
Компоненти архітектури, справа наліво на схемі, такі:
cAdvisor: демон, вбудований у kubelet, для збирання, агрегування та надання метрик контейнерів.
kubelet: агент вузла для керування ресурсами контейнерів. Метрики ресурсів доступні через точки доступу API kubelet /metrics/resource і /stats.
метрики ресурсів на рівні вузла: API, який надає kubelet для виявлення й отримання підсумкової статистики по вузлу, доступної через точку доступу /metrics/resource.
metrics-server: компонент-надбудова кластера, який збирає й агрегує метрики ресурсів, отримані від кожного kubelet. API-сервер обслуговує Metrics API для HPA, VPA і команди kubectl top. Metrics Server — це еталонна реалізація Metrics API.
Metrics API: API Kubernetes, що надає доступ до даних про CPU та памʼять, які використовуються для автомасштабування робочих навантажень. Щоб це працювало у вашому кластері, потрібен API-сервер розширення, який надає Metrics API.
Примітка:
cAdvisor підтримує читання метрик з cgroups, що працює зі звичайними середовищами виконання контейнерів у Linux. Якщо ви використовуєте середовище виконання контейнерів з іншим механізмом ізоляції ресурсів, наприклад віртуалізацією, це середовище виконання контейнерів має підтримувати метрики контейнерів CRI, щоб метрики були доступні kubelet.
Metrics API
СТАН ФУНКЦІОНАЛУ:GA since Kubernetes v1.37
Metrics-server реалізує Metrics API. Це API дає змогу отримати дані про використання CPU та памʼяті вузлами й Podʼами вашого кластера. Його основна роль — передавати метрики використання ресурсів компонентам автомасштабування K8s.
Ось приклад запиту до Metrics API для вузла minikube, обробленого через jq для зручного перегляду:
kubectl get --raw "/apis/metrics.k8s.io/v1/nodes/minikube"| jq '.'
Щоб отримати доступ до Metrics API, потрібно розгорнути metrics-server або інший адаптер, який його надає.
Вимірювання використання ресурсів
CPU
CPU відображається як середнє використання ядер, виміряне в одиницях CPU. Один CPU у Kubernetes еквівалентний 1 vCPU/ядру в хмарних провайдерів і 1 гіперпотоку на процесорах Intel на bare-metal.
Це значення отримують, обчислюючи швидкість зміни накопичувального лічильника CPU, який надає ядро (і в Linux, і в Windows). Часове вікно, використане для обчислення CPU, показано в полі window у Metrics API.
Щоб дізнатися більше про те, як Kubernetes розподіляє та вимірює ресурси CPU, дивіться значення CPU.
Памʼять
Памʼять відображається як робочий набір, виміряний у байтах, у момент збору метрики.
В ідеальному світі "робочий набір" — це обсяг памʼяті, що використовується й не може бути звільнений за умов тиску на памʼять. Однак обчислення робочого набору залежить від ОС хоста й, як правило, значною мірою покладається на евристики для отримання оцінки.
Модель Kubernetes для робочого набору контейнера очікує, що середовище виконання контейнерів враховує анонімну памʼять, повʼязану з відповідним контейнером. Метрика робочого набору зазвичай також включає деяку кешовану памʼять (file-backed), оскільки ОС хоста не завжди може звільнити сторінки.
Щоб дізнатися більше про те, як Kubernetes розподіляє та вимірює ресурси памʼяті, дивіться значення памʼяті.
Metrics Server
Metrics-server отримує метрики ресурсів від kubelet і надає їх через Metrics API на API-сервері Kubernetes для використання HPA та VPA. Ці метрики також можна переглядати командою kubectl top.
Metrics-server використовує API Kubernetes для відстеження вузлів і Podʼів у вашому кластері. Metrics-server запитує кожен вузол через HTTP, щоб отримати метрики. Metrics-server також будує внутрішнє подання метаданих Podʼів і зберігає кеш стану справності Podʼів. Ця кешована інформація про стан справності Podʼів доступна через API розширення, яке надає metrics-server.
Наприклад, для запиту HPA metrics-server має визначити, які Podʼи відповідають селекторам міток у Deployment.
Metrics-server викликає API kubelet для збору метрик з кожного вузла. Залежно від версії metrics-server використовується:
Точка доступу ресурсів метрик /metrics/resource у версії v0.6.0+ або
Точка доступу Summary API /stats/summary у старіших версіях
Щоб дізнатися про те, як kubelet надає метрики вузла, і як ви можете отримати до них доступ через API Kubernetes, прочитайте Дані метрик вузлів.
4.4.2 - Відстеження стану вузлів
Node Problem Detector — це демон для моніторингу стану вузла та звітування про нього. Node Problem Detector можна запустити як DaemonSet або як окремий демон. Node Problem Detector збирає інформацію про проблеми вузла з різних демонів і повідомляє про ці стани API-серверу як стани вузла або як події.
Вам треба мати кластер Kubernetes, а також інструмент командного рядка kubectl має бути налаштований для роботи з вашим кластером. Рекомендується виконувати ці настанови у кластері, що має щонайменше два вузли, які не виконують роль вузлів управління. Якщо у вас немає кластера, ви можете створити його, за допомогою minikube або використовувати одну з цих пісочниць:
Node Problem Detector використовує формат логу ядра для повідомлення про проблеми ядра. Щоб дізнатися, як розширити формат логу ядра, дивіться Додавання підтримки іншого формату логів.
Увімкнення Node Problem Detector
Деякі хмарні постачальники вмикають Node Problem Detector як надбудову. Ви також можете увімкнути Node Problem Detector за допомогою kubectl або створивши DaemonSet надбудови.
Використання kubectl для увімкнення Node Problem Detector
kubectl дає найгнучкіше керування Node Problem Detector. Ви можете перезаписати стандартну конфігурацію, щоб пристосувати її до свого середовища або виявляти власні проблеми вузла. Наприклад:
Створіть конфігурацію Node Problem Detector, аналогічну node-problem-detector.yaml:
Використання Podʼа надбудови для увімкнення Node Problem Detector
Якщо ви використовуєте власне рішення для початкового налаштування кластера й вам не потрібно перезаписувати стандартну конфігурацію, ви можете скористатися Podʼом надбудови, щоб ще більше автоматизувати розгортання.
Створіть node-problem-detector.yaml та збережіть конфігурацію в теці Podʼа надбудови /etc/kubernetes/addons/node-problem-detector на вузлі панелі управління.
apiVersion:apps/v1kind:DaemonSetmetadata:name:node-problem-detector-v0.1namespace:kube-systemlabels:k8s-app:node-problem-detectorversion:v0.1kubernetes.io/cluster-service:"true"spec:selector:matchLabels:k8s-app:node-problem-detector version:v0.1kubernetes.io/cluster-service:"true"template:metadata:labels:k8s-app:node-problem-detectorversion:v0.1kubernetes.io/cluster-service:"true"spec:hostNetwork:truecontainers:- name:node-problem-detectorimage:registry.k8s.io/node-problem-detector:v0.1securityContext:privileged:trueresources:limits:cpu:"200m"memory:"100Mi"requests:cpu:"20m"memory:"20Mi"volumeMounts:- name:logmountPath:/logreadOnly:true- name:config# Overwrite the config/ directory with ConfigMap volumemountPath:/configreadOnly:truevolumes:- name:loghostPath:path:/var/log/- name:config# Define ConfigMap volumeconfigMap:name:node-problem-detector-config
Перестворіть Node Problem Detector з новим файлом конфігурації:
# Якщо у вас працює node-problem-detector, видаліть його перед перествореннямkubectl delete -f https://k8s.io/examples/debug/node-problem-detector.yaml
kubectl apply -f https://k8s.io/examples/debug/node-problem-detector-configmap.yaml
Примітка:
Цей підхід застосовується тільки до Node Problem Detector, запущеного за допомогою kubectl.
Перезапис конфігурації не підтримується, якщо Node Problem Detector працює як надбудова кластера. Менеджер надбудов не підтримує ConfigMap.
Демони проблем
Демон проблем — це піддемон Node Problem Detector. Він моніторить певні види проблем вузла та повідомляє про них Node Problem Detector. Існує кілька типів підтримуваних демонів проблем.
Демон типу SystemLogMonitor відстежує системні логи й повідомляє про проблеми та метрики згідно з попередньо визначеними правилами. Ви можете налаштувати конфігурації для різних джерел логів, таких як filelog, kmsg, kernel, abrt і systemd.
Демон типу SystemStatsMonitor збирає різні системні статистичні дані, повʼязані зі справністю, як метрики. Його поведінку можна налаштувати, оновивши його файл конфігурації.
Демон типу CustomPluginMonitor викликає та перевіряє різні проблеми вузла, запускаючи сценарії, визначені користувачем. Ви можете використовувати різні власні втулки моніторингу для відстеження різних проблем і налаштовувати поведінку демона, оновивши файл конфігурації.
Демон типу HealthChecker перевіряє справність kubelet і середовища виконання контейнерів на вузлі.
Додавання підтримки іншого формату логів
Монітор системного логу наразі підтримує файлові логи, journald та kmsg. Додаткові джерела можна додати, реалізувавши новий спостерігач за логами.
Додавання власних втулків моніторингу
Ви можете розширити Node Problem Detector, щоб він виконував будь-які сценарії моніторингу, написані будь-якою мовою, розробивши власний втулок. Сценарії моніторингу мають відповідати протоколу втулка щодо коду виходу та стандартного виводу. Докладніше дивіться пропозицію інтерфейсу втулка.
Експортер
Експортер повідомляє про проблеми та/або метрики вузлів певним бекендам. Підтримуються такі експортери:
Експортер Kubernetes: цей експортер повідомляє про проблеми вузлів API-серверу Kubernetes. Тимчасові проблеми повідомляються як події (Events), а постійні — як стани вузла (Node Conditions).
Експортер Prometheus: цей експортер локально повідомляє про проблеми вузлів і метрики як метрики Prometheus (або OpenMetrics). IP-адресу й порт експортера можна вказати аргументами командного рядка.
Експортер Stackdriver: цей експортер повідомляє про проблеми вузлів і метрики до Stackdriver Monitoring API. Поведінку експорту можна налаштувати за допомогою файлу конфігурації.
Рекомендації та обмеження
Рекомендується запускати Node Problem Detector у кластері для моніторингу стану вузлів. Під час роботи Node Problem Detector можна очікувати додаткових витрат ресурсів на кожному вузлі. Зазвичай це прийнятно, оскільки:
Лог ядра росте відносно повільно.
Для Node Problem Detector встановлено обмеження ресурсів.
Навіть під високим навантаженням використання ресурсів прийнятне. Докладніше дивіться результати бенчмарку Node Problem Detector.
4.4.3 - Налагодження вузлів Kubernetes за допомогою crictl
СТАН ФУНКЦІОНАЛУ:GA since Kubernetes v1.11
crictl — це інтерфейс командного рядка для середовищ виконання контейнерів, сумісних з CRI. За його допомогою можна оглядати й налагоджувати середовища виконання контейнерів і застосунки на вузлі Kubernetes. crictl і його вихідний код розміщено в репозиторії cri-tools.
Перш ніж ви розпочнете
Для роботи crictl потрібна операційна система Linux із середовищем виконання CRI.
Встановлення crictl
Стиснений архів crictl для кількох різних архітектур можна завантажити зі сторінки релізів cri-tools. Завантажте версію, яка відповідає вашій версії Kubernetes. Розпакуйте архів і перемістіть crictl у теку з вашого системного шляху, наприклад /usr/local/bin/.
Загальне використання
Команда crictl має кілька підкоманд і прапорців середовища виконання. Докладніше дивіться crictl help або crictl <subcommand> help.
Точку доступу для crictl можна встановити одним із таких способів:
Встановіть прапорці --runtime-endpoint та --image-endpoint.
Встановіть змінні середовища CONTAINER_RUNTIME_ENDPOINT та IMAGE_SERVICE_ENDPOINT.
Встановіть точку доступу у файлі конфігурації /etc/crictl.yaml. Щоб вказати інший файл, використовуйте прапорець --config=PATH_TO_FILE під час запуску crictl.
Примітка:
Якщо ви не встановите точку доступу, crictl намагатиметься підʼєднатися до відомих точок доступу зі списку, що може вплинути на продуктивність.
Також можна вказати тайм-аут підʼєднання до сервера й увімкнути або вимкнути налагодження, задавши значення timeout або debug у файлі конфігурації або використавши прапорці командного рядка --timeout і --debug.
Щоб переглянути або змінити поточну конфігурацію, перегляньте або відредагуйте вміст /etc/crictl.yaml. Наприклад, з середовищем виконання контейнерів containerd конфігурація буде схожа на таку:
Наведені нижче приклади показують деякі команди crictl і приклади їхнього виводу.
Отримання переліку Podʼів
Вивести всі Podʼи:
crictl pods
Вивід подібний до такого:
POD ID CREATED STATE NAME NAMESPACE ATTEMPT
926f1b5a1d33a About a minute ago Ready sh-84d7dcf559-4r2gq default 0
4dccb216c4adb About a minute ago Ready nginx-65899c769f-wv2gp default 0
a86316e96fa89 17 hours ago Ready kube-proxy-gblk4 kube-system 0
919630b8f81f1 17 hours ago Ready nvidia-device-plugin-zgbbv kube-system 0
Вивести Podʼи за назвою:
crictl pods --name nginx-65899c769f-wv2gp
Вивід подібний до такого:
POD ID CREATED STATE NAME NAMESPACE ATTEMPT
4dccb216c4adb 2 minutes ago Ready nginx-65899c769f-wv2gp default 0
Вивести Podʼи за міткою:
crictl pods --label run=nginx
Вивід подібний до такого:
POD ID CREATED STATE NAME NAMESPACE ATTEMPT
4dccb216c4adb 2 minutes ago Ready nginx-65899c769f-wv2gp default 0
CONTAINER ID IMAGE CREATED STATE NAME ATTEMPT
1f73f2d81bf98 busybox@sha256:141c253bc4c3fd0a201d32dc1f493bcf3fff003b6df416dea4f41046e0f37d47 7 minutes ago Running sh 1
9c5951df22c78 busybox@sha256:141c253bc4c3fd0a201d32dc1f493bcf3fff003b6df416dea4f41046e0f37d47 8 minutes ago Exited sh 0
87d3992f84f74 nginx@sha256:d0a8828cccb73397acb0073bf34f4d7d8aa315263f1e7806bf8c55d8ac139d5f 8 minutes ago Running nginx 0
1941fb4da154f k8s-gcrio.azureedge.net/hyperkube-amd64@sha256:00d814b1f7763f4ab5be80c58e98140dfc69df107f253d7fdd714b30a714260a 18 hours ago Running kube-proxy 0
Вивести запущені контейнери:
crictl ps
Вивід подібний до такого:
CONTAINER ID IMAGE CREATED STATE NAME ATTEMPT
1f73f2d81bf98 busybox@sha256:141c253bc4c3fd0a201d32dc1f493bcf3fff003b6df416dea4f41046e0f37d47 6 minutes ago Running sh 1
87d3992f84f74 nginx@sha256:d0a8828cccb73397acb0073bf34f4d7d8aa315263f1e7806bf8c55d8ac139d5f 7 minutes ago Running nginx 0
1941fb4da154f k8s-gcrio.azureedge.net/hyperkube-amd64@sha256:00d814b1f7763f4ab5be80c58e98140dfc69df107f253d7fdd714b30a714260a 17 hours ago Running kube-proxy 0
Аудит Kubernetes надає важливий для безпеки хронологічний набір записів, що документують послідовність дій у кластері. Кластер проводить аудит дій, ініційованих користувачами, застосунками, які використовують API Kubernetes, і самою панеллю управління.
Аудит дає змогу адміністраторам кластера відповісти на такі запитання:
що сталося?
коли це сталося?
хто це ініціював?
з чим це сталося?
де це було помічено?
звідки це було ініційовано?
куди це прямувало?
Записи аудиту починають свій життєвий цикл у компоненті kube-apiserver. Кожен запит на кожному етапі виконання генерує подію аудиту, яку потім попередньо обробляють відповідно до певної політики й записують у бекенд. Політика визначає, що записується, а бекенди зберігають записи. Поточні реалізації бекендів — файли логів і вебхуки.
Кожен запит можна записати з відповідним етапом (stage). Визначено такі етапи:
RequestReceived — етап для подій, що генеруються, щойно обробник аудиту отримує запит, і до того, як запит передано далі ланцюжком обробників.
ResponseStarted — після надсилання заголовків відповіді, але до надсилання тіла відповіді. Цей етап генерується лише для тривалих запитів (наприклад, watch).
ResponseComplete — тіло відповіді завершено, і більше жодних байтів не буде надіслано.
Panic — події, що генеруються, коли сталася паніка.
Можливість логування аудиту збільшує споживання памʼяті API-сервером, оскільки для кожного запиту зберігається певний контекст, потрібний для аудиту. Споживання памʼяті залежить від конфігурації логування аудиту.
Політика аудиту
Політика аудиту визначає правила щодо того, які події слід записувати і які дані вони мають містити. Структуру обʼєкта політики аудиту визначено в групі API audit.k8s.io. Під час обробки подію по черзі порівнюють зі списком правил. Перше правило, що збіглося, встановлює рівень аудиту події. Визначено такі рівні аудиту:
None — не записувати події, які відповідають цьому правилу.
Metadata — записувати події з метаданими (користувач, що надіслав запит, часова мітка, ресурс, дієслово тощо), але без тіла запиту чи відповіді.
Request — записувати події з метаданими й тілом запиту, але без тіла відповіді. Це не стосується запитів, не повʼязаних з ресурсами.
RequestResponse — записувати події з метаданими запиту, тілом запиту й тілом відповіді. Це не стосується запитів, не повʼязаних з ресурсами.
Файл з політикою можна передати kube-apiserver за допомогою прапорця --audit-policy-file. Якщо прапорець пропущено, жодні події не записуються. Зверніть увагу, що поле rulesобовʼязково має бути у файлі політики аудиту. Політика без правил (0) вважається неприпустимою.
apiVersion:audit.k8s.io/v1# Це обовʼязково.kind:Policy# Не генерувати події аудиту для всіх запитів на етапі RequestReceived.omitStages:- "RequestReceived"rules:# Логувати зміни Podʼів на рівні RequestResponse- level:RequestResponseresources:- group:""# Ресурс "pods" не охоплює запити до будь-якого субресурсу Podʼів,# що узгоджується з політикою RBAC.resources:["pods"]# Логувати "pods/log", "pods/status" на рівні Metadata- level:Metadataresources:- group:""resources:["pods/log","pods/status"]# Не логувати запити до ConfigMap з назвою "controller-leader"- level:Noneresources:- group:""resources:["configmaps"]resourceNames:["controller-leader"]# Не логувати watch-запити від "system:kube-proxy" до endpoints або services- level:Noneusers:["system:kube-proxy"]verbs:["watch"]resources:- group:""# основна група APIresources:["endpoints","services"]# Не логувати автентифіковані запити до певних URL-шляхів, що не є ресурсами.- level:NoneuserGroups:["system:authenticated"]nonResourceURLs:- "/api*"# Зіставлення за шаблоном.- "/version"# Логувати тіло запитів на зміну ConfigMap у kube-system.- level:Requestresources:- group:""# основна група APIresources:["configmaps"]# Це правило застосовується тільки до ресурсів в просторі імен "kube-system".# Порожній рядок "" можна використовувати для вибору ресурсів без простору імен.namespaces:["kube-system"]# Логувати зміни ConfigMap і Secret у всіх інших просторах імен на рівні Metadata.- level:Metadataresources:- group:""# основна група APIresources:["secrets","configmaps"]# Логувати всі інші ресурси в групах core та extensions на рівні Request.- level:Requestresources:- group:""# основна група API- group:"extensions"# Версію групи НЕ слід вказувати.# Загальне правило для логування всіх інших запитів на рівні Metadata.- level:Metadata# Тривалі запити, як-от watch, що підпадають під це правило,# не генерують подію аудиту на етапі RequestReceived.omitStages:- "RequestReceived"
Можна використати мінімальний файл політики аудиту, щоб записувати всі запити на рівні Metadata:
# Записувати всі запити на рівні Metadata.apiVersion:audit.k8s.io/v1kind:Policyrules:- level:Metadata
Якщо ви створюєте власний профіль аудиту, за відправну точку можна взяти профіль аудиту для Google Container-Optimized OS. Перегляньте скрипт configure-helper.sh, який генерує файл політики аудиту. Більшу частину файлу політики аудиту можна побачити безпосередньо в скрипті.
Бекенди аудиту зберігають події аудиту в зовнішньому сховищі. Без додаткових налаштувань kube-apiserver надає два бекенди:
бекенд логів, який записує події у файлову систему
бекенд webhook, який надсилає події до зовнішнього HTTP API
У всіх випадках події аудиту мають структуру, визначену API Kubernetes у групі API audit.k8s.io.
Примітка:
У разі патчів тіло запиту — це масив JSON з операціями патча, а не обʼєкт JSON з відповідним обʼєктом API Kubernetes. Наприклад, наведене нижче тіло запиту є коректним запитом на патч до /apis/batch/v1/namespaces/some-namespace/jobs/some-job-name:
Бекенд логів записує події аудиту у файл у форматі JSONlines. Бекенд аудиту логів можна налаштувати за допомогою таких прапорців kube-apiserver:
--audit-log-path вказує шлях до файлу логу, який бекенд логів використовує для запису подій аудиту. Якщо цей прапорець не вказано, бекенд логів вимкнено. - означає стандартний вивід
--audit-log-maxage визначає максимальну кількість днів для зберігання старих файлів логів аудиту
--audit-log-maxbackup визначає максимальну кількість файлів логів аудиту для зберігання
--audit-log-maxsize визначає максимальний розмір файлу логу аудиту в мегабайтах, після якого виконується його ротація
Якщо панель управління вашого кластера запускає kube-apiserver як Pod, не забудьте змонтувати hostPath у розташування файлу політики й файлу логів, щоб записи аудиту зберігалися. Наприклад:
Бекенд аудиту webhook надсилає події аудиту до віддаленого веб-API, яке вважається різновидом API Kubernetes, зокрема щодо засобів автентифікації. Бекенд аудиту webhook можна налаштувати за допомогою таких прапорців kube-apiserver:
--audit-webhook-config-file вказує шлях до файлу з конфігурацією webhook. Конфігурація webhook фактично є спеціалізованим kubeconfig.
--audit-webhook-initial-backoff вказує час очікування після першого невдалого запиту перед повторною спробою. Подальші запити повторюються з експоненційною затримкою.
Файл конфігурації webhook використовує формат kubeconfig, щоб вказати віддалену адресу сервісу й облікові дані для підʼєднання до нього.
Пакетна обробка подій
Обидва бекенди, log і webhook, підтримують пакетну обробку. Нижче наведено перелік доступних прапорців для кожного бекенду. Стандартно пакетну обробку й тротлінг увімкнено для бекенду webhook і вимкнено для бекенду log.
--audit-webhook-mode визначає стратегію буферизації. Можливі значення:
batch — буферизувати події й асинхронно обробляти їх пакетами. Це стандартний режим для бекенду webhook.
blocking — блокувати відповіді API-сервера під час обробки кожної окремої події.
blocking-strict — те саме, що й blocking, але якщо під час логування аудиту на етапі RequestReceived стається збій, увесь запит до kube-apiserver завершується невдачею.
Такі прапорці використовуються лише в режимі batch:
--audit-webhook-batch-buffer-size визначає кількість подій для буферизації перед пакетною обробкою. Якщо швидкість надходження подій переповнює буфер, події відкидаються. Стандартне значення — 10000.
--audit-webhook-batch-max-size визначає максимальну кількість подій в одному пакеті. Стандартне значення — 400.
--audit-webhook-batch-max-wait визначає максимальний час очікування перед безумовною пакетною обробкою подій у черзі. Стандартне значення — 30 секунд.
--audit-webhook-batch-throttle-enable визначає, чи увімкнено тротлінг пакетів. Стандартно тротлінг увімкнено.
--audit-webhook-batch-throttle-qps визначає максимальну середню кількість пакетів, що генеруються за секунду. Стандартне значення — 10.
--audit-webhook-batch-throttle-burst визначає максимальну кількість пакетів, згенерованих у той самий момент, якщо дозволений QPS раніше використовувався не повністю. Стандартне значення — 15.
--audit-log-mode визначає стратегію буферизації. Можливі значення:
batch — буферизувати події й асинхронно обробляти їх пакетами. Пакетна обробка не рекомендується для бекенду log.
blocking — блокувати відповіді API-сервера під час обробки кожної окремої події. Це стандартний режим для бекенду log.
blocking-strict — те саме, що й blocking, але якщо під час логування аудиту на етапі RequestReceived стається збій, увесь запит до kube-apiserver завершується невдачею.
Такі прапорці використовуються лише в режимі batch (стандартно для бекенду log пакетну обробку вимкнено, і коли її вимкнено, усі прапорці, повʼязані з пакетною обробкою, ігноруються):
--audit-log-batch-buffer-size визначає кількість подій для буферизації перед пакетною обробкою. Якщо швидкість надходження подій переповнює буфер, події відкидаються.
--audit-log-batch-max-size визначає максимальну кількість подій в одному пакеті.
--audit-log-batch-max-wait визначає максимальний час очікування перед безумовною пакетною обробкою подій у черзі.
--audit-log-batch-throttle-enable визначає, чи увімкнено тротлінг пакетної обробки.
--audit-log-batch-throttle-qps визначає максимальну середню кількість пакетів, що генеруються за секунду.
--audit-log-batch-throttle-burst визначає максимальну кількість пакетів, згенерованих у той самий момент, якщо дозволений QPS раніше використовувався не повністю.
Налаштування параметрів
Параметри слід задавати з урахуванням навантаження на API-сервер.
Наприклад, якщо kube-apiserver отримує 100 запитів щосекунди і кожен запит проходить аудит лише на етапах ResponseStarted і ResponseComplete, слід розраховувати на ≅200 подій аудиту щосекунди. Якщо в пакеті до 100 подій, рівень тротлінгу слід встановити щонайменше 2 запити на секунду. Якщо бекенду може знадобитися до 5 секунд для запису подій, розмір буфера слід встановити так, щоб він вміщував події за 5 секунд, тобто 10 пакетів або 1000 подій.
Однак у більшості випадків стандартних параметрів має бути достатньо, і вам не потрібно задавати їх вручну. Щоб відстежувати стан підсистеми аудиту, можна переглядати такі метрики Prometheus, які надає kube-apiserver, а також логи.
Метрика apiserver_audit_event_total містить загальну кількість експортованих подій аудиту.
Метрика apiserver_audit_error_total містить загальну кількість подій, відкинутих через помилку під час експорту.
Обрізання записів логу
Обидва бекенди, логів і webhook, підтримують обмеження розміру подій, що записуються. Наприклад, ось перелік прапорців, доступних для бекенду логів:
audit-log-truncate-enabled — чи ввімкнено обрізання подій і пакетів.
audit-log-truncate-max-batch-size — максимальний розмір у байтах пакета, що надсилається до базового бекенду.
audit-log-truncate-max-event-size — максимальний розмір у байтах події аудиту, що надсилається до базового бекенду.
Стандартно обрізання вимкнено і для webhook, і для log; щоб увімкнути цю можливість, адміністратор кластера має встановити audit-log-truncate-enabled або audit-webhook-truncate-enabled.
Дізнайтеся більше про типи ресурсів Event і Policy з довідника конфігурації аудиту.
4.4.5 - Розробка та налагодження сервісів локально за допомогою telepresence
Примітка: Цей розділ містить посилання на проєкти сторонніх розробників, які надають функціонал, необхідний для Kubernetes. Автори проєкту Kubernetes не несуть відповідальності за ці проєкти. Проєкти вказано в алфавітному порядку. Щоб додати проєкт до цього списку, ознайомтеся з посібником з контенту перед надсиланням змін. Докладніше.
Застосунки Kubernetes зазвичай складаються з кількох окремих сервісів, кожен з яких працює у власному контейнері. Розробляти й налагоджувати ці сервіси у віддаленому кластері Kubernetes може бути незручно, бо для запуску інструментів налагодження потрібно отримати доступ до оболонки запущеного контейнера.
telepresence — це інструмент, що спрощує локальну розробку й налагодження сервісів, проксіюючи сервіс до віддаленого кластера Kubernetes. telepresence дає змогу використовувати для локального сервісу власні інструменти, як-от налагоджувач та IDE, і надає сервісу повний доступ до ConfigMap, Secrets і сервісів, що працюють у віддаленому кластері.
У цьому документі описано, як використовувати telepresence для локальної розробки й налагодження сервісів, що працюють у віддаленому кластері.
Підʼєднання вашого локального компʼютера до віддаленого кластера Kubernetes
Після встановлення telepresence виконайте telepresence connect, щоб запустити його демон і підʼєднати вашу локальну робочу станцію до кластера.
$ telepresence connect
Launching Telepresence Daemon
...
Connected to context default (https://<cluster public IP>)
Ви можете звертатися до сервісів командою curl, використовуючи синтаксис Kubernetes, наприклад curl -ik https://kubernetes.default
Розробка або налагодження наявного сервісу
Під час розробки застосунку в Kubernetes ви зазвичай програмуєте або налагоджуєте один сервіс. Цьому сервісу може знадобитися доступ до інших сервісів для тестування й налагодження. Один із варіантів — використовувати конвеєр безперервного розгортання, але навіть найшвидший конвеєр розгортання додає затримку в цикл програмування чи налагодження.
Використовуйте команду telepresence intercept $SERVICE_NAME --port $LOCAL_PORT:$REMOTE_PORT, щоб створити «перехоплення» (intercept) для перенаправлення трафіку віддаленого сервісу.
Де:
$SERVICE_NAME — це назва вашого локального сервісу
$LOCAL_PORT — це порт, на якому ваш сервіс працює на вашій локальній робочій станції
$REMOTE_PORT — це порт, який ваш сервіс слухає в кластері
Ця команда вказує Telepresence надсилати віддалений трафік на ваш локальний сервіс замість сервісу у віддаленому кластері Kubernetes. Вносьте зміни у вихідний код сервісу локально, зберігайте їх, і відповідні зміни одразу набиратимуть чинності під час доступу до віддаленого застосунку. Ви також можете запускати локальний сервіс за допомогою налагоджувача чи будь-якого іншого локального інструмента розробки.
Як працює Telepresence?
Telepresence встановлює sidecar traffic-agent поруч із контейнером вашого наявного застосунку, що працює у віддаленому кластері. Потім він перехоплює всі запити трафіку, що надходять до Podʼа, і замість того, щоб пересилати їх застосунку у віддаленому кластері, спрямовує весь трафік (коли ви створюєте глобальне перехоплення) або його частину (коли ви створюєте персональне перехоплення) до вашого локального середовища розробки.
Що далі
Якщо вас цікавить практичний навчальний матеріал, перегляньте цей навчальний матеріал, у якому покроково описано локальну розробку застосунку Guestbook на Google Kubernetes Engine.
4.4.6 - Усунення несправностей керування топологією
Kubernetes приховує від користувача багато аспектів того, як Podʼи виконуються на вузлах. Це зроблено навмисно. Однак деяким робочим навантаженням для прийнятної роботи потрібні сильніші гарантії щодо затримки та/або продуктивності. kubelet надає методи для складніших політик розміщення робочих навантажень і водночас зберігає абстракцію вільною від явних директив розміщення.
Ви можете керувати топологією всередині вузлів. Це означає, що ви допомагаєте kubelet налаштувати операційну систему хоста так, щоб Podʼи й контейнери розміщувалися з правильного боку внутрішніх меж, таких як домени NUMA. (NUMA — абревіатура від non-uniform memory access (нерівномірний доступ до памʼяті); вона відображає ідею, що CPU можуть бути топологічно ближчими до певних ділянок памʼяті через фізичне розташування апаратних компонентів і спосіб їх зʼєднання.)
Джерела інформації для усунення несправностей
Щоб зʼясувати, чому Pod не вдалося розгорнути або чому його відхилено на вузлі в контексті керування топологією, можна скористатися такими засобами:
Статус Podʼа — показує помилки спорідненості топології
Системні логи — містять цінну інформацію для налагодження, наприклад, про згенеровані підказки
Файл стану kubelet — дамп внутрішнього стану менеджера памʼяті (включно з мапою вузлів і мапами памʼяті)
Ви можете використовувати API ресурсів втулка пристрою для отримання інформації про памʼять, зарезервовану для контейнерів
Усунення несправностей TopologyAffinityError
Ця помилка зазвичай виникає в таких ситуаціях:
вузол не має достатньо доступних ресурсів, щоб задовольнити запит Podʼа
запит Podʼа відхилено через обмеження певної політики менеджера топології
Помилка зʼявляється в статусі Podʼа:
kubectl get pods
NAME READY STATUS RESTARTS AGE
guaranteed 0/1 TopologyAffinityError 0 113s
Використовуйте kubectl describe pod <id> або kubectl events, щоб отримати детальне повідомлення про помилку:
Warning TopologyAffinityError 10m kubelet, dell8 Resources cannot be allocated with Topology locality
Перегляньте системні логи
Шукайте в системних логах записи щодо конкретного Podʼа.
Набір підказок, згенерованих менеджером CPU, має бути в логах. Також у логах можна знайти набір підказок, які менеджер памʼяті згенерував для Podʼа.
Менеджер топології обʼєднує ці підказки, щоб обчислити одну найкращу підказку. Найкраща підказка також має бути в логах.
Найкраща підказка вказує, де виділити всі ресурси. Менеджер топології перевіряє цю підказку на відповідність своїй поточній політиці й, залежно від результату, або допускає Pod на вузол, або відхиляє його.
Також шукайте в логах записи, повʼязані з менеджером памʼяті, наприклад, щоб знайти інформацію про оновлення cgroups і cpuset.mems.
Приклади
Перевірка стану менеджера памʼяті на вузлі
Спочатку розгорнімо зразковий Pod Guaranteed з такою специфікацією:
З файлу стану можна зробити висновок, що Pod закріплено за обома вузлами NUMA, тобто:
"numaAffinity":[0,1],
Термін «закріплений» означає, що споживання памʼяті Podʼом обмежено (через конфігурацію cgroups) цими вузлами NUMA.
Це автоматично означає, що менеджер памʼяті створив нову групу з цих двох вузлів NUMA, тобто вузлів NUMA з індексами 0 і 1.
Щоб проаналізувати ресурси памʼяті, доступні в групі, потрібно підсумувати відповідні записи з вузлів NUMA, що належать до групи.
Наприклад, загальний обсяг вільної «звичайної» памʼяті в групі можна обчислити, додавши вільну памʼять, доступну на кожному вузлі NUMA групи, тобто в розділі "memory" вузла NUMA 0 ("free":0) і вузла NUMA 1 ("free":103739236352). Отже, загальний обсяг вільної «звичайної» памʼяті в цій групі дорівнює 0 + 103739236352 байтів.
Рядок "systemReserved":3221225472 показує, що адміністратор цього вузла зарезервував 3221225472 байти (тобто 3Gi) для kubelet і системних процесів на вузлі NUMA 0 за допомогою прапорця --reserved-memory.
Перевірка API ресурсів втулка пристрою
kubelet надає gRPC-сервіс PodResourceLister, щоб уможливити виявлення ресурсів і повʼязаних з ними метаданих. Через його точку доступу gRPC List можна отримати інформацію про зарезервовану памʼять для кожного контейнера, яка міститься в повідомленні protobuf ContainerMemory.
Цю інформацію можна отримати лише для Podʼів класу QoS Guaranteed.
4.4.7 - Поради щодо налагодження Windows
Усунення несправностей на рівні вузла
Мої Podʼи застрягли в стані "Container Creating" або постійно перезапускаються
Переконайтеся, що ваш образ pause сумісний з версією вашої ОС Windows. Дивіться Контейнер pause, щоб дізнатися про найновіший / рекомендований образ pause та/або отримати більше інформації.
Примітка:
Якщо ви використовуєте containerd як середовище виконання контейнерів, образ pause вказується в полі plugins.plugins.cri.sandbox_image файлу конфігурації config.toml.
Мої Podʼи показують статус ErrImgPull або ImagePullBackOff
Переконайтеся, що ваш Pod планується на сумісний вузол Windows.
Додаткову інформацію про те, як вказати сумісний вузол для вашого Podʼа, можна знайти в
цьому посібнику.
Усунення несправностей мережі
Мої Podʼи Windows не мають мережевого зʼєднання
Якщо ви використовуєте віртуальні машини, переконайтеся, що MAC spoofing увімкнено на всіх мережевих адаптерах віртуальних машин.
Мої Podʼи Windows не можуть виконати ping до зовнішніх ресурсів
Для Podʼів Windows не запрограмовано правил вихідного трафіку для протоколу ICMP. Однак TCP/UDP підтримується. Коли потрібно показати зʼєднання з ресурсами за межами кластера, замініть ping <IP> відповідними командами curl <IP>.
Якщо проблеми не зникли, найімовірніше, ваша мережева конфігурація в cni.conf потребує додаткової уваги. Цей статичний файл завжди можна редагувати. Оновлена конфігурація застосовується до всіх нових ресурсів Kubernetes.
Одна з мережевих вимог Kubernetes (дивіться модель Kubernetes) — звʼязок усередині кластера без NAT. Щоб виконати цю вимогу, існує ExceptionList для всього трафіку, до якого ви не хочете застосовувати вихідний NAT. Однак це також означає, що зовнішню IP-адресу, до якої ви звертаєтеся, потрібно вилучити з ExceptionList. Лише тоді трафік з ваших Podʼів Windows буде правильно оброблено SNAT, щоб отримати відповідь із зовнішнього світу. Тож ваш ExceptionList у cni.conf має виглядати так:
"ExceptionList": [
"10.244.0.0/16", # Підмережа кластера
"10.96.0.0/12", # Підмережа Service
"10.127.130.0/24" # Підмережа керування (хоста)
]
Мій вузол Windows не може отримати доступ до Service типу NodePort
Локальний доступ до NodePort із самого вузла не працює. Це відоме обмеження. Доступ до NodePort працює з інших вузлів або із зовнішніх клієнтів.
vNIC і точки доступу HNS контейнерів видаляються
Ця проблема може виникати, коли параметр hostname-override не передається до kube-proxy. Щоб її розвʼязати, користувачам потрібно передати kube-proxy імʼя хоста так:
Мій вузол Windows не може отримати доступ до моїх Service за IP-адресою Service
Це відоме обмеження мережевого стека Windows. Однак Podʼи Windows можуть звертатися до IP-адреси Service.
Під час запуску kubelet не знайдено мережевого адаптера
Мережевому стеку Windows потрібен віртуальний адаптер, щоб мережа Kubernetes працювала. Якщо наведені нижче команди не повертають результатів (в оболонці адміністратора), то створення віртуальної мережі — необхідної передумови для роботи kubelet — не вдалося:
Часто варто змінити параметр InterfaceName скрипту start.ps1, якщо мережевий адаптер хоста називається не "Ethernet". Інакше перегляньте вивід скрипту start-kubelet.ps1, щоб зʼясувати, чи були помилки під час створення віртуальної мережі.
DNS-перетворення не працює належним чином
Перевірте обмеження DNS для Windows у цьому розділі.
kubectl port-forward завершується з помилкою "unable to do port forwarding: wincat not found"
Це реалізовано в Kubernetes 1.15 через додавання wincat.exe до інфраструктурного контейнера pause mcr.microsoft.com/oss/kubernetes/pause:3.6. Обовʼязково використовуйте підтримувану версію Kubernetes. Якщо ви хочете зібрати власний інфраструктурний контейнер pause, обовʼязково додайте до нього wincat.
Встановлення Kubernetes завершується невдачею, бо мій вузол Windows Server розташований за проксі
Якщо ви перебуваєте за проксі, потрібно визначити такі змінні середовища PowerShell:
З Flannel мої вузли мають проблеми після повторного приєднання до кластера
Щоразу, коли раніше видалений вузол знову приєднується до кластера, flannelD намагається призначити вузлу нову підмережу Podʼів. Користувачам слід видалити старі файли конфігурації підмережі Podʼів за такими шляхами:
Flanneld зависає на "Waiting for the Network to be created"
Є чимало повідомлень про цю проблему; найімовірніше, це проблема синхронізації в момент, коли встановлюється IP-адреса керування мережі flannel. Як обхідний шлях, перезапустіть start.ps1 або запустіть його вручну так:
Мої Podʼи Windows не можуть запуститися через відсутність /run/flannel/subnet.env
Це означає, що Flannel не запустився правильно. Можна спробувати перезапустити flanneld.exe або вручну скопіювати файли з /run/flannel/subnet.env на майстрі Kubernetes до C:\run\flannel\subnet.env на робочому вузлі Windows і змінити рядок FLANNEL_SUBNET на інше значення. Наприклад, якщо потрібна підмережа вузла 10.244.4.1/24:
Декларативні та імперативні парадигми взаємодії з API Kubernetes.
5.1 - Декларативне керування обʼєктами Kubernetes за допомогою файлів конфігурації
Обʼєкти Kubernetes можна створювати, оновлювати й видаляти, зберігаючи кілька файлів конфігурації обʼєктів у теці та використовуючи kubectl apply для рекурсивного створення й оновлення цих обʼєктів за потреби. Цей метод зберігає записи, зроблені в живих обʼєктах, без внесення змін назад до файлів конфігурації обʼєктів. kubectl diff також дає змогу попередньо переглянути зміни, які внесе apply.
Вам треба мати кластер Kubernetes, а також інструмент командного рядка kubectl має бути налаштований для роботи з вашим кластером. Рекомендується виконувати ці настанови у кластері, що має щонайменше два вузли, які не виконують роль вузлів управління. Якщо у вас немає кластера, ви можете створити його, за допомогою minikube або використовувати одну з цих пісочниць:
Декларативна конфігурація обʼєктів потребує чіткого розуміння визначень і конфігурації обʼєктів Kubernetes. Прочитайте й виконайте наведені нижче документи, якщо ви ще цього не зробили:
Нижче подано визначення термінів, використаних у цьому документі:
файл конфігурації обʼєкта / файл конфігурації: файл, який визначає конфігурацію обʼєкта Kubernetes. У цій темі показано, як передавати файли конфігурації до kubectl apply. Файли конфігурації зазвичай зберігаються в системі контролю версій, як-от Git.
жива конфігурація обʼєкта / жива конфігурація: живі значення конфігурації обʼєкта, які спостерігає кластер Kubernetes. Вони зберігаються у сховищі кластера Kubernetes, зазвичай etcd.
декларативний записувач конфігурації / декларативний записувач: особа або програмний компонент, що вносить оновлення до живого обʼєкта. Живі записувачі, про яких ідеться в цій темі, змінюють файли конфігурації обʼєктів і запускають kubectl apply, щоб записати зміни.
Як створити обʼєкти
Використовуйте kubectl apply, щоб створити всі обʼєкти, визначені файлами конфігурації у вказаній теці, за винятком тих, що вже існують:
kubectl apply -f <directory>
Це встановлює анотацію kubectl.kubernetes.io/last-applied-configuration: '{...}' для кожного обʼєкта. Анотація містить вміст файлу конфігурації обʼєкта, який був використаний для створення обʼєкта.
Примітка:
Додайте прапорець -R, щоб рекурсивно обробляти теки.
Оскільки diff виконує запит застосування на стороні сервера в режимі dry-run, для нього потрібно надати дозволи PATCH, CREATE і UPDATE. Докладніше дивіться в розділі Авторизація запуску dry-run.
Виведіть живу конфігурацію за допомогою kubectl get:
kubectl get -f https://k8s.io/examples/application/simple_deployment.yaml -o yaml
Вивід показує, що анотація kubectl.kubernetes.io/last-applied-configuration була записана до живої конфігурації та відповідає файлу конфігурації:
kind:Deploymentmetadata:annotations:# ...# Це json-представлення simple_deployment.yaml# Його записав kubectl apply під час створення обʼєктаkubectl.kubernetes.io/last-applied-configuration:| {"apiVersion":"apps/v1","kind":"Deployment",
"metadata":{"annotations":{},"name":"nginx-deployment","namespace":"default"},
"spec":{"minReadySeconds":5,"selector":{"matchLabels":{"app":nginx}},"template":{"metadata":{"labels":{"app":"nginx"}},
"spec":{"containers":[{"image":"nginx:1.14.2","name":"nginx",
"ports":[{"containerPort":80}]}]}}}}# ...spec:# ...minReadySeconds:5selector:matchLabels:# ...app:nginxtemplate:metadata:# ...labels:app:nginxspec:containers:- image:nginx:1.14.2# ...name:nginxports:- containerPort:80# ...# ...# ...# ...
Як оновити обʼєкти
Ви також можете використовувати kubectl apply, щоб оновити всі обʼєкти, визначені в теці, навіть якщо ці обʼєкти вже існують. Цей підхід робить таке:
Встановлює в живій конфігурації поля, що є у файлі конфігурації.
Очищає в живій конфігурації поля, вилучені з файлу конфігурації.
Для наочності наведена вище команда посилається на один файл конфігурації, а не на теку.
Виведіть живу конфігурацію за допомогою kubectl get:
kubectl get -f https://k8s.io/examples/application/simple_deployment.yaml -o yaml
Вивід показує, що анотація kubectl.kubernetes.io/last-applied-configuration була записана до живої конфігурації та відповідає файлу конфігурації:
kind:Deploymentmetadata:annotations:# ...# Це json-представлення simple_deployment.yaml# Його записав kubectl apply під час створення обʼєктаkubectl.kubernetes.io/last-applied-configuration:| {"apiVersion":"apps/v1","kind":"Deployment",
"metadata":{"annotations":{},"name":"nginx-deployment","namespace":"default"},
"spec":{"minReadySeconds":5,"selector":{"matchLabels":{"app":nginx}},"template":{"metadata":{"labels":{"app":"nginx"}},
"spec":{"containers":[{"image":"nginx:1.14.2","name":"nginx",
"ports":[{"containerPort":80}]}]}}}}# ...spec:# ...minReadySeconds:5selector:matchLabels:# ...app:nginxtemplate:metadata:# ...labels:app:nginxspec:containers:- image:nginx:1.14.2# ...name:nginxports:- containerPort:80# ...# ...# ...# ...
Оновіть поле replicas безпосередньо в живій конфігурації за допомогою kubectl scale. Тут kubectl apply не використовується:
Виведіть живу конфігурацію за допомогою kubectl get:
kubectl get deployment nginx-deployment -o yaml
Вивід показує, що поле replicas встановлено на 2, і анотація last-applied-configuration
не містить поле replicas:
apiVersion:apps/v1kind:Deploymentmetadata:annotations:# ...# зверніть увагу, що анотація не містить replicas# оскільки це поле не оновлювалося через applykubectl.kubernetes.io/last-applied-configuration:| {"apiVersion":"apps/v1","kind":"Deployment",
"metadata":{"annotations":{},"name":"nginx-deployment","namespace":"default"},
"spec":{"minReadySeconds":5,"selector":{"matchLabels":{"app":nginx}},"template":{"metadata":{"labels":{"app":"nginx"}},
"spec":{"containers":[{"image":"nginx:1.14.2","name":"nginx",
"ports":[{"containerPort":80}]}]}}}}# ...spec:replicas:2# записано командою scale# ...minReadySeconds:5selector:matchLabels:# ...app:nginxtemplate:metadata:# ...labels:app:nginxspec:containers:- image:nginx:1.14.2# ...name:nginxports:- containerPort:80# ...
Оновіть файл конфігурації simple_deployment.yaml, щоб змінити образ з nginx:1.14.2 на nginx:1.16.1 та видалити поле minReadySeconds:
Виведіть живу конфігурацію за допомогою kubectl get:
kubectl get -f https://k8s.io/examples/application/update_deployment.yaml -o yaml
Вивід показує такі зміни в живій конфігурації:
Поле replicas зберігає значення 2, встановлене kubectl scale. Це можливо, бо воно відсутнє у файлі конфігурації.
Поле image оновлено з nginx:1.14.2 до nginx:1.16.1.
Анотацію last-applied-configuration оновлено новим образом.
Поле minReadySeconds очищено.
Анотація last-applied-configuration більше не містить поле minReadySeconds.
apiVersion:apps/v1kind:Deploymentmetadata:annotations:# ...# Анотація містить оновлений образ nginx 1.16.1,# але не містить оновлення replicas до 2kubectl.kubernetes.io/last-applied-configuration:| {"apiVersion":"apps/v1","kind":"Deployment",
"metadata":{"annotations":{},"name":"nginx-deployment","namespace":"default"},
"spec":{"selector":{"matchLabels":{"app":nginx}},"template":{"metadata":{"labels":{"app":"nginx"}},
"spec":{"containers":[{"image":"nginx:1.16.1","name":"nginx",
"ports":[{"containerPort":80}]}]}}}}# ...spec:replicas:2# Встановлено за допомогою `kubectl scale`. Ігнорується `kubectl apply`.# minReadySeconds очищено за допомогою `kubectl apply`# ...selector:matchLabels:# ...app:nginxtemplate:metadata:# ...labels:app:nginxspec:containers:- image:nginx:1.16.1# Встановлено за допомогою `kubectl apply`# ...name:nginxports:- containerPort:80# ...# ...# ...# ...
Попередження:
Поєднання kubectl apply з командами імперативної конфігурації обʼєктів create і replace не підтримується. Це тому, що create і replace не зберігають kubectl.kubernetes.io/last-applied-configuration, який kubectl apply використовує для обчислення оновлень.
Як видалити обʼєкти
Існують два підходи до видалення обʼєктів, керованих за допомогою kubectl apply.
Рекомендований: kubectl delete -f <filename>
Рекомендований підхід — видаляти обʼєкти вручну за допомогою імперативної команди, оскільки так явніше видно, що саме видаляється, і менша ймовірність, що користувач випадково щось видалить:
Як альтернативу kubectl delete, ви можете використовувати kubectl apply для ідентифікації обʼєктів, які мають бути видалені після видалення їх маніфестів з теки у локальній файловій системі.
У Kubernetes 1.37 у kubectl apply доступні два режими очищення:
Очищення на основі allowlist: цей режим існує з kubectl v1.5, але досі перебуває на етапі альфа через проблеми зі зручністю використання, коректністю та продуктивністю його дизайну. Режим на основі ApplySet призначений для його заміни.
Очищення на основі ApplySet: apply set — це обʼєкт на стороні сервера (стандартно Secret), який kubectl може використовувати для точного й ефективного відстеження членства в наборі під час операцій apply. Цей режим зʼявився як альфа у kubectl v1.27 на заміну очищенню на основі allowlist.
СТАН ФУНКЦІОНАЛУ:Alpha since Kubernetes v1.5
Попередження:
Будьте обережні, використовуючи --prune з kubectl apply у режимі allowlist. Те, які обʼєкти очищаються, залежить від значень прапорців --prune-allowlist, --selector і --namespace та ґрунтується на динамічному виявленні обʼєктів в області дії. Особливо якщо значення прапорців змінюються між викликами, це може призвести до неочікуваного видалення або збереження обʼєктів.
Щоб використовувати очищення на основі allowlist, додайте такі прапорці до виклику kubectl apply:
--prune: видалити раніше застосовані обʼєкти, яких немає в наборі, переданому поточному виклику.
--prune-allowlist: список груп-версій-типів (GVK) для розгляду під час очищення. Цей прапорець необовʼязковий, але наполегливо рекомендований, оскільки його стандартне значення — це частковий список типів як у просторах імен, так і в області кластера, що може призвести до несподіваних результатів.
--selector/-l: використовуйте селектор міток, щоб обмежити набір обʼєктів, вибраних для очищення. Цей прапорець необовʼязковий, але наполегливо рекомендований.
--all: використовуйте замість --selector/-l, щоб явно вибрати всі раніше застосовані обʼєкти типів зі списку дозволених.
Очищення на основі allowlist запитує в API-сервера всі обʼєкти дозволених GVK, що відповідають заданим міткам (якщо такі є), і намагається зіставити отримані живі конфігурації обʼєктів із файлами маніфестів обʼєктів. Якщо обʼєкт відповідає запиту, не має маніфесту в теці та має анотацію kubectl.kubernetes.io/last-applied-configuration, його буде видалено.
Apply із prune слід виконувати лише для кореневої теки, що містить маніфести обʼєктів. Виконання для підтек може призвести до ненавмисного видалення обʼєктів, які раніше були застосовані, мають задані мітки (якщо є) і не зʼявляються в підтеці.
СТАН ФУНКЦІОНАЛУ:Alpha since Kubernetes v1.27
Увага:
kubectl apply --prune --applyset перебуває на етапі альфа, і в наступних випусках можуть зʼявитися несумісні зміни.
Щоб використовувати очищення на основі ApplySet, встановіть змінну середовища KUBECTL_APPLYSET=true і додайте такі прапорці до виклику kubectl apply:
--prune: видалити раніше застосовані обʼєкти, яких немає в наборі, переданому поточному виклику.
--applyset: назва обʼєкта, який kubectl може використовувати для точного й ефективного відстеження членства в наборі під час операцій apply.
Стандартно тип батьківського обʼєкта ApplySet — Secret. Однак також можна використовувати ConfigMaps у форматі --applyset=configmaps/<name>. Якщо використовується Secret або ConfigMap, kubectl створить обʼєкт, якщо його ще немає.
Також можна використовувати власні ресурси як батьківські обʼєкти ApplySet. Для цього додайте до Custom Resource Definition (CRD), що визначає потрібний ресурс, мітку applyset.kubernetes.io/is-parent-type: true. Потім створіть обʼєкт, який ви хочете використовувати як батьківський обʼєкт ApplySet (kubectl не робить цього автоматично для власних ресурсів). Нарешті, посилайтеся на цей обʼєкт у прапорці applyset так: --applyset=<resource>.<group>/<name> (наприклад, widgets.custom.example.com/widget-name).
Під час очищення на основі ApplySet kubectl додає мітку applyset.kubernetes.io/part-of=<parentID> до кожного обʼєкта в наборі перед надсиланням на сервер. З міркувань продуктивності він також збирає список типів ресурсів і просторів імен, що містить набір, і додає їх в анотації живого батьківського обʼєкта. Нарешті, наприкінці операції apply він запитує в API-сервера обʼєкти цих типів у цих просторах імен (або в області кластера, якщо потрібно), що належать до набору, визначеного міткою applyset.kubernetes.io/part-of=<parentID>.
Застереження та обмеження:
Кожен обʼєкт може бути членом не більше одного набору.
Прапорець --namespace обовʼязковий під час використання будь-якого батьківського обʼєкта в просторі імен, зокрема стандартного Secret. Це означає, що ApplySets, які охоплюють кілька просторів імен, мають використовувати як батьківський обʼєкт власний ресурс в області кластера.
Щоб безпечно використовувати очищення на основі ApplySet з кількома теками, використовуйте унікальну назву ApplySet для кожної.
Як переглянути обʼєкт
Ви можете використовувати kubectl get з -o yaml, щоб переглянути конфігурацію живого обʼєкта:
kubectl get -f <filename|url> -o yaml
Як apply обчислює різницю та обʼєднує зміни
Увага:
Патч — це операція оновлення, обмежена конкретними полями обʼєкта, а не всім обʼєктом. Це дає змогу оновлювати лише певний набір полів обʼєкта без попереднього читання обʼєкта.
Коли kubectl apply оновлює живу конфігурацію обʼєкта, він робить це, надсилаючи запит на патч до API-сервера. Патч визначає оновлення для конкретних полів конфігурації живого обʼєкта. Команда kubectl apply обчислює цей запит на патч за допомогою файлу конфігурації, живої конфігурації та анотації last-applied-configuration, збереженої в живій конфігурації.
Обчислення merge patch
Команда kubectl apply записує вміст файлу конфігурації до анотації kubectl.kubernetes.io/last-applied-configuration. Вона використовується для визначення полів, які було вилучено з файлу конфігурації й потрібно очистити з живої конфігурації. Ось кроки для обчислення того, які поля слід видалити або встановити:
Обчислити поля для видалення. Це поля, які присутні в last-applied-configuration та відсутні у файлі конфігурації.
Обчислити поля для додавання або встановлення. Це поля, які присутні у файлі конфігурації, значення яких не відповідають живій конфігурації.
Ось приклад. Припустимо, що це файл конфігурації для обʼєкта Deployment:
apiVersion:apps/v1kind:Deploymentmetadata:name:nginx-deploymentspec:selector:matchLabels:app:nginxtemplate:metadata:labels:app:nginxspec:containers:- name:nginximage:nginx:1.16.1# update the imageports:- containerPort:80
Також, припустимо, що це жива конфігурація для того самого обʼєкта Deployment:
apiVersion:apps/v1kind:Deploymentmetadata:annotations:# ...# зверніть увагу, що анотація не містить replicas# оскільки це поле не оновлювалося через applykubectl.kubernetes.io/last-applied-configuration:| {"apiVersion":"apps/v1","kind":"Deployment",
"metadata":{"annotations":{},"name":"nginx-deployment","namespace":"default"},
"spec":{"minReadySeconds":5,"selector":{"matchLabels":{"app":nginx}},"template":{"metadata":{"labels":{"app":"nginx"}},
"spec":{"containers":[{"image":"nginx:1.14.2","name":"nginx",
"ports":[{"containerPort":80}]}]}}}}# ...spec:replicas:2# записано командою scale# ...minReadySeconds:5selector:matchLabels:# ...app:nginxtemplate:metadata:# ...labels:app:nginxspec:containers:- image:nginx:1.14.2# ...name:nginxports:- containerPort:80# ...
Ось обчислення злиття, які виконає kubectl apply:
Обчислити поля для видалення, прочитавши значення з last-applied-configuration і порівнявши їх зі значеннями у файлі конфігурації. Очистити поля, явно встановлені в null у локальному файлі конфігурації обʼєкта, незалежно від того, чи є вони в last-applied-configuration. У цьому прикладі minReadySeconds є в анотації last-applied-configuration, але немає у файлі конфігурації. Дія: очистити minReadySeconds у живій конфігурації.
Обчислити поля для встановлення, прочитавши значення з файлу конфігурації й порівнявши їх зі значеннями в живій конфігурації. У цьому прикладі значення image у файлі конфігурації не збігається зі значенням у живій конфігурації. Дія: встановити значення image у живій конфігурації.
Встановити анотацію last-applied-configuration, щоб вона відповідала значенню файлу конфігурації.
Обʼєднати результати з 1, 2, 3 у єдиний запит на патч до API-сервера.
Ось жива конфігурація, яка є результатом злиття:
apiVersion:apps/v1kind:Deploymentmetadata:annotations:# ...# Анотація містить оновлений образ nginx 1.16.1,# але не містить оновлення replicas до 2kubectl.kubernetes.io/last-applied-configuration:| {"apiVersion":"apps/v1","kind":"Deployment",
"metadata":{"annotations":{},"name":"nginx-deployment","namespace":"default"},
"spec":{"selector":{"matchLabels":{"app":nginx}},"template":{"metadata":{"labels":{"app":"nginx"}},
"spec":{"containers":[{"image":"nginx:1.16.1","name":"nginx",
"ports":[{"containerPort":80}]}]}}}}# ...spec:selector:matchLabels:# ...app:nginxreplicas:2# Встановлено за допомогою `kubectl scale`. Ігнорується `kubectl apply`.# minReadySeconds очищено за допомогою `kubectl apply`# ...template:metadata:# ...labels:app:nginxspec:containers:- image:nginx:1.16.1# Встановлено за допомогою `kubectl apply`# ...name:nginxports:- containerPort:80# ...# ...# ...# ...
Як зливаються поля різних типів
Те, як певне поле у файлі конфігурації зливається з живою конфігурацією, залежить від типу поля. Існує кілька типів полів:
primitive: поле типу рядок, ціле число або логічне значення. Наприклад, image і replicas є полями primitive. Дія: замінити.
map, також званий object: поле типу map або складний тип, що містить підполя. Наприклад, labels, annotations, spec і metadata — це map. Дія: злити елементи або підполя.
list: поле, що містить список елементів, які можуть бути типів primitive або map. Наприклад, containers, ports і args є списками. Дія: залежить від випадку.
Коли kubectl apply оновлює поле map або list, він зазвичай не замінює все поле, а оновлює окремі піделементи. Наприклад, під час злиття spec у Deployment весь spec не замінюється. Натомість порівнюються й зливаються підполя spec, як-от replicas.
Злиття змін для полів типу primitive
Поля primitive замінюються або очищаються.
Примітка:
- використовується для "not applicable", оскільки значення не використовується.
Поле у файлі конфігурації обʼєкта
Поле в живій конфігурації обʼєкта
Поле в last-applied-configuration
Дія
Так
Так
-
Встановити живе значення з файлу конфігурації.
Так
Ні
-
Встановити живе значення з локальної конфігурації.
Ні
-
Так
Очистити з живої конфігурації.
Ні
-
Ні
Нічого не робити. Зберегти живе значення.
Злиття змін у полях типу map
Поля, які є map, зливаються шляхом порівняння кожного з підполів або елементів map:
Примітка:
- використовується для "not applicable", оскільки значення не використовується.
Ключ у файлі конфігурації обʼєкта
Ключ у живій конфігурації обʼєкта
Поле в last-applied-configuration
Дія
Так
Так
-
Порівняти значення підполів.
Так
Ні
-
Встановити живе значення з локальної конфігурації.
Ні
-
Так
Видалити з живої конфігурації.
Ні
-
Ні
Нічого не робити. Зберегти живе значення.
Злиття змін для полів типу list
Злиття змін у list використовує одну з трьох стратегій:
Заміна list, якщо всі його елементи є primitive.
Злиття окремих елементів у списку складних елементів.
Злиття list елементів primitive.
Вибір стратегії залежить від конкретного поля.
Заміна list, якщо всі його елементи є primitive
Список обробляється так само, як поле primitive. Замініть або видаліть увесь список. Це зберігає порядок.
Приклад: Використовуйте kubectl apply, щоб оновити поле args контейнера в Podʼі. Це встановлює значення args в живій конфігурації на значення у файлі конфігурації. Будь-які елементи args, які раніше були додані до живої конфігурації, втрачаються. Порядок елементів args, визначених у файлі конфігурації, зберігається у живій конфігурації.
# Значення last-applied-configurationargs:["a","b"]# Значення файлу конфігураціїargs:["a","c"]# Жива конфігураціяargs:["a","b","d"]# Результат після злиттяargs:["a","c"]
Пояснення: Під час злиття значення з файлу конфігурації використано як нове значення списку.
Злиття окремих елементів списку складних елементів:
Обробляйте список як map, а конкретне поле кожного елемента — як ключ. Додавайте, видаляйте або оновлюйте окремі елементи. Це не зберігає порядок.
Ця стратегія злиття використовує спеціальний теґ кожного поля, який називається patchMergeKey. patchMergeKey визначено для кожного поля у вихідному коді Kubernetes: types.go Під час злиття списку map поле, вказане як patchMergeKey для певного елемента, використовується як ключ map для цього елемента.
Приклад: Використайте kubectl apply, щоб оновити поле containers у PodSpec. Це зливає список так, ніби він є map, у якому ключем кожного елемента є name.
# Значення last-applied-configurationcontainers:- name:nginximage:nginx:1.16- name: nginx-helper-a # ключ:nginx-helper-a; буде видалено в результатіimage:helper:1.3- name: nginx-helper-b # ключ:nginx-helper-b; буде збереженоimage:helper:1.3# Значення файлу конфігураціїcontainers:- name:nginximage:nginx:1.16- name:nginx-helper-bimage:helper:1.3- name: nginx-helper-c # ключ:nginx-helper-c; буде додано в результатіimage:helper:1.3# Жива конфігураціяcontainers:- name:nginximage:nginx:1.16- name:nginx-helper-aimage:helper:1.3- name:nginx-helper-bimage:helper:1.3args:["run"]# Поле буде збережено- name: nginx-helper-d # ключ:nginx-helper-d; буде збереженоimage:helper:1.3# Результат після злиттяcontainers:- name:nginximage:nginx:1.16# Елемент nginx-helper-a видалено- name:nginx-helper-bimage:helper:1.3args:["run"]# Поле збережено- name:nginx-helper-c# Елемент доданоimage:helper:1.3- name:nginx-helper-d# Елемент проігнорованоimage:helper:1.3
Пояснення:
Контейнер з назвою "nginx-helper-a" видалено, оскільки у файлі конфігурації немає контейнера з назвою "nginx-helper-a".
Контейнер з назвою "nginx-helper-b" зберіг зміни в args у живій конфігурації. kubectl apply зміг визначити, що "nginx-helper-b" у живій конфігурації — це той самий "nginx-helper-b", що й у файлі конфігурації, хоча їхні поля мали різні значення (у файлі конфігурації немає args). Це тому, що значення поля patchMergeKey (name) було однаковим в обох.
Контейнер з назвою "nginx-helper-c" додано, оскільки в живій конфігурації не було контейнера з такою назвою, а у файлі конфігурації він був.
Контейнер з назвою "nginx-helper-d" збережено, оскільки в last-applied-configuration не було елемента з такою назвою.
Злиття списку елементів типу primitive
Станом на Kubernetes 1.5 злиття списків елементів типу primitive не підтримується.
Примітка:
Вибір стратегії для певного поля визначається теґом patchStrategy у types.go Якщо для поля типу list не вказано patchStrategy, список замінюється.
Стандартні значення полів
API-сервер встановлює певним полям стандартні значення в живій конфігурації, якщо їх не вказано під час створення обʼєкта.
Ось файл конфігурації для обʼєкта Deployment. У файлі не вказано strategy:
Виведіть живу конфігурацію, використовуючи kubectl get:
kubectl get -f https://k8s.io/examples/application/simple_deployment.yaml -o yaml
Вивід показує, що API-сервер встановив кільком полям стандартні значення в живій конфігурації. Ці поля не було вказано у файлі конфігурації.
apiVersion:apps/v1kind:Deployment# ...spec:selector:matchLabels:app:nginxminReadySeconds:5replicas:1# стандартне значення від apiserverstrategy:rollingUpdate:# стандартне значення від apiserver, виведене з strategy.typemaxSurge:1maxUnavailable:1type:RollingUpdate# стандартне значення від apiservertemplate:metadata:creationTimestamp:nulllabels:app:nginxspec:containers:- image:nginx:1.14.2imagePullPolicy:IfNotPresent# стандартне значення від apiservername:nginxports:- containerPort:80protocol:TCP# стандартне значення від apiserverresources:{}# стандартне значення від apiserverterminationMessagePath:/dev/termination-log# стандартне значення від apiserverdnsPolicy:ClusterFirst# стандартне значення від apiserverrestartPolicy:Always# стандартне значення від apiserversecurityContext:{}# стандартне значення від apiserverterminationGracePeriodSeconds:30# стандартне значення від apiserver# ...
У запиті на патч поля зі стандартними значеннями не отримують стандартні значення повторно, якщо їх явно не очищено в цьому запиті. Це може спричинити неочікувану поведінку полів, стандартні значення яких залежать від інших полів. Коли ці інші поля згодом змінюються, виведені з них значення не оновлюються, якщо їх явно не очистити.
Тому рекомендовано явно визначати у файлі конфігурації певні поля, стандартні значення яких задає сервер, навіть якщо бажані значення збігаються зі стандартними значеннями сервера. Так легше розпізнавати конфліктні значення, які сервер не встановить повторно.
Приклад:
# last-applied-configurationspec:template:metadata:labels:app:nginxspec:containers:- name:nginximage:nginx:1.14.2ports:- containerPort:80# Файл конфігураціїspec:strategy:type:Recreate# оновлене значенняtemplate:metadata:labels:app:nginxspec:containers:- name:nginximage:nginx:1.14.2ports:- containerPort:80# Жива конфігураціяspec:strategy:type:RollingUpdate# стандартне значенняrollingUpdate:# стандартне значення, виведене з typemaxSurge :1maxUnavailable:1template:metadata:labels:app:nginxspec:containers:- name:nginximage:nginx:1.14.2ports:- containerPort:80# Результат після злиття — ПОМИЛКА!spec:strategy:type: Recreate # оновлене значення:несумісне з rollingUpdaterollingUpdate: # стандартне значення:несумісне з "type: Recreate"maxSurge :1maxUnavailable:1template:metadata:labels:app:nginxspec:containers:- name:nginximage:nginx:1.14.2ports:- containerPort:80
Пояснення:
Користувач створює Deployment без визначення strategy.type.
Сервер встановлює для strategy.type стандартне значення RollingUpdate і стандартні значення для strategy.rollingUpdate.
Користувач змінює strategy.type на Recreate. Значення strategy.rollingUpdate лишаються стандартними, хоча сервер очікує, що їх буде очищено. Якби значення strategy.rollingUpdate було спочатку визначено у файлі конфігурації, було б зрозуміліше, що їх потрібно видалити.
Apply завершується збоєм, бо strategy.rollingUpdate не очищено. Поле strategy.rollingupdate не можна визначати, якщо strategy.type дорівнює Recreate.
Рекомендація: ці поля слід явно визначати у файлі конфігурації обʼєкта:
Селектори та мітки PodTemplate робочих навантажень, як-от Deployment, StatefulSet, Job, DaemonSet, ReplicaSet і ReplicationController
Стратегія розгортання Deployment
Як очистити поля зі стандартними значеннями сервера або поля, встановлені іншими записувачами
Поля, яких немає у файлі конфігурації, можна очистити, встановивши їхні значення в null і застосувавши файл конфігурації. Для полів зі стандартними значеннями сервера це повторно встановлює стандартні значення.
Як змінити власника поля між файлом конфігурації та прямими імперативними записувачами
Лише цими методами слід змінювати окреме поле обʼєкта:
Використовуйте kubectl apply.
Записуйте безпосередньо в живу конфігурацію без зміни файлу конфігурації: наприклад, використовуйте kubectl scale.
Зміна власника з прямого імперативного записувача на файл конфігурації
Додайте поле до файлу конфігурації. Для цього поля припиніть прямі оновлення живої конфігурації, які не проходять через kubectl apply.
Зміна власника з файлу конфігурації на безпосереднього імперативного записувача
Станом на Kubernetes 1.5 зміна власника поля з файлу конфігурації на імперативного записувача потребує ручних кроків:
Видаліть поле з файлу конфігурації.
Видаліть поле з анотації kubectl.kubernetes.io/last-applied-configuration на живому обʼєкті.
Зміна методів керування
Обʼєктами Kubernetes слід керувати лише одним методом одночасно. Перехід з одного методу на інший можливий, але виконується вручну.
Примітка:
Можна використовувати імперативне видалення разом із декларативним керуванням.
Міграція з керування імперативними командами на декларативну конфігурацію обʼєктів
Міграція з керування імперативними командами на декларативну конфігурацію обʼєктів складається з кількох ручних кроків:
Експортуйте живий обʼєкт у локальний файл конфігурації:
kubectl get <kind>/<name> -o yaml > <kind>_<name>.yaml
Видаліть вручну поле status з файлу конфігурації.
Примітка:
Цей крок є необовʼязковим, оскільки kubectl apply не оновлює поле статусу, навіть якщо воно присутнє у файлі конфігурації.
Встановіть анотацію kubectl.kubernetes.io/last-applied-configuration на обʼєкті:
Змініть процеси так, щоб для керування обʼєктом використовувався виключно kubectl apply.
Визначення селекторів контролера та міток PodTemplate
Попередження:
Оновлювати селектори контролерів категорично не рекомендовано.
Рекомендований підхід — визначити одну незмінну мітку PodTemplate, яка використовується тільки селектором контролера й не має іншого семантичного значення.
Починаючи з версії 1.14, kubectl також підтримує керування обʼєктами Kubernetes за допомогою файлу kustomization. Щоб переглянути ресурси, знайдені в теці з файлом kustomization, виконайте таку команду:
kubectl kustomize <kustomization_directory>
Щоб застосувати ці ресурси, виконайте kubectl apply із прапорцем --kustomize або -k:
Вам треба мати кластер Kubernetes, а також інструмент командного рядка kubectl має бути налаштований для роботи з вашим кластером. Рекомендується виконувати ці настанови у кластері, що має щонайменше два вузли, які не виконують роль вузлів управління. Якщо у вас немає кластера, ви можете створити його, за допомогою minikube або використовувати одну з цих пісочниць:
Kustomize — це інструмент для налаштування конфігурацій Kubernetes. Він має такі можливості для керування файлами конфігурації застосунків:
генерування ресурсів з інших джерел
встановлення наскрізних полів для ресурсів
компонування та налаштування колекцій ресурсів
Генерування ресурсів
ConfigMaps і Secrets зберігають конфігураційні або конфіденційні дані, які використовуються іншими обʼєктами Kubernetes, наприклад Podʼами. Джерело істини для ConfigMaps або Secrets зазвичай розташоване поза кластером, наприклад це файл .properties або файл ключа SSH. Kustomize має secretGenerator і configMapGenerator, які генерують Secret і ConfigMap із файлів або літералів.
configMapGenerator
Щоб згенерувати ConfigMap з файлу, додайте запис до списку files у configMapGenerator. Ось приклад генерування ConfigMap з елементом даних із файлу .properties:
Щоб згенерувати ConfigMap з файлу env, додайте запис до списку envs у configMapGenerator. Ось приклад генерування ConfigMap з елементом даних із файлу .env:
Кожна змінна у файлі .env стає окремим ключем у згенерованому ConfigMap. Це відрізняється від попереднього прикладу, де файл з назвою application.properties (з усіма його записами) вбудовується як значення одного ключа.
ConfigMaps також можна генерувати з літеральних пар ключ-значення. Щоб згенерувати ConfigMap з літеральної пари ключ-значення, додайте запис до списку literals у configMapGenerator. Ось приклад генерування ConfigMap з елементом даних із пари ключ-значення:
Щоб використати згенерований ConfigMap у Deployment, посилайтеся на нього за назвою configMapGenerator. Kustomize автоматично замінить цю назву згенерованою.
Ось приклад Deployment, що використовує згенерований ConfigMap:
Ви можете генерувати Secrets із файлів або літеральних пар ключ-значення. Щоб згенерувати Secret з файлу, додайте запис до списку files у secretGenerator. Ось приклад генерування Secret з елементом даних із файлу:
Щоб згенерувати Secret з літеральної пари ключ-значення, додайте запис до списку literals у secretGenerator. Ось приклад генерування Secret з елементом даних із пари ключ-значення:
До згенерованих ConfigMaps і Secrets додається суфікс із хешем вмісту. Це гарантує, що під час зміни вмісту генерується новий ConfigMap або Secret. Щоб вимкнути додавання суфікса, можна використати generatorOptions. Крім того, можна вказати наскрізні параметри для згенерованих ConfigMaps і Secrets.
Часто в проєкті компонують набір ресурсів і керують ними в одному файлі чи теці. Kustomize дає змогу компонувати ресурси з різних файлів і застосовувати до них патчі або інші налаштування.
Компонування
Kustomize підтримує компонування різних ресурсів. Поле resources у файлі kustomization.yaml визначає список ресурсів, які слід включити в конфігурацію. Вкажіть шлях до файлу конфігурації ресурсу у списку resources. Ось приклад застосунку NGINX, що складається з Deployment і Service:
Ресурси з kubectl kustomize ./ містять обидва обʼєкти: Deployment і Service.
Налаштування
Патчі можна використовувати для застосування різних налаштувань до ресурсів. Kustomize підтримує різні механізми патчів через StrategicMerge і Json6902 за допомогою поля patches. patches може бути файлом або вбудованим рядком, спрямованим на один або кілька ресурсів.
Поле patches містить список патчів, які застосовуються в порядку їх зазначення. Ціль патча вибирає ресурси за group, version, kind, name, namespace, labelSelector і annotationSelector.
Рекомендовано створювати невеликі патчі, які роблять щось одне. Наприклад, створіть один патч для збільшення кількості реплік Deployment, а інший — для встановлення обмеження памʼяті. Цільовий ресурс визначається за полями group, version, kind і name з файлу патча.
Не всі ресурси чи поля підтримують патчі strategicMerge. Для зміни довільних полів у довільних ресурсах Kustomize пропонує застосування JSON patch через Json6902. Щоб знайти правильний ресурс для патча Json6902, обовʼязково потрібно вказати поле target у файлі kustomization.yaml.
Наприклад, збільшити кількість реплік обʼєкта Deployment можна також за допомогою патча Json6902. Цільовий ресурс визначається за group, version, kind і name з поля target.
Крім патчів, Kustomize також дає змогу налаштовувати образи контейнерів або вставляти значення полів з інших обʼєктів у контейнери без створення патчів. Наприклад, можна змінити образ, що використовується в контейнерах, вказавши новий образ у полі images у kustomization.yaml.
Іноді застосунку, що працює в Podʼі, потрібні значення конфігурації з інших обʼєктів. Наприклад, Pod з обʼєкта Deployment має прочитати відповідну назву Service зі змінної середовища або з аргументу команди. Оскільки назва Service може змінюватися, коли у файлі kustomization.yaml додається namePrefix або nameSuffix, не рекомендовано жорстко задавати назву Service в аргументі команди. Для цього Kustomize може вставити назву Service у контейнери через replacements.
У Kustomize є поняття base і overlay. Base — це тека з файлом kustomization.yaml, яка містить набір ресурсів і повʼязані налаштування. Base може бути локальною текою або текою з віддаленого репозиторію, якщо всередині є файл kustomization.yaml. Overlay — це тека з файлом kustomization.yaml, яка посилається на інші теки kustomization як на свої bases. Base нічого не знає про overlay і може використовуватися в кількох overlay.
Файл kustomization.yaml у теці overlay може посилатися на кілька bases, обʼєднуючи всі ресурси, визначені в цих base, в єдину конфігурацію. Крім того, він може застосовувати налаштування поверх цих ресурсів для задоволення певних вимог.
Цей base можна використовувати в кількох overlay. Ви можете додавати різні namePrefix або інші наскрізні поля в різних overlay. Ось два overlay, які використовують той самий base.
Як застосовувати, переглядати й видаляти обʼєкти за допомогою Kustomize
Використовуйте --kustomize або -k у командах kubectl, щоб розпізнавати ресурси, якими керує kustomization.yaml. Зверніть увагу, що -k має вказувати на теку kustomization, наприклад,
5.3 - Керування обʼєктами Kubernetes за допомогою імперативних команд
Обʼєкти Kubernetes можна швидко створювати, оновлювати й видаляти безпосередньо за допомогою імперативних команд, вбудованих в інструмент командного рядка kubectl. У цьому документі пояснено, як організовано ці команди та як їх використовувати для керування живими обʼєктами.
Вам треба мати кластер Kubernetes, а також інструмент командного рядка kubectl має бути налаштований для роботи з вашим кластером. Рекомендується виконувати ці настанови у кластері, що має щонайменше два вузли, які не виконують роль вузлів управління. Якщо у вас немає кластера, ви можете створити його, за допомогою minikube або використовувати одну з цих пісочниць:
Інструмент kubectl підтримує команди на основі дієслів для створення деяких найпоширеніших типів обʼєктів. Команди названо так, щоб їх могли розпізнати користувачі, не знайомі з типами обʼєктів Kubernetes.
run: створює новий Pod для запуску контейнера.
expose: створює новий обʼєкт Service для балансування трафіку між Podʼами.
autoscale: створює новий обʼєкт Autoscaler для автоматичного горизонтального масштабування контролера, наприклад Deployment.
Інструмент kubectl також підтримує команди створення на основі типу обʼєкта. Ці команди підтримують більше типів обʼєктів і чіткіше виражають свій намір, але вимагають, щоб користувачі знали тип обʼєктів, які вони мають намір створити.
create <objecttype> [<subtype>] <instancename>
Деякі типи обʼєктів мають підтипи, які можна вказати в команді create. Наприклад, обʼєкт Service має кілька підтипів, зокрема ClusterIP, LoadBalancer і NodePort. Ось приклад створення Service з підтипом NodePort:
kubectl create service nodeport <myservicename>
У наведеному вище прикладі команда create service nodeport називається підкомандою команди create service.
Ви можете використати прапорець -h, щоб знайти аргументи й прапорці, які підтримує підкоманда:
kubectl create service nodeport -h
Як оновлювати обʼєкти
Команда kubectl підтримує команди на основі дієслів для деяких поширених операцій оновлення. Ці команди названо так, щоб користувачі, не знайомі з обʼєктами Kubernetes, могли виконувати оновлення, не знаючи конкретних полів, які потрібно встановити:
scale: горизонтально масштабувати контролер, щоб додати або вилучити Podʼи, оновивши кількість реплік контролера.
annotate: додати анотацію до обʼєкта або вилучити її.
label: додати мітку до обʼєкта або вилучити її.
Команда kubectl також підтримує команди оновлення на основі аспекту обʼєкта. Встановлення цього аспекту може встановлювати різні поля для різних типів обʼєктів:
set<field>: встановити аспект обʼєкта.
Примітка:
У версії Kubernetes 1.5 не кожна команда на основі дієслова має відповідну команду на основі аспекту.
Інструмент kubectl підтримує ці додаткові способи безпосереднього оновлення живого обʼєкта, однак вони вимагають кращого розуміння схеми обʼєктів Kubernetes.
edit: безпосередньо редагувати необроблену конфігурацію живого обʼєкта, відкриваючи її в редакторі.
patch: безпосередньо змінювати конкретні поля живого обʼєкта за допомогою рядка патча. Докладніше про рядки патча дивіться в розділі про патчі в API Conventions.
Як видаляти обʼєкти
Ви можете використовувати команду delete, щоб видалити обʼєкт з кластера:
delete <type>/<name>
Примітка:
Ви можете використовувати kubectl delete як для імперативних команд, так і для імперативного конфігурування обʼєктів. Різниця полягає в аргументах, переданих команді. Щоб використати kubectl delete як імперативну команду, передайте обʼєкт для видалення як аргумент. Ось приклад, який передає обʼєкт Deployment з назвою nginx:
kubectl delete deployment/nginx
Як переглянути обʼєкт
Існує кілька команд для виведення інформації про обʼєкт:
get: виводить базову інформацію про відповідні обʼєкти. Використайте get -h, щоб побачити список параметрів.
describe: виводить агреговану детальну інформацію про відповідні обʼєкти.
logs: виводить stdout і stderr контейнера, що працює в Podʼі.
Використання команд set для модифікації обʼєктів перед створенням
Деякі поля обʼєктів не мають прапорця, який можна використати в команді create. У деяких із цих випадків можна використати комбінацію set і create, щоб вказати значення поля перед створенням обʼєкта. Для цього вивід команди create передається через канал до команди set, а потім назад до команди create. Ось приклад:
Команда kubectl create service -o yaml --dry-run=client створює конфігурацію для Service, але виводить її в stdout у форматі YAML замість надсилання до API-сервера Kubernetes.
Команда kubectl set selector --local -f - -o yaml читає конфігурацію зі stdin і записує оновлену конфігурацію в stdout у форматі YAML.
Команда kubectl create -f - створює обʼєкт, використовуючи конфігурацію, отриману через stdin.
Використання --edit для модифікації обʼєктів перед створенням
Можна використати kubectl create --edit, щоб внести довільні зміни в обʼєкт перед його створенням. Ось приклад:
5.4 - Імперативне керування обʼєктами Kubernetes за допомогою файлів конфігурації
Обʼєкти Kubernetes можна створювати, оновлювати й видаляти за допомогою інструмента командного рядка kubectl разом із файлом конфігурації обʼєкта у форматі YAML або JSON. У цьому документі пояснено, як визначати обʼєкти й керувати ними за допомогою файлів конфігурації.
Вам треба мати кластер Kubernetes, а також інструмент командного рядка kubectl має бути налаштований для роботи з вашим кластером. Рекомендується виконувати ці настанови у кластері, що має щонайменше два вузли, які не виконують роль вузлів управління. Якщо у вас немає кластера, ви можете створити його, за допомогою minikube або використовувати одну з цих пісочниць:
Ви можете використовувати kubectl create -f, щоб створити обʼєкт з файлу конфігурації. Докладніше дивіться в довіднику API Kubernetes.
kubectl create -f <filename|url>
Як оновити обʼєкти
Попередження:
Оновлення обʼєктів за допомогою команди replace вилучає всі частини специфікації, не вказані у файлі конфігурації. Цю команду не слід використовувати з обʼєктами, чиї специфікації частково керуються кластером, наприклад із Services типу LoadBalancer, де поле externalIPs керується незалежно від файлу конфігурації. Поля, що керуються незалежно, потрібно скопіювати у файл конфігурації, щоб replace не вилучив їх.
Ви можете використовувати kubectl replace -f, щоб оновити живий обʼєкт відповідно до файлу конфігурації.
kubectl replace -f <filename|url>
Як видалити обʼєкти
Ви можете використовувати kubectl delete -f, щоб видалити обʼєкт, описаний у файлі конфігурації.
kubectl delete -f <filename|url>
Примітка:
Якщо файл конфігурації задає поле generateName у розділі metadata замість поля name, ви не можете видалити обʼєкт за допомогою kubectl delete -f <filename|url>. Для видалення обʼєкта доведеться використати інші прапорці. Наприклад:
Ви можете використовувати kubectl get -f, щоб переглянути інформацію про обʼєкт, описаний у файлі конфігурації.
kubectl get -f <filename|url> -o yaml
Прапорець -o yaml вказує, що треба вивести повну конфігурацію обʼєкта. Використайте kubectl get -h, щоб побачити список параметрів.
Обмеження
Команди create, replace і delete добре працюють, коли конфігурація кожного обʼєкта повністю визначена й записана в його файлі конфігурації. Однак якщо живий обʼєкт оновлено, а оновлення не внесено до його файлу конфігурації, вони будуть втрачені під час наступного виконання replace. Це може статися, якщо контролер, як-от HorizontalPodAutoscaler, вносить оновлення безпосередньо в живий обʼєкт. Ось приклад:
Ви створюєте обʼєкт з файлу конфігурації.
Інше джерело оновлює обʼєкт, змінюючи якесь поле.
Ви замінюєте обʼєкт з файлу конфігурації. Зміни, внесені іншим джерелом на кроці 2, втрачаються.
Якщо вам потрібна підтримка кількох записувачів для одного обʼєкта, можна використовувати kubectl apply для керування обʼєктом.
Створення та редагування обʼєкта за URL без збереження конфігурації
Припустимо, у вас є URL файлу конфігурації обʼєкта. Ви можете використати kubectl create --edit, щоб внести зміни до конфігурації перед створенням обʼєкта. Це особливо корисно для навчальних матеріалів і завдань, що вказують на файл конфігурації, який читач може змінити.
kubectl create -f <url> --edit
Міграція від імперативних команд до імперативного конфігурування обʼєктів
Міграція від імперативних команд до імперативного конфігурування обʼєктів складається з кількох кроків, які виконуються вручну.
Експортуйте живий обʼєкт у локальний файл конфігурації обʼєкта:
kubectl get <kind>/<name> -o yaml > <kind>_<name>.yaml
Вручну вилучіть поле status із файлу конфігурації обʼєкта.
Для подальшого керування обʼєктом використовуйте виключно replace.
kubectl replace -f <kind>_<name>.yaml
Визначення селекторів контролерів та міток PodTemplate
Попередження:
Оновлювати селектори контролерів категорично не рекомендовано.
Рекомендований підхід — визначити одну незмінну мітку PodTemplate, яка використовується тільки селектором контролера без іншого семантичного значення.
5.5 - Оновлення обʼєктів API на місці за допомогою kubectl patch
Використовуйте kubectl patch для оновлення обʼєктів Kubernetes API на місці. Виконайте strategic merge patch або JSON merge patch.
У цьому завданні показано, як використовувати kubectl patch для оновлення обʼєкта API на місці. Вправи цього завдання демонструють strategic merge patch і JSON merge patch.
Перш ніж ви розпочнете
Вам треба мати кластер Kubernetes, а також інструмент командного рядка kubectl має бути налаштований для роботи з вашим кластером. Рекомендується виконувати ці настанови у кластері, що має щонайменше два вузли, які не виконують роль вузлів управління. Якщо у вас немає кластера, ви можете створити його, за допомогою minikube або використовувати одну з цих пісочниць:
Вивід показує, що Deployment має два Podʼи. 1/1 вказує на те, що кожен Pod має один контейнер:
NAME READY STATUS RESTARTS AGE
patch-demo-28633765-670qr 1/1 Running 0 23s
patch-demo-28633765-j5qs3 1/1 Running 0 23s
Запишіть назви запущених Podʼів. Пізніше ви побачите, що ці Podʼи будуть завершені й замінені новими.
На цей момент кожен Pod має один контейнер, який запускає образ nginx. Тепер припустимо, що ви хочете, щоб кожен Pod мав два контейнери: один запускає nginx, а інший — redis.
Створіть файл з назвою patch-file.yaml із таким вмістом:
Перегляньте Podʼи, повʼязані з вашим Deployment після накладання патчу:
kubectl get pods
Вивід показує, що запущені Podʼи мають інші назви, ніж Podʼи, які працювали раніше. Deployment завершив старі Podʼи й створив два нові Podʼи, що відповідають оновленій специфікації Deployment. 2/2 вказує на те, що кожен Pod має два контейнери:
NAME READY STATUS RESTARTS AGE
patch-demo-1081991389-2wrn5 2/2 Running 0 1m
patch-demo-1081991389-jmg7b 2/2 Running 0 1m
Придивіться уважніше до одного з Podʼів patch-demo:
kubectl get pod <your-pod-name> --output yaml
Вивід показує, що Pod має два контейнери: один, який запускає nginx, і один, який запускає redis:
containers:
- image: redis
...
- image: nginx
...
Примітки щодо strategic merge patch
Патч, який ви виконали в попередній вправі, називається strategic merge patch. Зверніть увагу, що патч не замінив список containers. Натомість він додав до списку новий контейнер. Іншими словами, список у патчі обʼєднано з наявним списком. Так відбувається не завжди, коли ви застосовуєте strategic merge patch до списку. У деяких випадках список замінюється, а не обʼєднується.
Під час strategic merge patch список або замінюється, або обʼєднується залежно від його стратегії патча. Стратегія патча задається значенням ключа patchStrategy у теґу поля у вихідному коді Kubernetes. Наприклад, поле Containers структури PodSpec має patchStrategy зі значенням merge:
"io.k8s.api.core.v1.PodSpec": {...,"containers": {"description": "List of containers belonging to the pod. ...."},"x-kubernetes-patch-merge-key": "name","x-kubernetes-patch-strategy": "merge"}
Зверніть увагу, що список tolerations у PodSpec замінено, а не обʼєднано. Це тому, що поле Tolerations у PodSpec не має ключа patchStrategy у своєму теґу поля. Тож strategic merge patch використовує стандартну стратегію патча, тобто replace.
Використання JSON merge patch для оновлення Deployment
Strategic merge patch відрізняється від JSON merge patch. Якщо під час JSON merge patch потрібно оновити список, слід вказати весь новий список. Новий список повністю замінює наявний.
Команда kubectl patch має параметр type, який ви можете встановити на одне з цих значень:
Список containers, який ви вказали у патчі, має лише один контейнер. Вивід показує, що ваш список з одним контейнером замінив наявний список containers.
У виводі ви можете побачити, що наявні Podʼи були завершені, а нові Podʼи — створені. 1/1 вказує на те, що кожен новий Pod працює лише з одним контейнером.
NAME READY STATUS RESTARTS AGE
patch-demo-1307768864-69308 1/1 Running 0 1m
patch-demo-1307768864-c86dc 1/1 Running 0 1m
Використання strategic merge patch для оновлення Deployment зі стратегією retainKeys
Ось файл конфігурації для Deployment, що використовує стратегію RollingUpdate:
kubectl get deployment retainkeys-demo --output yaml
У виводі показано, що обʼєкт стратегії в Deployment більше не містить ключа rollingUpdate:
spec:strategy:type:Recreatetemplate:
Примітки щодо strategic merge patch зі стратегією retainKeys
Патч, який ви виконали в попередній вправі, називається strategic merge patch зі стратегією retainKeys. Цей метод вводить нову директиву $retainKeys, що має такі стратегії:
Вона містить список рядків.
Усі поля, які потрібно зберегти, повинні бути присутні в списку $retainKeys.
Присутні поля буде обʼєднано з живим обʼєктом.
Всі відсутні поля будуть очищені під час застосування патча.
Усі поля у списку $retainKeys повинні бути надмножиною або такими ж, як і поля, що присутні в патчі.
Стратегія retainKeys працює не для всіх обʼєктів. Вона працює лише тоді, коли значення ключа patchStrategy у теґу поля у вихідному коді Kubernetes містить retainKeys. Наприклад, поле Strategy структури DeploymentSpec має patchStrategy зі значенням retainKeys:
"io.k8s.api.apps.v1.DeploymentSpec": {...,"strategy": {"$ref": "#/definitions/io.k8s.api.apps.v1.DeploymentStrategy","description": "The deployment strategy to use to replace existing pods with new ones.","x-kubernetes-patch-strategy": "retainKeys"},....}
Оновлення кількості реплік обʼєкта за допомогою kubectl patch з --subresource
Прапорець --subresource=[subresource-name] використовується з командами kubectl, як-от get, patch, edit, apply і replace, для отримання та оновлення субресурсів status, scale і resize вказаних вами ресурсів. Ви можете вказати субресурс для будь-якого ресурсу API Kubernetes (вбудованого або CR), що має субресурс status, scale або resize.
Наприклад, Deployment має субресурси status і scale, тож ви можете використовувати kubectl, щоб отримати або змінити лише субресурс status Deployment.
apiVersion:apps/v1kind:Deploymentmetadata:name:nginx-deploymentspec:selector:matchLabels:app:nginxreplicas:2# tells deployment to run 2 pods matching the templatetemplate:metadata:labels:app:nginxspec:containers:- name:nginximage:nginx:1.14.2ports:- containerPort:80
Якщо ви запускаєте kubectl patch і вказуєте прапорець --subresource для ресурсу, який не підтримує цей конкретний субресурс, API-сервер повертає помилку 404 Not Found.
Підсумки
У цій вправі ви використали kubectl patch, щоб змінити живу конфігурацію обʼєкта Deployment. Ви не змінювали файл конфігурації, за допомогою якого спочатку створили обʼєкт Deployment. Інші команди для оновлення обʼєктів API: kubectl annotate, kubectl edit, kubectl replace, kubectl scale і kubectl apply.
Примітка:
Strategic merge patch не підтримується для власних ресурсів.
5.6 - Міграція обʼєктів Kubernetes за допомогою міграції версій сховища
СТАН ФУНКЦІОНАЛУ:Beta since Kubernetes v1.35; (стандартно вимкнено)
More information about this feature
To use this feature, you (or a cluster administrator) will need to enable the StorageVersionMigrator feature gate for all relevant components in your cluster.
Kubernetes покладається на активне переписування даних API для підтримки деяких операцій обслуговування, повʼязаних зі зберіганням у стані спокою. Два помітні приклади — версійна схема збережених ресурсів (тобто зміна бажаної схеми зберігання з v1 на v2 для певного ресурсу) та шифрування у стані спокою (тобто перезапис застарілих даних через зміну способу шифрування даних).
Виконання міграції версій сховища гарантує, що всі обʼєкти ресурсу перенесено із застарілої версії сховища. Вимога до виконання міграції сховища — ресурс повинен мати цілочисельну версію ресурсу. Усі ресурси Kubernetes і CRD гарантовано мають цю властивість, але міграція завершиться збоєм, якщо це не так, наприклад для агрегованих API.
Вам треба мати кластер Kubernetes, а також інструмент командного рядка kubectl має бути налаштований для роботи з вашим кластером. Рекомендується виконувати ці настанови у кластері, що має щонайменше два вузли, які не виконують роль вузлів управління. Якщо у вас немає кластера, ви можете створити його, за допомогою minikube або використовувати одну з цих пісочниць:
Стежте за міграцією Secrets, перевіряючи .status обʼєкта StorageVersionMigration. Успішна міграція повинна мати стан Succeeded зі значенням true. Отримайте обʼєкт StorageVersionMigration таким чином:
Перевірте, що збережений Secret тепер починається з k8s:enc:aescbc:v1:key2.
Оновлення бажаної схеми зберігання CRD
Розгляньмо сценарій, у якому CustomResourceDefinition (CRD) створено для обслуговування власних ресурсів (CR) і встановлено як бажану схему зберігання. Коли настане час ввести v2 CRD, її можна додати лише для обслуговування за допомогою вебхука конвертації. Це забезпечує плавніший перехід, за якого користувачі можуть створювати CR за схемою v1 або v2, а вебхук виконує потрібну конвертацію схеми між ними. Перш ніж встановити v2 як бажану версію схеми зберігання, важливо переконатися, що всі наявні CR, збережені як v1, мігровано на v2. Цю міграцію можна виконати за допомогою Storage Version Migration, щоб перенести всі CR з v1 на v2.
Створіть маніфест для CRD з назвою test-crd.yaml з таким вмістом:
Стежте за міграцією Secrets за допомогою статусу. Успішна міграція повинна мати стан Succeeded зі значенням "True" у полі статусу. Отримайте ресурс міграції таким чином:
kubectl get storageversionmigration.storagemigration.k8s.io/crdsvm -o yaml
Керування конфіденційними даними налаштувань за допомогою Secrets.
6.1 - Керування Secrets за допомогою kubectl
Створення обʼєктів Secret за допомогою командного рядка kubectl.
На цій сторінці показано, як створювати й редагувати Secrets Kubernetes, керувати ними та видаляти їх за допомогою інструмента командного рядка kubectl.
Перш ніж ви розпочнете
Вам треба мати кластер Kubernetes, а також інструмент командного рядка kubectl має бути налаштований для роботи з вашим кластером. Рекомендується виконувати ці настанови у кластері, що має щонайменше два вузли, які не виконують роль вузлів управління. Якщо у вас немає кластера, ви можете створити його, за допомогою minikube або використовувати одну з цих пісочниць:
Обʼєкт Secret зберігає конфіденційні дані, такі як облікові дані, які Podʼи використовують для доступу до сервісів. Наприклад, Secret може знадобитися для зберігання імені користувача й пароля, потрібних для доступу до бази даних.
Ви можете створити Secret, передавши необроблені дані в команді або зберігши облікові дані у файлах, які ви передаєте в команді. Наведені нижче команди створюють Secret, який зберігає імʼя користувача admin і пароль S!B\*d$zDsb=.
Щоб екранувати спеціальні символи, такі як $, \, *, = і !, у рядках, потрібно використовувати одинарні лапки ''. Інакше ваша оболонка інтерпретуватиме ці символи.
Примітка:
Поле stringData у Secret погано працює із застосуванням на боці сервера (server-side apply).
Прапорець -n гарантує, що згенеровані файли не матимуть зайвого символу нового рядка в кінці тексту. Це важливо, бо коли kubectl читає файл і кодує вміст у рядок base64, зайвий символ нового рядка теж кодується. Спеціальні символи в рядках, які ви додаєте у файл, екранувати не потрібно.
Команди kubectl get і kubectl describe стандартно не показують вміст Secret. Це захищає Secret від випадкового розкриття або збереження в логах термінала.
Розкодування Secret
Перегляньте вміст створеного вами Secret:
kubectl get secret db-user-pass -o jsonpath='{.data}'
Це приклад для цілей документації. На практиці цей спосіб може призвести до збереження команди із закодованими даними в історії оболонки. Будь-хто з доступом до вашого компʼютера може знайти цю команду й розкодувати Secret. Кращий підхід — поєднати команди перегляду та розкодування.
kubectl get secret db-user-pass -o jsonpath='{.data.password}'| base64 --decode
Редагування Secret
Ви можете редагувати наявний обʼєкт Secret, якщо він не є незмінним. Щоб відредагувати Secret, виконайте таку команду:
kubectl edit secrets <secret-name>
Це відкриє ваш типовий редактор і дозволить оновити закодовані в base64 значення Secret у полі data, як у наведеному нижче прикладі:
# Будь ласка, відредагуйте наведений нижче обʼєкт. Рядки, що починаються з символу «#», ігноруватимуться,# а порожній файл призведе до припинення редагування. Якщо під час збереження цього файлу виникне помилка, його# буде знову відкрито з зазначенням відповідних помилок.#apiVersion:v1data:password:UyFCXCpkJHpEc2I9username:YWRtaW4=kind:Secretmetadata:creationTimestamp:"2022-06-28T17:44:13Z"name:db-user-passnamespace:defaultresourceVersion:"12708504"uid:91becd59-78fa-4c85-823f-6d44436242actype:Opaque
6.2 - Керування Secrets за допомогою файлу конфігурації
Створення обʼєктів Secret за допомогою файлу конфігурації ресурсу.
Перш ніж ви розпочнете
Вам треба мати кластер Kubernetes, а також інструмент командного рядка kubectl має бути налаштований для роботи з вашим кластером. Рекомендується виконувати ці настанови у кластері, що має щонайменше два вузли, які не виконують роль вузлів управління. Якщо у вас немає кластера, ви можете створити його, за допомогою minikube або використовувати одну з цих пісочниць:
Ви можете спочатку визначити обʼєкт Secret у маніфесті у форматі JSON або YAML, а потім створити цей обʼєкт. Ресурс Secret містить два словники: data і stringData. Поле data використовується для зберігання довільних даних, закодованих у base64. Поле stringData надається для зручності й дозволяє вказувати ті самі дані у вигляді незакодованих рядків. Ключі data і stringData мають складатися з буквено-цифрових символів, -, _ або ..
Наведений нижче приклад зберігає два рядки в Secret за допомогою поля data.
Серіалізовані значення JSON і YAML даних Secret кодуються як рядки base64. Символи нового рядка в цих рядках неприпустимі й мають бути вилучені. Під час використання утиліти base64 у Darwin/macOS користувачам слід уникати параметра -b для розбиття довгих рядків. Натомість користувачам Linux слід додавати параметр -w 0 до команд base64 або використовувати конвеєр base64 | tr -d '\n', якщо параметр -w недоступний.
Вказання незакодованих даних під час створення Secret
У деяких сценаріях ви можете натомість використовувати поле stringData. Це поле дозволяє розмістити рядок без кодування base64 безпосередньо в Secret, і цей рядок буде закодовано автоматично під час створення або оновлення Secret.
Практичний приклад: ви розгортаєте застосунок, який використовує Secret для зберігання файлу конфігурації, і хочете заповнити частини цього файлу конфігурації під час розгортання.
Наприклад, якщо ваш застосунок використовує такий файл конфігурації:
YWRtaW5pc3RyYXRvcg== розкодовується в administrator.
Редагування Secret
Щоб відредагувати дані в Secret, створеному за допомогою маніфесту, змініть поле data або stringData у маніфесті й застосуйте файл до кластера. Ви можете редагувати наявний обʼєкт Secret, якщо він не є незмінним.
Наприклад, якщо ви хочете змінити пароль із попереднього прикладу на birdsarentreal, зробіть таке:
Kubernetes оновлює наявний обʼєкт Secret. Докладніше: інструмент kubectl помічає, що вже існує обʼєкт Secret із такою самою назвою. kubectl отримує наявний обʼєкт, планує зміни в ньому й надсилає змінений обʼєкт Secret до панелі управління кластера.
Створення обʼєктів Secret за допомогою файлу kustomization.yaml.
kubectl підтримує використання інструмента керування обʼєктами Kustomize для керування Secrets і ConfigMaps. За допомогою Kustomize ви створюєте генератор ресурсів, який генерує Secret, що його можна застосувати до API-сервера за допомогою kubectl.
Перш ніж ви розпочнете
Вам треба мати кластер Kubernetes, а також інструмент командного рядка kubectl має бути налаштований для роботи з вашим кластером. Рекомендується виконувати ці настанови у кластері, що має щонайменше два вузли, які не виконують роль вузлів управління. Якщо у вас немає кластера, ви можете створити його, за допомогою minikube або використовувати одну з цих пісочниць:
Ви можете згенерувати Secret, визначивши secretGenerator у файлі kustomization.yaml, який посилається на інші наявні файли, файли .env або літеральні значення. Наприклад, наведені нижче інструкції створюють файл kustomization для імені користувача admin і пароля 1f2d1e2e67df.
Примітка:
Поле stringData у Secret погано працює із застосуванням на боці сервера (server-side apply).
Ви також можете визначити secretGenerator у файлі kustomization.yaml, надавши файли .env. Наприклад, наведений нижче файл kustomization.yaml отримує дані з файлу .env.secret:
У всіх випадках значення не потрібно кодувати в base64. Назва файлу YAML має бути kustomization.yaml або kustomization.yml.
Застосування файлу kustomization
Щоб створити Secret, застосуйте теку, яка містить файл kustomization:
kubectl apply -k <directory-path>
Вивід подібний до такого:
secret/database-creds-5hdh7hhgfk created
Під час генерації Secret його назву створюють шляхом хешування даних Secret і додавання значення хешу до назви. Це гарантує, що під час кожної зміни даних генерується новий Secret.
Щоб перевірити, що Secret створено, і розкодувати дані Secret,
kubectl get -k <directory-path> -o jsonpath='{.data}'
У файлі kustomization.yaml змініть дані, наприклад password.
Застосуйте теку, яка містить файл kustomization:
kubectl apply -k <directory-path>
Вивід подібний до такого:
secret/db-user-pass-6f24b56cc8 created
Змінений Secret створюється як новий обʼєкт Secret, а не оновлює наявний обʼєкт Secret. Можливо, вам доведеться оновити посилання на Secret у ваших Podʼах.
Визначення конфігурації та інших даних для Podʼів, у яких працює ваше робоче навантаження.
7.1 - Визначення команди та аргументів для контейнера
На цій сторінці показано, як визначати команди й аргументи під час запуску контейнера в Pod.
Перш ніж ви розпочнете
Вам треба мати кластер Kubernetes, а також інструмент командного рядка kubectl має бути налаштований для роботи з вашим кластером. Рекомендується виконувати ці настанови у кластері, що має щонайменше два вузли, які не виконують роль вузлів управління. Якщо у вас немає кластера, ви можете створити його, за допомогою minikube або використовувати одну з цих пісочниць:
Визначення команди та аргументів під час створення Podʼа
Під час створення Podʼа ви можете визначити команду й аргументи для контейнерів, які працюють у Podʼі. Щоб визначити команду, додайте поле command у файл конфігурації. Щоб визначити аргументи команди, додайте поле args у файл конфігурації. Команду й аргументи, які ви визначили, не можна змінити після створення Podʼа.
Команда й аргументи, які ви визначаєте у файлі конфігурації, перевизначають стандартну команду й аргументи, надані образом контейнера. Якщо ви визначаєте args, але не визначаєте команду, використовується стандартна команда з вашими новими аргументами.
Примітка:
Поле command відповідає ENTRYPOINT, а поле args — CMD у деяких середовищах виконання контейнерів.
У цій вправі ви створите Pod, який запускає один контейнер. Файл конфігурації Podʼа визначає команду й два аргументи:
Вивід показує, що контейнер, який працював у Podʼі command-demo, завершився.
Щоб побачити вивід команди, яка виконувалася в контейнері, перегляньте логи Podʼа:
kubectl logs command-demo
Вивід показує значення змінних середовища HOSTNAME та KUBERNETES_PORT:
command-demo
tcp://10.3.240.1:443
Використання змінних середовища для визначення аргументів
У попередньому прикладі ви визначили аргументи безпосередньо, вказавши рядки. Замість прямого вказування рядків ви можете визначати аргументи за допомогою змінних середовища:
Це означає, що ви можете визначити аргумент для Podʼа будь-яким способом, доступним для визначення змінних середовища, зокрема за допомогою ConfigMaps і Secrets.
Примітка:
Змінна середовища вказується в дужках, "$(VAR)". Це потрібно, щоб змінна розгорталася в полі command або args.
Виконання команди в оболонці
Іноді потрібно, щоб команда виконувалася в оболонці. Наприклад, ваша команда може складатися з кількох команд, обʼєднаних у конвеєр, або бути скриптом оболонки. Щоб виконати команду в оболонці, оберніть її так:
command: ["/bin/sh"]args: ["-c", "while true; do echo hello; sleep 10;done"]
На цій сторінці показано, як визначати залежні змінні середовища для контейнера в Podʼі Kubernetes.
Перш ніж ви розпочнете
Вам треба мати кластер Kubernetes, а також інструмент командного рядка kubectl має бути налаштований для роботи з вашим кластером. Рекомендується виконувати ці настанови у кластері, що має щонайменше два вузли, які не виконують роль вузлів управління. Якщо у вас немає кластера, ви можете створити його, за допомогою minikube або використовувати одну з цих пісочниць:
Визначення залежної змінної середовища для контейнера
Під час створення Podʼа ви можете встановлювати залежні змінні середовища для контейнерів, які працюють у Podʼі. Для цього можна використовувати $(VAR_NAME) у value поля env у файлі конфігурації.
У цій вправі ви створите Pod, який запускає один контейнер. Файл конфігурації Podʼа визначає залежну змінну середовища з поширеним способом використання. Ось маніфест конфігурації Podʼа:
Як показано вище, ви визначили правильне посилання на залежність SERVICE_ADDRESS, неправильне посилання на залежність UNCHANGED_REFERENCE і пропустили залежні посилання в ESCAPED_REFERENCE.
Якщо змінну середовища вже визначено на момент посилання, посилання можна правильно розвʼязати, як у випадку SERVICE_ADDRESS.
Зверніть увагу, що порядок у списку env має значення. Змінна середовища не вважається «визначеною», якщо вона вказана нижче в списку. Саме тому UNCHANGED_REFERENCE не вдається розвʼязати $(PROTOCOL) у наведеному вище прикладі.
Коли змінна середовища не визначена або включає лише деякі змінні, невизначена змінна середовища розглядається як звичайний рядок, як у випадку UNCHANGED_REFERENCE. Зверніть увагу, що неправильно розібрані змінні середовища зазвичай не блокують запуск контейнера.
Синтаксис $(VAR_NAME) можна екранувати подвійним $, тобто $$(VAR_NAME). Екрановані посилання ніколи не розгортаються, незалежно від того, чи визначена змінна, на яку вони посилаються. Це видно з наведеного вище випадку ESCAPED_REFERENCE.
7.3 - Визначення змінних середовища для контейнера
На цій сторінці показано, як визначити змінні середовища для контейнера в Podʼі Kubernetes.
Перш ніж ви розпочнете
Вам треба мати кластер Kubernetes, а також інструмент командного рядка kubectl має бути налаштований для роботи з вашим кластером. Рекомендується виконувати ці настанови у кластері, що має щонайменше два вузли, які не виконують роль вузлів управління. Якщо у вас немає кластера, ви можете створити його, за допомогою minikube або використовувати одну з цих пісочниць:
Під час створення Podʼа ви можете задати змінні середовища для контейнерів, які працюють у Podʼі. Щоб задати змінні середовища, додайте поле env або envFrom у файл конфігурації.
Поля env та envFrom діють по-різному.
env
дозволяє задати змінні середовища для контейнера, вказавши значення безпосередньо для кожної названої змінної.
envFrom
дозволяє задати змінні середовища для контейнера через посилання на ConfigMap або Secret. Коли ви використовуєте envFrom, усі пари ключ-значення у вказаному ConfigMap або Secret задаються як змінні середовища контейнера. Ви також можете вказати спільний префікс.
У цій вправі ви створите Pod, який запускає один контейнер. Файл конфігурації Podʼа визначає змінну середовища з назвою DEMO_GREETING і значенням "Hello from the environment". Ось маніфест конфігурації Podʼа:
apiVersion:v1kind:Podmetadata:name:envar-demolabels:purpose:demonstrate-envarsspec:containers:- name:envar-demo-containerimage:gcr.io/google-samples/hello-app:2.0env:- name:DEMO_GREETINGvalue:"Hello from the environment"- name:DEMO_FAREWELLvalue:"Such a sweet sorrow"
NAME READY STATUS RESTARTS AGE
envar-demo 1/1 Running 0 9s
Виведіть змінні середовища контейнера Podʼа:
kubectl exec envar-demo -- printenv
Вивід подібний до такого:
NODE_VERSION=4.4.2
EXAMPLE_SERVICE_PORT_8080_TCP_ADDR=10.3.245.237
HOSTNAME=envar-demo
...
DEMO_GREETING=Hello from the environment
DEMO_FAREWELL=Such a sweet sorrow
Примітка:
Змінні середовища, встановлені за допомогою полів env або envFrom, перевизначають будь-які змінні середовища, вказані в образі контейнера.
Примітка:
Змінні середовища можуть посилатися одна на одну, але порядок важливий. Змінні, що використовують інші змінні, визначені в тому самому контексті, мають іти нижче в списку. Так само уникайте циклічних посилань.
Використання змінних середовища у вашій конфігурації
Змінні середовища, які ви визначаєте в конфігурації Podʼа в .spec.containers[*].env[*], можна використовувати в інших частинах конфігурації, наприклад у командах і аргументах, які ви задаєте для контейнерів Podʼа. У наведеному нижче прикладі конфігурації змінні середовища GREETING, HONORIFIC і NAME мають значення Warm greetings to, The Most Honorable і Kubernetes відповідно. Змінна середовища MESSAGE обʼєднує всі ці змінні середовища, а потім використовується як аргумент командного рядка, переданий контейнеру env-print-demo.
7.4 - Визначення значень змінних середовища за допомогою init-контейнера
СТАН ФУНКЦІОНАЛУ:Beta since Kubernetes v1.35; (стандартно увімкнено)
На цій сторінці показано, як налаштувати змінні середовища для контейнерів у Podʼі за допомогою файлу.
Перш ніж ви розпочнете
Вам треба мати кластер Kubernetes, а також інструмент командного рядка kubectl має бути налаштований для роботи з вашим кластером. Рекомендується виконувати ці настанови у кластері, що має щонайменше два вузли, які не виконують роль вузлів управління. Якщо у вас немає кластера, ви можете створити його, за допомогою minikube або використовувати одну з цих пісочниць:
У цьому маніфесті initContainer монтує том emptyDir і записує змінні середовища у файл усередині нього, а звичайні контейнери посилаються і на файл, і на ключ змінної середовища через поле fileKeyRef, не монтуючи том. Коли поле optional має значення false, вказаний key у fileKeyRef має існувати у файлі змінних середовища.
Том монтується лише в контейнер, який записує у файл (initContainer), а контейнер-споживач, який використовує змінну середовища, не матиме змонтованого тому.
Під час ініціалізації контейнера kubelet отримує змінні середовища зі вказаних файлів у томі emptyDir і надає їх контейнеру.
Примітка:
Усі типи контейнерів (init-контейнери, звичайні контейнери, sidecar-контейнери й ефемерні контейнери) підтримують завантаження змінних середовища з файлів.
Хоча ці змінні середовища можуть зберігати конфіденційну інформацію, томи emptyDir не забезпечують тих самих механізмів захисту, що й окремі обʼєкти Secret. Тому надання конфіденційних змінних середовища контейнерам через цю можливість не вважається рекомендованою практикою безпеки.
Вивід показує значення вибраних змінних середовища:
DB_ADDRESS=address
Синтаксис файлів env
Формат файлу env, який використовує Kubernetes, є чітко визначеною підмножиною семантики змінних середовища для POSIX-сумісного bash. Будь-який файл env, який підтримує Kubernetes, створює ті самі змінні середовища, що й під час інтерпретації в POSIX-сумісному bash. Однак POSIX-сумісний bash підтримує деякі додаткові формати, які Kubernetes не приймає.
Приклад:
MY_VAR='my-literal-value'
Правила
Оголошення змінної: використовуйте форму VAR='value'. Пробіли навколо = ігноруються; пробіли на початку рядка ігноруються; порожні рядки ігноруються.
Значення в лапках: значення мають бути взяті в одинарні лапки (').
Вміст в одинарних лапках зберігається дослівно. Обробка екранованих послідовностей, згортання пробілів чи інтерпретація символів не застосовуються.
Символи нового рядка в одинарних лапках зберігаються (багаторядкові значення підтримуються).
Коментарі: рядки, що починаються з #, розглядаються як коментарі та ігноруються. Символ # всередині значення в одинарних лапках не є коментарем.
7.5 - Використання змінних середовища для передачі контейнерам інформації про Pod
На цій сторінці показано, як Pod може використовувати змінні середовища, щоб передавати інформацію про себе контейнерам, які працюють у Podʼі, за допомогою downward API. Ви можете використовувати змінні середовища для надання полів Podʼа, полів контейнера або тих і тих.
У Kubernetes є два способи надати поля Podʼа та контейнера запущеному контейнеру:
Разом ці два способи надання полів Podʼа та контейнера називаються downward API.
Оскільки Services є основним способом взаємодії між контейнеризованими застосунками, якими керує Kubernetes, корисно мати змогу виявляти їх під час виконання.
Вам треба мати кластер Kubernetes, а також інструмент командного рядка kubectl має бути налаштований для роботи з вашим кластером. Рекомендується виконувати ці настанови у кластері, що має щонайменше два вузли, які не виконують роль вузлів управління. Якщо у вас немає кластера, ви можете створити його, за допомогою minikube або використовувати одну з цих пісочниць:
У цьому маніфесті ви бачите пʼять змінних середовища. Поле env — це масив визначень змінних середовища. Перший елемент масиву вказує, що змінна середовища MY_NODE_NAME отримує значення з поля spec.nodeName Podʼа. Аналогічно інші змінні середовища отримують свої назви з полів Podʼа.
Примітка:
Поля в цьому прикладі є полями Podʼа. Вони не є полями контейнера в Podʼі.
Щоб зрозуміти, чому ці значення є в логу, подивіться на поля command і args у файлі конфігурації. Коли контейнер запускається, він записує значення пʼяти змінних середовища в stdout. Він повторює це кожні десять секунд.
Далі отримайте доступ до оболонки в контейнері, який працює у вашому Podʼі:
kubectl exec -it dapi-envars-fieldref -- sh
В оболонці перегляньте змінні середовища:
# Виконайте це в оболонці всередині контейнераprintenv
Вивід показує, що деяким змінним середовища призначено значення полів Podʼа:
Використання полів контейнера як значень змінних середовища
У попередній вправі ви використовували інформацію з полів рівня Podʼа як значення змінних середовища. У наступній вправі ви передасте поля, які є частиною визначення Podʼа, але взяті з конкретного контейнера, а не з Podʼа загалом.
Ось маніфест іншого Podʼа, який знову має лише один контейнер:
У цьому маніфесті ви бачите чотири змінні середовища. Поле env — це масив визначень змінних середовища. Перший елемент масиву вказує, що змінна середовища MY_CPU_REQUEST отримує значення з поля requests.cpu контейнера з назвою test-container. Аналогічно інші змінні середовища отримують значення з полів, специфічних для цього контейнера.
7.6 - Передача інформації про Pod контейнерам через файли
На цій сторінці показано, як Pod може використовувати том downwardAPI, щоб передавати інформацію про себе контейнерам, які працюють у Podʼі. Том downwardAPI може надавати поля Podʼа й контейнера.
У Kubernetes є два способи надати поля Podʼа та контейнера запущеному контейнеру:
Разом ці два способи надання полів Podʼа та контейнера називаються downward API.
Перш ніж ви розпочнете
Вам треба мати кластер Kubernetes, а також інструмент командного рядка kubectl має бути налаштований для роботи з вашим кластером. Рекомендується виконувати ці настанови у кластері, що має щонайменше два вузли, які не виконують роль вузлів управління. Якщо у вас немає кластера, ви можете створити його, за допомогою minikube або використовувати одну з цих пісочниць:
У маніфесті ви бачите, що Pod має том downwardAPI, а контейнер монтує цей том у /etc/podinfo.
Подивіться на масив items у downwardAPI. Кожен елемент масиву визначає том downwardAPI. Перший елемент вказує, що значення поля metadata.labels Podʼа слід зберегти у файлі з назвою labels. Другий елемент вказує, що значення поля annotations Podʼа слід зберегти у файлі з назвою annotations.
Примітка:
Поля в цьому прикладі є полями Podʼа. Вони не є полями контейнера в Podʼі.
У виводі видно, що файли labels та annotations містяться в тимчасовій підтеці: у цьому прикладі ..2982_06_02_21_47_53.299460680. У теці /etc/podinfo..data є символічним посиланням на тимчасову підтеку. Також у теці /etc/podinfolabels та annotations є символічними посиланнями.
drwxr-xr-x ... Feb 6 21:47 ..2982_06_02_21_47_53.299460680
lrwxrwxrwx ... Feb 6 21:47 ..data -> ..2982_06_02_21_47_53.299460680
lrwxrwxrwx ... Feb 6 21:47 annotations -> ..data/annotations
lrwxrwxrwx ... Feb 6 21:47 labels -> ..data/labels
/etc/..2982_06_02_21_47_53.299460680:
total 8
-rw-r--r-- ... Feb 6 21:47 annotations
-rw-r--r-- ... Feb 6 21:47 labels
Символічні посилання дають змогу динамічно й атомарно оновлювати метадані: оновлення записуються в нову тимчасову теку, а символічне посилання ..data оновлюється атомарно за допомогою rename(2).
Примітка:
Контейнер, який використовує Downward API як том, змонтований через subPath, не отримуватиме оновлень Downward API.
Вийдіть з оболонки:
/# exit
Зберігання полів контейнера
У попередній вправі ви зробили поля рівня Podʼа доступними за допомогою downward API. У наступній вправі ви передасте поля, які є частиною визначення Podʼа, але взяті з конкретного контейнера, а не з Podʼа загалом. Ось маніфест Podʼа, який знову має лише один контейнер:
У маніфесті ви бачите, що Pod має том downwardAPI, а єдиний контейнер у цьому Podʼі монтує цей том у /etc/podinfo.
Подивіться на масив items у downwardAPI. Кожен елемент масиву визначає файл у томі downward API.
Перший елемент вказує, що в контейнері з назвою client-container значення поля limits.cpu у форматі, заданому 1m, слід опублікувати як файл із назвою cpu_limit. Поле divisor необовʼязкове й має стандартне значення 1. Дільник 1 означає ядра для ресурсів cpu або байти для ресурсів memory.
Отримайте доступ до оболонки в контейнері, який працює у вашому Podʼі:
kubectl exec -it kubernetes-downwardapi-volume-example-2 -- sh
В оболонці перегляньте файл cpu_limit:
# Виконайте це в оболонці всередині контейнераcat /etc/podinfo/cpu_limit
Ви можете використовувати подібні команди, щоб переглянути файли cpu_request, mem_limit та mem_request.
Проєціювання ключів на конкретні шляхи та дозволи файлів
Ви можете проєціювати ключі на конкретні шляхи й задавати конкретні дозволи для кожного файлу окремо. Докладніше дивіться Secrets.
Що далі
Прочитайте визначення API spec для Pod. Воно містить визначення Container (частина Pod).
Прочитайте список доступних полів, які можна надати за допомогою downward API.
Прочитайте про томи в застарілій довідці API:
Перегляньте визначення API Volume, яке описує загальний том у Podʼі, до якого мають доступ контейнери.
Перегляньте визначення API DownwardAPIVolumeSource, яке описує том з інформацією Downward API.
Перегляньте визначення API DownwardAPIVolumeFile, яке містить посилання на поля обʼєкта або ресурсу для заповнення файлу в томі Downward API.
Перегляньте визначення API ResourceFieldSelector, яке визначає ресурси контейнера та формат їх виводу.
8 - Запуск застосунків
Запуск застосунків без збереження стану і зі збереженням стану та керування ними.
8.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/v1kind:Deploymentmetadata:name:nginx-deploymentspec:selector:matchLabels:app:nginxreplicas:2# tells deployment to run 2 pods matching the templatetemplate:metadata:labels:app:nginxspec:containers:- name:nginximage:nginx:1.14.2ports:- containerPort:80
apiVersion:apps/v1kind:Deploymentmetadata:name:nginx-deploymentspec:selector:matchLabels:app:nginxreplicas:2template:metadata:labels:app:nginxspec:containers:- name:nginximage:nginx:1.16.1# Update the version of nginx from 1.14.2 to 1.16.1ports:- containerPort:80
Спостерігайте, як Deployment створює Podʼи з новими назвами й видаляє старі Podʼи:
kubectl get pods -l app=nginx
Масштабування застосунку шляхом збільшення кількості реплік
Ви можете збільшити кількість Podʼів у вашому Deployment, застосувавши новий файл YAML. Цей файл YAML встановлює replicas на 4, що означає, що Deployment повинен мати чотири Podʼи:
apiVersion:apps/v1kind:Deploymentmetadata:name:nginx-deploymentspec:selector:matchLabels:app:nginxreplicas:4# Update the replicas from 2 to 4template:metadata:labels:app:nginxspec:containers:- name:nginximage:nginx:1.16.1ports:- containerPort:80
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.
8.2 - Горизонтальне ручне масштабування для Deployment
На цій сторінці показано, як вручну масштабувати Deployment горизонтально, змінюючи кількість його реплік. Ручне масштабування дає змогу безпосередньо контролювати кількість запущених Podʼів для передбачуваних змін навантаження або керування витратами.
Це відрізняється від вертикального масштабування, за якого кількість реплік лишається незмінною, але змінюється кількість ресурсів, доступних кожному Podʼу.
Цілі
Масштабування Deployment вгору для обробки більшого трафіку.
Зменшення масштабу Deployment для економії ресурсів.
Масштабування Deployment до нуля для тимчасового призупинення робочого навантаження.
Розуміння, коли використовувати ручне масштабування, а коли HorizontalPodAutoscaler.
Перш ніж ви розпочнете
Вам треба мати кластер Kubernetes, а також інструмент командного рядка kubectl має бути налаштований для роботи з вашим кластером. Рекомендується виконувати ці настанови у кластері, що має щонайменше два вузли, які не виконують роль вузлів управління. Якщо у вас немає кластера, ви можете створити його, за допомогою minikube або використовувати одну з цих пісочниць:
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 на менше значення:
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:
Для скриптів використовуйте патч JSON із попередньою перевіркою. Наведена нижче команда встановлює кількість реплік на 4, але лише якщо поточна кількість дорівнює 2:
Операція test призводить до збою патчу, якщо поточне значення не збігається, що запобігає небажаним змінам, коли кілька людей або скриптів змінюють той самий Deployment.
Коли використовувати ручне, а коли автоматичне масштабування
Аспект
Ручне масштабування
Автоматичне масштабування (HPA)
Найкраще для
Передбачуваних, запланованих або одноразових змін навантаження
Змінного або непередбачуваного попиту
Як це працює
Ви встановлюєте .spec.replicas безпосередньо
HPA регулює кількість реплік на основі спостережуваних метрик
Час реакції
Негайно після виконання команди
Реагує на метрики з невеликою затримкою
Врахування метрик
Відсутнє — кількість реплік вирішуєте ви
Відстежує CPU, памʼять або власні метрики
Обслуговування
Потребує ручного втручання для налаштування
Працює автономно після налаштування
Увага:
Якщо HorizontalPodAutoscaler керує Deployment, не встановлюйте репліки вручну. HPA постійно узгоджує кількість реплік і перевизначає будь-які ручні зміни.
На цій сторінці показано, як оновити запущений Deployment до нової версії за допомогою поетапного оновлення. Поетапне оновлення поступово замінює старі Podʼи новими, тому ваш застосунок залишається доступним протягом усього процесу.
Вам треба мати кластер Kubernetes, а також інструмент командного рядка kubectl має бути налаштований для роботи з вашим кластером. Рекомендується виконувати ці настанови у кластері, що має щонайменше два вузли, які не виконують роль вузлів управління. Якщо у вас немає кластера, ви можете створити його, за допомогою minikube або використовувати одну з цих пісочниць:
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 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 застосовує всі зміни разом, коли ви відновлюєте розгортання.
RollingUpdate (стандартно): поступово замінює старі Podʼи новими.
Recreate: спочатку завершує всі наявні Podʼи, а потім створює нові. Це призводить до простою.
Для стратегії RollingUpdate ці параметри контролюють, як Kubernetes виконує оновлення:
Параметр
Що контролює
Стандартно
Приклад
maxUnavailable
Максимальна кількість Podʼів, які можуть бути недоступні під час оновлення
25%
1 або 25%
maxSurge
Максимальна кількість додаткових Podʼів, які можуть бути створені під час оновлення
25%
1 або 25%
Примітка:
maxUnavailable та maxSurge приймають абсолютне число або відсоток. Kubernetes обчислює відсотки від бажаної кількості реплік, округлюючи вниз для maxUnavailable та округлюючи вгору для maxSurge.
Для налаштування цих параметрів використовуйте kubectl patch:
Ви також можете задати ці поля в маніфесті 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
Стовпець CHANGE-CAUSE показує значення анотації kubernetes.io/change-cause на момент кожної ревізії. Ця анотація не встановлюється автоматично, але якщо ви використовуєте автоматизоване рішення для керування Deployments, ваш інструмент може записувати в цю анотацію певний текст.
kubectl rollout status deployment/nginx-deployment
Примітка:
Історія ревізій Deployment зберігається в ReplicaSets, якими він керує. Стандартно Kubernetes зберігає 10 старих ReplicaSets. Ви можете змінити це обмеження, встановивши .spec.revisionHistoryLimit у маніфесті Deployment. Значення 0 повністю вимикає відкочування.
8.4 - Запуск одноекземплярного застосунку зі збереженням стану
На цій сторінці показано, як запустити одноекземплярний застосунок зі збереженням стану в Kubernetes, використовуючи PersistentVolume та Deployment. Застосунок — MySQL.
Цілі
Створити PersistentVolume, що посилається на диск у вашому середовищі.
Створити Deployment MySQL.
Відкрити доступ до MySQL іншим Podʼам у кластері за відомим DNS-імʼям.
Перш ніж ви розпочнете
Вам треба мати кластер Kubernetes, а також інструмент командного рядка kubectl має бути налаштований для роботи з вашим кластером. Рекомендується виконувати ці настанови у кластері, що має щонайменше два вузли, які не виконують роль вузлів управління. Якщо у вас немає кластера, ви можете створити його, за допомогою minikube або використовувати одну з цих пісочниць:
Ви можете запустити застосунок зі збереженням стану, створивши Deployment Kubernetes і підʼєднавши його до наявного PersistentVolume за допомогою PersistentVolumeClaim. Наприклад, цей файл YAML описує Deployment, який запускає MySQL і посилається на PersistentVolumeClaim. Файл визначає монтування тому для /var/lib/mysql, а потім створює PersistentVolumeClaim, що шукає том на 20G. Цю заявку задовольняє будь-який наявний том, що відповідає вимогам, або динамічний provisioner.
Примітка: пароль визначено у файлі конфігурації yaml, і це небезпечно. Безпечне рішення дивіться в розділі Kubernetes Secrets.
apiVersion:v1kind:Servicemetadata:name:mysqlspec:ports:- port:3306selector:app:mysqlclusterIP:None---apiVersion:apps/v1kind:Deploymentmetadata:name:mysqlspec:selector:matchLabels:app:mysqlstrategy:type:Recreatetemplate:metadata:labels:app:mysqlspec:containers:- image:mysql:9name:mysqlenv:# Use secret in real usage- name:MYSQL_ROOT_PASSWORDvalue:passwordports:- containerPort:3306name:mysqlvolumeMounts:- name:mysql-persistent-storagemountPath:/var/lib/mysqlvolumes:- name:mysql-persistent-storagepersistentVolumeClaim:claimName:mysql-pv-claim
Наведений вище файл 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 перед створенням нового з оновленою конфігурацією.
Якщо ви надали PersistentVolume вручну, вам також потрібно вручну видалити його й звільнити базовий ресурс. Якщо ви використовували динамічний provisioner, він автоматично видаляє PersistentVolume, коли бачить, що ви видалили PersistentVolumeClaim. Деякі динамічні provisioners (наприклад, для EBS і PD) також звільняють базовий ресурс під час видалення PersistentVolume.
8.5 - Запуск реплікованого застосунку зі збереженням стану
Ця сторінка показує, як запустити реплікований застосунок зі збереженням стану (StatefulSet). Цей застосунок — реплікована база даних MySQL. У топології цього прикладу є один головний сервер і кілька реплік, що використовують асинхронну реплікацію на основі рядків.
Примітка:
Ця конфігурація не призначена для промислового середовища. Налаштування MySQL залишаються на небезпечних типових значеннях, щоб зосередитися на загальних патернах запуску застосунків зі збереженням стану в Kubernetes.
Перш ніж ви розпочнете
Вам треба мати кластер Kubernetes, а також інструмент командного рядка kubectl має бути налаштований для роботи з вашим кластером. Рекомендується виконувати ці настанови у кластері, що має щонайменше два вузли, які не виконують роль вузлів управління. Якщо у вас немає кластера, ви можете створити його, за допомогою minikube або використовувати одну з цих пісочниць:
apiVersion:v1kind:ConfigMapmetadata:name:mysqllabels:app:mysqlapp.kubernetes.io/name:mysqldata:primary.cnf:| # Apply this config only on the primary.
[mysqld]
log-binreplica.cnf:| # Apply this config only on replicas.
[mysqld]
super-read-only
Цей ConfigMap надає перевизначення для my.cnf, що дозволяє вам незалежно керувати конфігурацією на головному сервері MySQL та його репліках. У цьому випадку ви хочете, щоб головний сервер міг надавати логи реплікації реплікам, а репліки відхиляли будь-які записи, які надходять не через реплікацію.
Немає нічого особливого у самому ConfigMap, що зумовлює застосування різних частин до різних Podʼів. Кожен Pod вирішує, яку частину дивитися при ініціалізації, на основі інформації, що надає контролер StatefulSet.
Створення Service
Створіть Service із наступного файлу конфігурації YAML:
# Headless service for stable DNS entries of StatefulSet members.apiVersion:v1kind:Servicemetadata:name:mysqllabels:app:mysqlapp.kubernetes.io/name:mysqlspec:ports:- name:mysqlport:3306clusterIP:Noneselector: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:v1kind:Servicemetadata:name:mysql-readlabels:app:mysqlapp.kubernetes.io/name:mysqlreadonly:"true"spec:ports:- name:mysqlport:3306selector:app:mysql
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:
Ви можете спостерігати за процесом запуску, виконавши:
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 змінюється випадковим чином, оскільки може бути вибрана інша точка доступу при кожній спробі підключення:
Ви можете натиснути 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 переплановується на іншому вузлі:
І знову, ви повинні побачити, що ідентифікатор сервера 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:
Припиніть цикл SELECT @@server_id, натиснувши Ctrl+C в його терміналі або виконавши наступне з іншого терміналу:
kubectl delete pod mysql-client-loop --now
Видаліть StatefulSet. Це також розпочне завершення Podʼів.
kubectl delete statefulset mysql
Перевірте, що Podʼи зникають. Завершення їхньої роботи може зайняти деякий час.
kubectl get pods -l app=mysql
Ви будете знати, що Podʼи завершилися, коли вищезазначена команда поверне:
No resources found.
Видаліть ConfigMap, Services та PersistentVolumeClaims.
kubectl delete configmap,service,pvc -l app=mysql
Якщо ви вручну надавали PersistentVolumes, вам також потрібно вручну видалити їх, а також звільнити відповідні ресурси. Якщо ви використовували динамічний provisioner, він автоматично видаляє PersistentVolumes, коли бачить, що ви видалили PersistentVolumeClaims. Деякі динамічні provisioners (такі як ті, що стосуються EBS та PD) також звільняють відповідні ресурси при видаленні PersistentVolumes.
Не можна зменшити масштаб StatefulSet, коли будь-який зі stateful Podʼів, якими він керує, несправний. Зменшення масштабу відбувається лише після того, як ці stateful Podʼи стануть запущеними й готовими.
Якщо spec.replicas > 1, Kubernetes не може визначити причину несправності Podʼа. Це може бути наслідком постійного або тимчасового збою. Тимчасовий збій може бути спричинений перезапуском, потрібним для оновлення або обслуговування.
Якщо Pod несправний через постійний збій, масштабування без усунення збою може призвести до стану, коли кількість членів StatefulSet опуститься нижче певної мінімальної кількості реплік, потрібних для правильної роботи. Це може призвести до недоступності вашого StatefulSet.
Якщо Pod несправний через тимчасовий збій і може знову стати доступним, тимчасова помилка може завадити операції збільшення або зменшення масштабу. Деякі розподілені бази даних мають проблеми, коли вузли приєднуються й виходять одночасно. У таких випадках краще оцінювати операції масштабування на рівні застосунку й виконувати масштабування лише тоді, коли ви впевнені, що кластер вашого застосунку зі збереженням стану повністю справний.
Це завдання передбачає, що у вас у кластері працює застосунок, представлений 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, їх можна видалити так:
Видалення Podʼів у StatefulSet не призводить до видалення повʼязаних томів. Це зроблено для того, щоб ви мали змогу скопіювати дані з тому перед його видаленням. Видалення PVC після завершення роботи Podʼів може спричинити видалення відповідних постійних томів залежно від класу сховища та політики повторного використання. Ніколи не розраховуйте на доступ до тому після видалення заявки.
Примітка:
Будьте обережні під час видалення PVC, оскільки це може призвести до втрати даних.
Повне видалення StatefulSet
Щоб видалити все у StatefulSet, зокрема повʼязані Podʼи, можна виконати серію команд, подібних до наведених нижче:
У наведеному вище прикладі Podʼи мають мітку app.kubernetes.io/name=MyApp; за потреби підставте власну мітку.
Примусове видалення Podʼів StatefulSet
Якщо деякі Podʼи у вашому StatefulSet тривалий час залишаються у стані 'Terminating' або 'Unknown', може знадобитися втрутитися вручну, щоб примусово видалити Podʼи з API-сервера. Це потенційно небезпечне завдання. Докладніше дивіться в розділі Примусове видалення 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-сервера лише такими способами:
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, виконайте таке:
8.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, щоб додати нові види ресурсів, які представляють показники метрик.
Якщо ви використовуєте Minikube, виконайте таку команду, щоб увімкнути metrics-server:
minikube addons enable metrics-server
Запустіть сервер php-apache і відкрийте до нього доступ
Щоб продемонструвати HorizontalPodAutoscaler, ви спочатку запустите Deployment, який запускає контейнер з образом hpa-example, і відкриєте до нього доступ як до Service за допомогою такого маніфесту:
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, виконавши:
# Можна використовувати "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:
Зверніть увагу, що поле targetCPUUtilizationPercentage замінено масивом під назвою metrics. Метрика використання CPU є метрикою ресурсу, оскільки вона подана як відсоток ресурсу, вказаного в контейнерах Podʼа. Зверніть увагу, що ви можете вказати інші метрики ресурсів, крім CPU. Стандартно єдина інша підтримувана метрика ресурсу — це memory. Ці ресурси не змінюють назв від кластера до кластера й мають бути доступними завжди, доки доступний API metrics.k8s.io.
Ви також можете вказувати метрики ресурсів у безпосередніх значеннях, а не у відсотках від запитаного значення, використовуючи target.type зі значенням AverageValue замість Utilization і встановлюючи відповідне поле target.averageValue замість target.averageUtilization.
Є ще два типи метрик, обидва вважаються власними метриками: метрики Podʼів і метрики обʼєктів. Ці метрики можуть мати назви, специфічні для кластера, і потребують розширенішого налаштування моніторингу кластера.
Перший із цих альтернативних типів метрик — це метрики Podʼів. Ці метрики описують Podʼи, усереднюються по Podʼах і порівнюються з цільовим значенням для визначення кількості реплік. Вони працюють майже так само, як метрики ресурсів, за винятком того, що підтримують лише тип targetAverageValue.
Метрики Podʼів вказуються за допомогою такого блоку метрики:
Другий альтернативний тип метрики — це метрики обʼєктів. Ці метрики описують інший обʼєкт у тому самому просторі імен, а не Podʼи. Метрики не обовʼязково отримуються з обʼєкта; вони лише описують його. Метрики обʼєктів підтримують типи targetValue і AverageValue. Для Value ціль порівнюється безпосередньо з метрикою, отриманою з API. Для AverageValue значення, отримане з API власних метрик, ділиться на кількість Podʼів перед порівнянням із ціллю. Наведений нижче приклад — це подання метрики requests-per-second у YAML.
Якщо ви надаєте кілька таких блоків метрик, HorizontalPodAutoscaler розглядатиме кожну метрику по черзі. HorizontalPodAutoscaler обчислить запропоновану кількість реплік для кожної метрики, а потім вибере найбільшу.
Наприклад, якщо ваша система моніторингу збирає метрики мережевого трафіку, ви можете оновити наведене вище визначення за допомогою kubectl edit, щоб воно мало такий вигляд:
Тоді ваш HorizontalPodAutoscaler намагатиметься забезпечити, щоб кожен Pod споживав приблизно 50% запитаного CPU, обслуговував 1000 пакетів за секунду, а всі Podʼи за Ingress main-route разом обслуговували 10000 запитів за секунду.
Автомасштабування за конкретнішими метриками
Багато конвеєрів метрик дають змогу описувати метрики або за назвою, або за набором додаткових дескрипторів, які називаються мітками. Для всіх типів метрик, крім метрик ресурсів (Podʼів, обʼєктів і зовнішніх, описаних нижче), ви можете вказати додатковий селектор міток, який передається вашому конвеєру метрик. Наприклад, якщо ви збираєте метрику http_requests з міткою verb, можна вказати такий блок метрики, щоб масштабувати лише за запитами GET:
Цей селектор використовує той самий синтаксис, що й повні селектори міток Kubernetes. Конвеєр моніторингу визначає, як згорнути кілька серій в одне значення, якщо назва й селектор відповідають кільком серіям. Селектор є адитивним і не може вибирати метрики, що описують обʼєкти, які не є цільовим обʼєктом (цільові Podʼи для типу Pods та описаний обʼєкт для типу Object).
Автомасштабування за метриками, що не стосуються обʼєктів Kubernetes
Застосунки, що працюють у Kubernetes, можуть потребувати автомасштабування за метриками, які не мають очевидного звʼязку з жодним обʼєктом у кластері Kubernetes, наприклад метриками, що описують розміщений сервіс, який не має прямої кореляції з просторами імен Kubernetes. У Kubernetes 1.10 і новіших версіях цей випадок можна вирішити за допомогою зовнішніх метрик.
Використання зовнішніх метрик потребує знання вашої системи моніторингу; налаштування подібне до потрібного для власних метрик. Зовнішні метрики дають змогу автоматично масштабувати кластер на основі будь-якої метрики, доступної у вашій системі моніторингу. Надайте блок metric з name і selector, як вище, і використовуйте тип метрики External замість Object. Якщо metricSelector відповідає кільком часовим рядам, HorizontalPodAutoscaler використовує суму їхніх значень. Зовнішні метрики підтримують цільові типи Value і AverageValue, які працюють точно так само, як і для типу Object.
Наприклад, якщо ваш застосунок обробляє завдання з розміщеного сервісу черг, ви можете додати такий розділ до маніфесту HorizontalPodAutoscaler, щоб вказати, що потрібен один обробник на кожні 30 невиконаних завдань.
Коли це можливо, краще використовувати цільові типи власних метрик замість зовнішніх метрик, оскільки адміністраторам кластера легше захистити 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, можна створити його декларативно за допомогою такого маніфесту:
horizontalpodautoscaler.autoscaling/php-apache created
8.10 - Вказання бюджету порушень для вашого застосунку
СТАН ФУНКЦІОНАЛУ:GA since Kubernetes v1.21
На цій сторінці показано, як обмежити кількість одночасних порушень, яких зазнає ваш застосунок, що підвищує доступність і водночас дозволяє адміністратору кластера керувати вузлами кластера.
Перш ніж ви розпочнете
Версія вашого Kubernetes сервера має бути не старішою ніж v1.21.
Для перевірки версії введіть kubectl version.
Ви є власником застосунку, який працює в кластері Kubernetes і потребує високої доступності.
Вам слід підтвердити з власником кластера або постачальником послуг, що вони дотримуються бюджетів порушень Podʼів.
Захист застосунку за допомогою PodDisruptionBudget
Визначте, який застосунок ви хочете захистити за допомогою PodDisruptionBudget (PDB).
Подумайте, як ваш застосунок реагує на порушення.
Створіть визначення PDB у вигляді файлу YAML.
Створіть обʼєкт PDB з файлу YAML.
Визначення застосунку для захисту
Найпоширеніший випадок — коли потрібно захистити застосунок, визначений одним із вбудованих контролерів Kubernetes:
Deployment
ReplicationController
ReplicaSet
StatefulSet
У цьому випадку запишіть .spec.selector контролера; той самий селектор використовується в .spec.selector PDB.
Починаючи з версії 1.15, PDB підтримують власні контролери, у яких увімкнено субресурс масштабування.
Також можна використовувати PDB з Podʼами, які не контролюються одним із наведених вище контролерів, або з довільними групами Podʼів, але є деякі обмеження, описані в розділі Довільні робочі навантаження та довільні селектори.
Подумайте, як ваш застосунок реагує на порушення
Вирішіть, скільки екземплярів може бути вимкнено одночасно протягом короткого часу через добровільне порушення.
Фронтенди без збереження стану:
Застереження: не зменшуйте потужність обслуговування більш ніж на 10%.
Рішення: наприклад, використовуйте PDB з minAvailable 90%.
Одноекземплярний застосунок зі збереженням стану:
Застереження: не завершуйте цей застосунок, не поговоривши зі мною.
Можливе рішення 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.
Наприклад, якщо наведений вище обʼєкт 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 за допомогою цієї команди:
Поточна реалізація вважає справними 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 на інший.
8.11 - Отримання доступу до API Kubernetes з Podʼа
У цьому посібнику показано, як отримати доступ до API Kubernetes зсередини Podʼа.
Перш ніж ви розпочнете
Вам треба мати кластер Kubernetes, а також інструмент командного рядка kubectl має бути налаштований для роботи з вашим кластером. Рекомендується виконувати ці настанови у кластері, що має щонайменше два вузли, які не виконують роль вузлів управління. Якщо у вас немає кластера, ви можете створити його, за допомогою minikube або використовувати одну з цих пісочниць:
Під час доступу до API зсередини Podʼа пошук API-сервера й автентифікація на ньому дещо відрізняються від випадку зовнішнього клієнта.
Найпростіший спосіб використовувати API Kubernetes із Podʼа — застосувати одну з офіційних клієнтських бібліотек. Ці бібліотеки можуть автоматично знаходити API-сервер і автентифікуватися.
Використання офіційних клієнтських бібліотек
Зсередини Podʼа рекомендовано підʼєднуватися до API Kubernetes такими способами:
Для клієнта Go використовуйте офіційну клієнтську бібліотеку Go. Функція rest.InClusterConfig() автоматично виконує виявлення хоста API й автентифікацію. Дивіться приклад тут.
Для клієнта Python використовуйте офіційну клієнтську бібліотеку Python. Функція config.load_incluster_config() автоматично виконує виявлення хоста API й автентифікацію. Дивіться приклад тут.
У кожному випадку для безпечного звʼязку з API-сервером використовуються облікові дані службового облікового запису Podʼа.
Прямий доступ до REST API
Під час роботи в Podʼі ваш контейнер може сформувати HTTPS URL для API-сервера Kubernetes, отримавши змінні середовища KUBERNETES_SERVICE_HOST і KUBERNETES_SERVICE_PORT_HTTPS. Внутрішньокластерну адресу API-сервера також опубліковано в Service з назвою kubernetes у просторі імен default, тож Podʼи можуть використовувати kubernetes.default.svc як DNS-імʼя локального API-сервера.
Примітка:
Kubernetes не гарантує, що API-сервер має дійсний сертифікат для імені хоста kubernetes.default.svc; однак від панелі управління очікується, що вона надасть дійсний сертифікат для імені хоста або IP-адреси, які представляє $KUBERNETES_SERVICE_HOST.
Рекомендований спосіб автентифікації на API-сервері — за допомогою облікових даних службового облікового запису. Стандартно Pod повʼязаний зі службовим обліковим записом, а облікові дані (токен) цього запису розміщуються в дереві файлової системи кожного контейнера цього Podʼа, у /var/run/secrets/kubernetes.io/serviceaccount/token.
Якщо доступний, набір сертифікатів розміщується в дереві файлової системи кожного контейнера у /var/run/secrets/kubernetes.io/serviceaccount/ca.crt, і його слід використовувати для перевірки серверного сертифіката API-сервера.
Нарешті, стандартний простір імен для операцій API в межах простору імен розміщується у файлі /var/run/secrets/kubernetes.io/serviceaccount/namespace у кожному контейнері.
Використання kubectl proxy
Якщо ви хочете надсилати запити до API без офіційної клієнтської бібліотеки, можна запустити kubectl proxy як команду нового sidecar-контейнера в Podʼі. Так kubectl proxy автентифікуватиметься в API й відкриє доступ до нього на інтерфейсі localhost Podʼа, щоб інші контейнери в Podʼі могли використовувати його безпосередньо.
Без використання проксі
Можна обійтися без kubectl proxy, передаючи токен автентифікації безпосередньо API-серверу. Внутрішній сертифікат захищає зʼєднання.
# Вказати імʼя хоста внутрішнього API-сервераAPISERVER=https://kubernetes.default.svc
# Шлях до токена ServiceAccountSERVICEACCOUNT=/var/run/secrets/kubernetes.io/serviceaccount
# Прочитати простір імен цього PodʼаNAMESPACE=$(cat ${SERVICEACCOUNT}/namespace)# Прочитати bearer-токен ServiceAccountTOKEN=$(cat ${SERVICEACCOUNT}/token)# Вказати внутрішній центр сертифікації (CA)CACERT=${SERVICEACCOUNT}/ca.crt
# Досліджувати API за допомогою TOKENcurl --cacert ${CACERT} --header "Authorization: Bearer ${TOKEN}" -X GET ${APISERVER}/api
9.1 - Виконання автоматизованих завдань за допомогою CronJob
На цій сторінці показано, як виконувати автоматизовані завдання за допомогою обʼєкта Kubernetes CronJob.
Перш ніж ви розпочнете
Вам треба мати кластер Kubernetes, а також інструмент командного рядка kubectl має бути налаштований для роботи з вашим кластером. Рекомендується виконувати ці настанови у кластері, що має щонайменше два вузли, які не виконують роль вузлів управління. Якщо у вас немає кластера, ви можете створити його, за допомогою minikube або використовувати одну з цих пісочниць:
Після створення CronJob отримайте його статус за допомогою цієї команди:
kubectl get cronjob hello
Вивід подібний до такого:
NAME SCHEDULE SUSPEND ACTIVE LAST SCHEDULE AGE
hello */1 * * * * False 0 <none> 10s
Як видно з результатів команди, CronJob ще не запланував і не запустив жодного Job. Відстежуйте створення Job упродовж приблизно однієї хвилини:
kubectl get jobs --watch
Вивід подібний до такого:
NAME COMPLETIONS DURATION AGE
hello-4111706356 0/1 0s
hello-4111706356 0/1 0s 0s
hello-4111706356 1/1 5s 5s
Тепер ви побачили один запущений Job, запланований CronJob "hello". Ви можете припинити відстеження Job і знову переглянути CronJob, щоб побачити, що він запланував Job:
kubectl get cronjob hello
Вивід подібний до такого:
NAME SCHEDULE SUSPEND ACTIVE LAST SCHEDULE AGE
hello */1 * * * * False 0 50s 75s
Ви маєте побачити, що CronJob hello успішно запланував Job у час, вказаний у LAST SCHEDULE. Наразі активних Jobs 0, тобто Job завершився успішно або з помилкою.
Тепер знайдіть Podʼи, які створив останній запланований Job, і перегляньте стандартний вивід одного з Podʼів.
Примітка:
Назва Job відрізняється від назви Podʼа.
# Замініть "hello-4111706356" на назву Job у вашій системіpods=$(kubectl get pods --selector=job-name=hello-4111706356 --output=jsonpath={.items[*].metadata.name})
Покажіть лог Podʼа:
kubectl logs $pods
Вивід подібний до такого:
Fri Feb 22 11:02:09 UTC 2019
Hello from the Kubernetes cluster
Видалення CronJob
Коли CronJob більше не потрібен, видаліть його за допомогою kubectl delete cronjob <cronjob name>:
kubectl delete cronjob hello
Видалення CronJob вилучає всі створені ним Jobs і Podʼи та зупиняє створення нових Jobs. Докладніше про вилучення Jobs читайте в розділі збір сміття.
9.2 - Груба паралельна обробка за допомогою робочої черги
У цьому прикладі ви запустите Job Kubernetes з кількома паралельними робочими процесами.
У цьому прикладі кожен створений Pod бере одну одиницю роботи з черги завдань, виконує її, видаляє її з черги та завершує роботу.
Ось огляд кроків у цьому прикладі:
Запустіть сервіс черги повідомлень. У цьому прикладі використовується RabbitMQ, але можна використати інший. На практиці ви налаштували б сервіс черги повідомлень один раз і повторно використовували б його для багатьох Jobs.
Створіть чергу й заповніть її повідомленнями. Кожне повідомлення представляє одне завдання, яке потрібно виконати. У цьому прикладі повідомлення — це ціле число, над яким ми виконаємо тривалі обчислення.
Запустіть Job, який працює над завданнями з черги. Job запускає кілька Podʼів. Кожен Pod бере одне завдання з черги повідомлень, обробляє його й завершує роботу.
Перш ніж ви розпочнете
Ви вже маєте знати базове, непаралельне використання Job.
Вам треба мати кластер Kubernetes, а також інструмент командного рядка kubectl має бути налаштований для роботи з вашим кластером. Рекомендується виконувати ці настанови у кластері, що має щонайменше два вузли, які не виконують роль вузлів управління. Якщо у вас немає кластера, ви можете створити його, за допомогою minikube або використовувати одну з цих пісочниць:
Вам знадобиться реєстр образів контейнерів, куди можна завантажувати образи для запуску у вашому кластері.
Цей приклад завдання також передбачає, що Docker встановлено локально.
Запуск сервісу черги повідомлень
У цьому прикладі використовується RabbitMQ, проте ви можете адаптувати його для іншого сервісу повідомлень типу AMQP.
На практиці ви можете один раз налаштувати сервіс черги повідомлень у кластері й повторно використовувати його для багатьох Jobs, а також для довготривалих сервісів.
Запустіть RabbitMQ таким чином:
# Створіть Service для використання StatefulSetkubectl create -f https://kubernetes.io/examples/application/job/rabbitmq/rabbitmq-service.yaml
Тепер можна спробувати звернутися до черги повідомлень. Ми створимо тимчасовий інтерактивний Pod, встановимо на ньому деякі інструменти й поекспериментуємо з чергами.
Waiting for pod default/temp-loe07 to be running, status is Pending, pod ready: false
... [ previous line repeats several times .. hit return when it stops ] ...
Зверніть увагу, що назва вашого Podʼа й запрошення командного рядка будуть іншими.
Далі встановіть amqp-tools, щоб працювати з чергами повідомлень. Наведені нижче команди показують, що потрібно виконати в інтерактивній оболонці цього Podʼа:
Якщо надбудову DNS кластера налаштовано неправильно, попередній крок може не спрацювати. Ви також можете знайти IP-адресу цього Service у змінній середовища:
# виконайте цю перевірку всередині Podʼаenv | grep RABBITMQ_SERVICE | grep HOST
RABBITMQ_SERVICE_SERVICE_HOST=10.0.147.152
(IP-адреса буде іншою)
Далі перевірте, чи можете створити чергу, а також публікувати й отримувати повідомлення.
# Виконайте ці команди всередині Podʼа# У наступному рядку rabbitmq-service — це імʼя хоста, за яким доступний rabbitmq-service.# 5672 — стандартний порт rabbitmq.exportBROKER_URL=amqp://guest:guest@rabbitmq-service:5672
# Якщо на попередньому кроці не вдалося розвʼязати "rabbitmq-service",# використайте натомість цю команду:BROKER_URL=amqp://guest:guest@$RABBITMQ_SERVICE_SERVICE_HOST:5672
# Тепер створіть чергу:/usr/bin/amqp-declare-queue --url=$BROKER_URL -q foo -d
foo
Опублікуйте одне повідомлення в чергу:
/usr/bin/amqp-publish --url=$BROKER_URL -r foo -p -b Hello
# І отримайте його назад./usr/bin/amqp-consume --url=$BROKER_URL -q foo -c 1 cat &&echo 1>&2
Hello
В останній команді інструмент amqp-consume взяв одне повідомлення (-c 1) із черги й передав його на стандартний ввід довільної команди. У цьому випадку програма cat виводить символи, прочитані зі стандартного вводу, а echo додає повернення каретки, щоб приклад було зручно читати.
Заповнення черги завданнями
Тепер заповніть чергу кількома імітованими завданнями. У цьому прикладі завдання — це рядки, які потрібно вивести.
На практиці вміст повідомлень може бути таким:
назви файлів, які потрібно обробити
додаткові прапорці для програми
діапазони ключів у таблиці бази даних
параметри конфігурації для симуляції
номери кадрів сцени для рендерингу
Якщо всім Podʼам Job потрібні великі дані лише для читання, їх зазвичай розміщують у спільній файловій системі на кшталт NFS і монтують лише для читання в усі Podʼи або пишуть програму в Podʼі так, щоб вона могла напряму читати дані з кластерної файлової системи (наприклад, HDFS).
У цьому прикладі ви створите чергу й заповните її за допомогою інструментів командного рядка AMQP. На практиці можна написати програму для заповнення черги за допомогою клієнтської бібліотеки AMQP.
# Виконайте це на вашому компʼютері, а не в Podʼі/usr/bin/amqp-declare-queue --url=$BROKER_URL -q job1 -d
job1
Додайте елементи до черги:
for f in apple banana cherry date fig grape lemon melon
do /usr/bin/amqp-publish --url=$BROKER_URL -r job1 -p -b $fdone
Ви додали 8 повідомлень до черги.
Створення образу контейнера
Тепер ви готові створити образ, який ви будете запускати як Job.
Job використовуватиме утиліту amqp-consume, щоб читати повідомлення з черги й виконувати фактичну роботу. Ось дуже простий приклад програми:
#!/usr/bin/env python# Just prints standard out and sleeps for 10 seconds.importsysimporttimeprint("Processing "+sys.stdin.readlines()[0])time.sleep(10)
Надайте скрипту дозвіл на виконання:
chmod +x worker.py
Тепер зберіть образ. Створіть тимчасову теку, перейдіть до неї, завантажте Dockerfile і worker.py. У будь-якому разі зберіть образ за допомогою цієї команди:
docker build -t job-wq-1 .
Для Docker Hub додайте до образу застосунку теґ зі своїм іменем користувача й надішліть його в Hub наведеними нижче командами. Замініть <username> своїм іменем користувача Hub.
docker tag job-wq-1 <username>/job-wq-1
docker push <username>/job-wq-1
Якщо ви використовуєте інший реєстр образів контейнерів, додайте теґ до образу й надішліть його туди.
Визначення Job
Ось маніфест Job. Потрібно зробити копію маніфесту Job (назвіть її ./job.yaml) і змінити назву образу контейнера на ту, яку ви використали.
У цьому прикладі кожен Pod працює над одним елементом із черги, а потім завершує роботу. Отже, кількість завершень Job відповідає кількості виконаних робочих елементів. Тому в маніфесті прикладу .spec.completions дорівнює 8.
Запуск Job
Тепер запустіть Job:
# це передбачає, що ви вже завантажили та відредагували маніфестkubectl apply -f ./job.yaml
Ви можете зачекати на успішне завершення Job із тайм-аутом:
# Перевірка назви умови не залежить від регіструkubectl wait --for=condition=complete --timeout=300s job/job-wq-1
Далі перевірте Job:
kubectl describe jobs/job-wq-1
Name: job-wq-1
Namespace: default
Selector: controller-uid=41d75705-92df-11e7-b85e-fa163ee3c11f
Labels: controller-uid=41d75705-92df-11e7-b85e-fa163ee3c11f
job-name=job-wq-1
Annotations: <none>
Parallelism: 2
Completions: 8
Start Time: Wed, 06 Sep 2022 16:42:02 +0000
Pods Statuses: 0 Running / 8 Succeeded / 0 Failed
Pod Template:
Labels: controller-uid=41d75705-92df-11e7-b85e-fa163ee3c11f
job-name=job-wq-1
Containers:
c:
Image: container-registry.example/causal-jigsaw-637/job-wq-1
Port:
Environment:
BROKER_URL: amqp://guest:guest@rabbitmq-service:5672
QUEUE: job1
Mounts: <none>
Volumes: <none>
Events:
FirstSeen LastSeen Count From SubobjectPath Type Reason Message
───────── ──────── ───── ──── ───────────── ────── ────── ───────
27s 27s 1 {job } Normal SuccessfulCreate Created pod: job-wq-1-hcobb
27s 27s 1 {job } Normal SuccessfulCreate Created pod: job-wq-1-weytj
27s 27s 1 {job } Normal SuccessfulCreate Created pod: job-wq-1-qaam5
27s 27s 1 {job } Normal SuccessfulCreate Created pod: job-wq-1-b67sr
26s 26s 1 {job } Normal SuccessfulCreate Created pod: job-wq-1-xe5hj
15s 15s 1 {job } Normal SuccessfulCreate Created pod: job-wq-1-w2zqe
14s 14s 1 {job } Normal SuccessfulCreate Created pod: job-wq-1-d6ppa
14s 14s 1 {job } Normal SuccessfulCreate Created pod: job-wq-1-p17e0
Усі Podʼи цього Job завершилися успішно! Готово.
Альтернативи
Перевага цього підходу в тому, що вам не потрібно змінювати свою програму-«робітника», щоб вона знала про робочу чергу. Ви можете додати незмінену робочу програму до образу контейнера.
Цей підхід потребує запуску сервісу черги повідомлень. Якщо запускати сервіс черги незручно, варто розглянути один з інших шаблонів Job.
Цей підхід створює Pod для кожного робочого елемента. Однак якщо робочі елементи виконуються лише кілька секунд, створення Podʼа для кожного з них може додати значні накладні витрати. Розгляньте інший підхід, наприклад із прикладу тонкої паралельної робочої черги, де один Pod виконує кілька робочих елементів.
У цьому прикладі ви використали утиліту amqp-consume, щоб читати повідомлення з черги й запускати фактичну програму. Перевага в тому, що програму не потрібно змінювати, щоб вона знала про чергу. У прикладі тонкої паралельної робочої черги показано, як взаємодіяти з робочою чергою за допомогою клієнтської бібліотеки.
Застереження
Якщо кількість завершень менша за кількість елементів у черзі, не всі елементи буде оброблено.
Якщо кількість завершень більша за кількість елементів у черзі, Job не вважатиметься завершеним, навіть якщо всі елементи в черзі оброблено. Він запускатиме додаткові Podʼи, які блокуватимуться в очікуванні повідомлення. Вам потрібно створити власний механізм, щоб виявляти наявність роботи й вимірювати розмір черги, задаючи відповідну кількість завершень.
У цього шаблону є малоймовірний стан гонитви. Якщо контейнер буде завершено між моментом, коли команда amqp-consume підтвердила повідомлення, і моментом успішного завершення контейнера, або якщо вузол вийде з ладу, перш ніж kubelet зможе надіслати API-серверу повідомлення про успіх Podʼа, Job не вважатиметься завершеним, навіть якщо всі елементи в черзі оброблено.
9.3 - Indexed Job для паралельної обробки зі статичним призначенням роботи
СТАН ФУНКЦІОНАЛУ:GA since Kubernetes v1.24
У цьому прикладі ви запустите Job Kubernetes, який використовує кілька паралельних робочих процесів. Кожен робочий процес — це окремий контейнер, що працює у власному Podʼі. Podʼи мають індексний номер, який автоматично встановлює панель управління, і це дозволяє кожному Podʼу визначити, над якою частиною загального завдання працювати.
Індекс Podʼа доступний в анотаціїbatch.kubernetes.io/job-completion-index як рядок із його десятковим значенням. Щоб контейнеризований процес завдання отримав цей індекс, можна опублікувати значення анотації за допомогою механізму downward API. Для зручності панель управління автоматично налаштовує downward API так, щоб індекс був доступний у змінній середовища JOB_COMPLETION_INDEX.
Нижче наведено огляд кроків у цьому прикладі:
Визначте маніфест Job з індексованим завершенням. Downward API дозволяє передати анотацію індексу Podʼа контейнеру як змінну середовища або файл.
Запустіть Indexed Job на основі цього маніфесту.
Перш ніж ви розпочнете
Ви вже маєте знати базове, непаралельне використання Job.
Вам треба мати кластер Kubernetes, а також інструмент командного рядка kubectl має бути налаштований для роботи з вашим кластером. Рекомендується виконувати ці настанови у кластері, що має щонайменше два вузли, які не виконують роль вузлів управління. Якщо у вас немає кластера, ви можете створити його, за допомогою minikube або використовувати одну з цих пісочниць:
Версія вашого Kubernetes сервера має бути не старішою ніж v1.21.
Для перевірки версії введіть kubectl version.
Оберіть підхід
Щоб отримати доступ до робочого елемента з програми робочого процесу, є кілька варіантів:
Прочитати змінну середовища JOB_COMPLETION_INDEX. Контролер Job автоматично повʼязує цю змінну з анотацією, що містить індекс завершення.
Прочитати файл, який містить індекс завершення.
Якщо програму не можна змінити, її можна обгорнути скриптом, який читає індекс будь-яким із наведених вище способів і перетворює його на щось, що програма може використати як вхідні дані.
У цьому прикладі уявіть, що ви обрали варіант 3 і хочете запустити утиліту rev. Ця програма приймає файл як аргумент і виводить його вміст у зворотному порядку.
rev data.txt
Ви використаєте інструмент rev з образу контейнера busybox.
Оскільки це лише приклад, кожен Pod виконує лише дрібну частину роботи (розвертає короткий рядок). У реальному робочому навантаженні ви могли б, наприклад, створити Job, що представляє завдання створення 60 секунд відео на основі даних сцени. Кожним робочим елементом у Job рендерингу відео був би рендеринг певного кадру цього відеокліпу. Індексоване завершення означало б, що кожен Pod у Job знає, який кадр рендерити й публікувати, рахуючи кадри від початку кліпу.
Визначте Indexed Job
Ось приклад маніфесту Job, який використовує режим завершення Indexed:
У наведеному вище прикладі ви використовуєте вбудовану змінну середовища JOB_COMPLETION_INDEX, яку контролер Job встановлює для всіх контейнерів. Init-контейнер зіставляє індекс зі статичним значенням і записує його у файл, спільний із контейнером робочого процесу через том emptyDir. За бажання можна визначити власну змінну середовища через downward API, щоб публікувати індекс у контейнери. Також можна завантажити список значень із ConfigMap як змінну середовища або файл.
# Це використовує перший підхід (покладаючись на $JOB_COMPLETION_INDEX)kubectl apply -f https://kubernetes.io/examples/application/job/indexed-job.yaml
Коли ви створюєте цей Job, панель управління створює серію Podʼів, по одному для кожного вказаного індексу. Значення .spec.parallelism визначає, скільки їх може працювати одночасно, а .spec.completions визначає, скільки Podʼів Job створює загалом.
Оскільки .spec.parallelism менше за .spec.completions, панель управління чекає завершення деяких перших Podʼів, перш ніж запускати нові.
Ви можете зачекати на успішне завершення Job із тайм-аутом:
# Перевірка назви умови не залежить від регіструkubectl wait --for=condition=complete --timeout=300s job/indexed-job
Тепер перегляньте опис Job і переконайтеся, що він успішний.
kubectl describe jobs/indexed-job
Вивід подібний до такого:
Name: indexed-job
Namespace: default
Selector: controller-uid=bf865e04-0b67-483b-9a90-74cfc4c3e756
Labels: controller-uid=bf865e04-0b67-483b-9a90-74cfc4c3e756
job-name=indexed-job
Annotations: <none>
Parallelism: 3
Completions: 5
Start Time: Thu, 11 Mar 2021 15:47:34 +0000
Pods Statuses: 2 Running / 3 Succeeded / 0 Failed
Completed Indexes: 0-2
Pod Template:
Labels: controller-uid=bf865e04-0b67-483b-9a90-74cfc4c3e756
job-name=indexed-job
Init Containers:
input:
Image: docker.io/library/bash
Port: <none>
Host Port: <none>
Command:
bash
-c
items=(foo bar baz qux xyz)
echo ${items[$JOB_COMPLETION_INDEX]} > /input/data.txt
Environment: <none>
Mounts:
/input from input (rw)
Containers:
worker:
Image: docker.io/library/busybox
Port: <none>
Host Port: <none>
Command:
rev
/input/data.txt
Environment: <none>
Mounts:
/input from input (rw)
Volumes:
input:
Type: EmptyDir (a temporary directory that shares a pod's lifetime)
Medium:
SizeLimit: <unset>
Events:
Type Reason Age From Message
---- ------ ---- ---- -------
Normal SuccessfulCreate 4s job-controller Created pod: indexed-job-njkjj
Normal SuccessfulCreate 4s job-controller Created pod: indexed-job-9kd4h
Normal SuccessfulCreate 4s job-controller Created pod: indexed-job-qjwsz
Normal SuccessfulCreate 1s job-controller Created pod: indexed-job-fdhq5
Normal SuccessfulCreate 1s job-controller Created pod: indexed-job-ncslj
У цьому прикладі ви запускаєте Job із власними значеннями для кожного індексу. Ви можете переглянути вивід одного з Podʼів:
kubectl logs indexed-job-fdhq5 # Змініть це на назву Podʼа з цього Job
Вивід подібний до такого:
xuq
9.4 - Job із взаємодією між Podʼами
У цьому прикладі ви запустите Job у режимі завершення Indexed, налаштований так, щоб Podʼи, створені Job, могли взаємодіяти між собою за іменами хостів Podʼів, а не за IP-адресами Podʼів.
Podʼам у межах Job може знадобитися взаємодіяти між собою. Робоче навантаження користувача в кожному Podʼі могло б запитувати API-сервер Kubernetes, щоб дізнатися IP-адреси інших Podʼів, але набагато простіше покладатися на вбудоване в Kubernetes розвʼязання DNS.
Jobs у режимі завершення Indexed автоматично задають імена хостів Podʼів у форматі ${jobName}-${completionIndex}. Цей формат дозволяє детерміновано будувати імена хостів Podʼів і забезпечувати взаємодію між Podʼами без потреби створювати клієнтське зʼєднання з панеллю управління Kubernetes для отримання імен хостів або IP-адрес Podʼів через запити API.
Ця конфігурація корисна для сценаріїв, де потрібна мережева взаємодія Podʼів, але ви не хочете залежати від мережевого зʼєднання з API-сервером Kubernetes.
Вам треба мати кластер Kubernetes, а також інструмент командного рядка kubectl має бути налаштований для роботи з вашим кластером. Рекомендується виконувати ці настанови у кластері, що має щонайменше два вузли, які не виконують роль вузлів управління. Якщо у вас немає кластера, ви можете створити його, за допомогою minikube або використовувати одну з цих пісочниць:
Версія вашого Kubernetes сервера має бути не старішою ніж v1.21.
Для перевірки версії введіть kubectl version.
Примітка:
Якщо ви використовуєте minikube або подібний інструмент, може знадобитися виконати додаткові кроки, щоб забезпечити наявність DNS.
Запуск Job із взаємодією між Podʼами
Щоб увімкнути взаємодію між Podʼами за іменами хостів Podʼів у Job, потрібно зробити таке:
Налаштуйте headless Service із дійсним селектором міток для Podʼів, створених вашим Job. Headless Service має бути в тому самому просторі імен, що й Job. Простий спосіб зробити це — використати селектор job-name: <your-job-name>, оскільки Kubernetes автоматично додає мітку job-name. Ця конфігурація спонукає систему DNS створити записи імен хостів Podʼів, що виконують ваш Job.
Налаштуйте headless Service як сервіс піддомену для Podʼів Job, додавши таке значення до специфікації шаблону Job:
subdomain:<headless-svc-name>
Приклад
Нижче наведено робочий приклад Job з увімкненою взаємодією між Podʼами за іменами хостів Podʼів. Job завершується лише після того, як усі Podʼи успішно пропінгують один одного за іменами хостів.
Примітка:
У скрипті Bash, який виконується в кожному Podʼі у наведеному нижче прикладі, імена хостів Podʼів можуть також мати префікс простору імен, якщо Pod має бути доступний ззовні простору імен.
apiVersion:v1kind:Servicemetadata:name:headless-svcspec:clusterIP:None# clusterIP має бути None для створення headless Serviceselector:job-name:example-job# має відповідати назві Job---apiVersion:batch/v1kind:Jobmetadata:name:example-jobspec:completions:3parallelism:3completionMode:Indexedtemplate:spec:subdomain:headless-svc# має відповідати назві ServicerestartPolicy:Nevercontainers:- name:example-workloadimage:bash:latestcommand:- bash- -c- | for i in 0 1 2
do
gotStatus="-1"
wantStatus="0"
while [ $gotStatus -ne $wantStatus ]
do
ping -c 1 example-job-${i}.headless-svc > /dev/null 2>&1
gotStatus=$?
if [ $gotStatus -ne $wantStatus ]; then
echo "Failed to ping pod example-job-${i}.headless-svc, retrying in 1 second..."
sleep 1
fi
done
echo "Successfully pinged pod: example-job-${i}.headless-svc"
done
Після застосування наведеного вище прикладу Podʼи зможуть звертатися один до одного через мережу за допомогою <pod-hostname>.<headless-service-name>. Ви маєте побачити вивід, подібний до такого:
kubectl logs example-job-0-qws42
Failed to ping pod example-job-0.headless-svc, retrying in 1 second...
Successfully pinged pod: example-job-0.headless-svc
Successfully pinged pod: example-job-1.headless-svc
Successfully pinged pod: example-job-2.headless-svc
Примітка:
Майте на увазі, що формат назви <pod-hostname>.<headless-service-name>, використаний у цьому прикладі, не працюватиме з політикою DNS None або Default. Дивіться Політику DNS Podʼа.
9.5 - Тонка паралельна обробка за допомогою робочої черги
У цьому прикладі ви запустите Job Kubernetes, який виконує кілька паралельних завдань як робочі процеси, кожен з яких працює в окремому Podʼі.
У цьому прикладі кожен створений Pod бере одну одиницю роботи з черги завдань, обробляє її й повторює це, доки не буде досягнуто кінця черги.
Ось загальний огляд кроків у цьому прикладі:
Запустіть сервіс зберігання для робочої черги. У цьому прикладі ви використаєте Redis для зберігання робочих елементів. У попередньому прикладі ви використовували RabbitMQ. У цьому прикладі ви використаєте Redis і власну клієнтську бібліотеку робочої черги, тому що AMQP не дає клієнтам зручного способу виявити, що робоча черга скінченної довжини порожня. На практиці ви один раз налаштуєте сховище на кшталт Redis і повторно використовуватимете його для робочих черг багатьох Jobs та для інших потреб.
Створіть чергу й заповніть її повідомленнями. Кожне повідомлення представляє одне завдання, яке потрібно виконати. У цьому прикладі повідомлення — це ціле число, над яким ми виконаємо тривалі обчислення.
Запустіть Job, який працює над завданнями з черги. Job запускає кілька Podʼів. Кожен Pod бере одне завдання з черги повідомлень, обробляє його й повторює це, доки не буде досягнуто кінця черги.
Перш ніж ви розпочнете
Вам треба мати кластер Kubernetes, а також інструмент командного рядка kubectl має бути налаштований для роботи з вашим кластером. Рекомендується виконувати ці настанови у кластері, що має щонайменше два вузли, які не виконують роль вузлів управління. Якщо у вас немає кластера, ви можете створити його, за допомогою minikube або використовувати одну з цих пісочниць:
Вам знадобиться реєстр образів контейнерів, куди можна завантажувати образи для запуску у вашому кластері. У прикладі використовується Docker Hub, але ви можете адаптувати його до іншого реєстру образів контейнерів.
Цей приклад завдання також передбачає, що Docker встановлено локально. Docker використовується для збирання образів контейнерів.
Ви маєте знати базове, непаралельне використання Job.
Запуск Redis
Для простоти в цьому прикладі ви запустите один екземпляр Redis. Приклад масштабованого й відмовостійкого розгортання Redis дивіться в прикладі Redis.
Ви також можете безпосередньо завантажити такі файли:
#!/usr/bin/env pythonimporttimeimportrediswqhost="redis"# Uncomment next two lines if you do not have CoreDNS working.# import os# host = os.getenv("REDIS_SERVICE_HOST")q=rediswq.RedisWQ(name="job2",host=host)print("Worker with sessionID: "+q.sessionID())print("Initial queue state: empty="+str(q.empty()))whilenotq.empty():item=q.lease(lease_secs=10,block=True,timeout=2)ifitemisnotNone:itemstr=item.decode("utf-8")print("Working on "+itemstr)time.sleep(10)# Put your actual work here instead of sleep.q.complete(item)else:print("Waiting for work")print("Queue empty, exiting")
Ви також можете завантажити файли worker.py, rediswq.py і Dockerfile, а потім зібрати образ контейнера. Ось приклад збирання образу за допомогою Docker:
docker build -t job-wq-2 .
Надішліть образ у реєстр
Для Docker Hub додайте до образу застосунку теґ зі своїм іменем користувача й надішліть його в Hub наведеними нижче командами. Замініть <username> своїм іменем користувача Hub.
docker tag job-wq-2 <username>/job-wq-2
docker push <username>/job-wq-2
Не забудьте відредагувати маніфест, змінивши gcr.io/myproject на свій власний шлях.
У цьому прикладі кожен Pod працює над кількома елементами черги, а потім завершується, коли елементів більше немає. Оскільки робочі процеси самі виявляють, що робоча черга порожня, а контролер Job не знає про робочу чергу, він покладається на те, що робочі процеси повідомлять про завершення роботи. Робочі процеси сигналізують, що черга порожня, успішно завершуючись. Тож щойно будь-який робочий процес успішно завершиться, контролер знає, що роботу виконано і що Podʼи незабаром завершаться. Тому кількість завершень Job потрібно лишити незаданою. Контролер Job також зачекає завершення інших Podʼів.
Запуск Job
Отже, тепер запустіть Job:
# передбачається, що ви вже завантажили та відредагували маніфестkubectl apply -f ./job.yaml
Тепер трохи зачекайте, а потім перевірте стан Job:
Ви можете зачекати на успішне завершення Job із тайм-аутом:
# Перевірка назви умови не залежить від регіструkubectl wait --for=condition=complete --timeout=300s job/job-wq-2
kubectl logs pods/job-wq-2-7r7b2
Worker with sessionID: bbd72d0a-9e5c-4dd6-abf6-416cc267991f
Initial queue state: empty=False
Working on banana
Working on date
Working on lemon
Як бачите, один із Podʼів цього Job працював над кількома одиницями роботи.
Альтернативи
Якщо запускати сервіс черги або змінювати контейнери для використання робочої черги незручно, варто розглянути один з інших шаблонів Job.
Якщо у вас є постійний потік фонової роботи, натомість розгляньте запуск фонових робочих процесів за допомогою ReplicaSet і використання бібліотеки фонової обробки, наприклад https://github.com/resque/resque.
9.6 - Паралельна обробка з розгортанням шаблону
Це завдання демонструє запуск кількох Jobs на основі спільного шаблону. Цей підхід можна використовувати для паралельної обробки пакетів роботи.
У цьому прикладі є лише три елементи: apple, banana та cherry. Приклади Jobs обробляють кожен елемент, виводячи рядок, а потім роблячи паузу.
Ви маєте знати базове, непаралельне використання Job.
Вам треба мати кластер Kubernetes, а також інструмент командного рядка kubectl має бути налаштований для роботи з вашим кластером. Рекомендується виконувати ці настанови у кластері, що має щонайменше два вузли, які не виконують роль вузлів управління. Якщо у вас немає кластера, ви можете створити його, за допомогою minikube або використовувати одну з цих пісочниць:
# Використайте curl для завантаження job-tmpl.yamlcurl -L -s -O https://k8s.io/examples/application/job/job-tmpl.yaml
Завантажений файл ще не є чинним маніфестом Kubernetes. Натомість цей шаблон є поданням обʼєкта Job у YAML із заповнювачами, які потрібно заповнити перед використанням. Синтаксис $ITEM нічого не означає для Kubernetes.
Створення маніфестів з шаблону
Наведений нижче фрагмент оболонки використовує sed, щоб замінити рядок $ITEM змінною циклу, записуючи результат у тимчасову теку jobs. Виконайте його зараз:
# Розгорніть шаблон у кілька файлів, по одному для кожного елемента, який потрібно обробити.mkdir ./jobs
for i in apple banana cherry
do cat job-tmpl.yaml | sed "s/\$ITEM/$i/" > ./jobs/job-$i.yaml
done
Перевірте, чи це спрацювало:
ls jobs/
Вивід подібний до такого:
job-apple.yaml
job-banana.yaml
job-cherry.yaml
Ви можете використовувати будь-яку мову шаблонів (наприклад, Jinja2 або ERB) або написати програму для генерації маніфестів Job.
Створення Jobs з маніфестів
Далі створіть усі Jobs однією командою kubectl:
kubectl create -f ./jobs
Вивід подібний до такого:
job.batch/process-item-apple created
job.batch/process-item-banana created
job.batch/process-item-cherry created
Тепер перевірте Jobs:
kubectl get jobs -l jobgroup=jobexample
Вивід подібний до такого:
NAME COMPLETIONS DURATION AGE
process-item-apple 1/1 14s 22s
process-item-banana 1/1 12s 21s
process-item-cherry 1/1 12s 20s
Параметр -l для kubectl вибирає лише Jobs, що належать до цієї групи Jobs (у системі можуть бути інші, не повʼязані Jobs).
Ви також можете перевірити стан Podʼів, використовуючи той самий селектор міток:
kubectl get pods -l jobgroup=jobexample
Вивід подібний до такого:
NAME READY STATUS RESTARTS AGE
process-item-apple-kixwv 0/1 Completed 0 4m
process-item-banana-wrsf7 0/1 Completed 0 4m
process-item-cherry-dnfu9 0/1 Completed 0 4m
Цією однією командою можна переглянути вивід усіх Jobs одразу:
kubectl logs -f -l jobgroup=jobexample
Вивід має бути таким:
Processing item apple
Processing item banana
Processing item cherry
Очищення
# Видаліть створені вами Jobs# Ваш кластер автоматично очищає їхні Podʼиkubectl delete job -l jobgroup=jobexample
Використання розширених параметрів шаблону
У першому прикладі кожен екземпляр шаблону мав один параметр, і цей параметр також використовувався в назві Job. Однак назви можуть містити лише певні символи.
Цей трохи складніший приклад використовує мову шаблонів Jinja, щоб згенерувати маніфести, а потім обʼєкти з цих маніфестів, із кількома параметрами для кожного Job.
У цій частині завдання ви використаєте однорядковий скрипт Python, щоб перетворити шаблон на набір маніфестів.
Спочатку скопіюйте й вставте наведений нижче шаблон обʼєкта Job у файл job.yaml.jinja2:
{% set params = [{ "name": "apple", "url": "http://dbpedia.org/resource/Apple", },
{ "name": "banana", "url": "http://dbpedia.org/resource/Banana", },
{ "name": "cherry", "url": "http://dbpedia.org/resource/Cherry" }]
%}
{% for p in params %}
{% set name = p["name"] %}
{% set url = p["url"] %}
---
apiVersion: batch/v1
kind: Job
metadata:
name: jobexample-{{ name }}
labels:
jobgroup: jobexample
spec:
template:
metadata:
name: jobexample
labels:
jobgroup: jobexample
spec:
containers:
- name: c
image: busybox:1.28
command: ["sh", "-c", "echo Processing URL {{ url }} && sleep 5"]
restartPolicy: Never
{% endfor %}
Наведений вище шаблон визначає два параметри для кожного обʼєкта Job за допомогою списку словників Python (рядки 1-4). Цикл for генерує один маніфест Job для кожного набору параметрів (решта рядків).
Цей приклад спирається на можливість YAML. Один файл YAML може містити кілька документів (у цьому випадку маніфестів Kubernetes), розділених рядком ---. Ви можете передати вивід безпосередньо до kubectl, щоб створити Jobs.
Далі використайте цю однорядкову програму Python, щоб розгорнути шаблон:
Kubernetes приймає та запускає створені вами Jobs.
Очищення
# Видаліть створені вами Jobs# Ваш кластер автоматично очищає їхні Podʼиkubectl delete job -l jobgroup=jobexample
Використання Jobs у реальних робочих навантаженнях
У реальному сценарії кожен Job виконує значні обчислення, наприклад рендеринг кадру фільму або обробку діапазону рядків у базі даних. Якщо ви рендерите фільм, $ITEM слід задати як номер кадру. Якщо ви обробляєте рядки таблиці бази даних, $ITEM має представляти діапазон рядків для обробки.
У цьому завданні ви виконали команду, щоб зібрати вивід Podʼів, отримавши їхні логи. У реальному сценарії кожен Pod Job записує свій вивід у надійне сховище перед завершенням. Можна використовувати PersistentVolume для кожного Job або зовнішній сервіс зберігання. Наприклад, якщо ви рендерите кадри фільму, надсилайте дані готового кадру за допомогою HTTP PUT на URL, використовуючи окрему URL-адресу для кожного кадру.
Мітки на Jobs і Podʼах
Після створення Job Kubernetes автоматично додає мітки, які відрізняють Podʼи одного Job від Podʼів іншого Job.
У цьому прикладі кожен Job та його шаблон Pod мають мітку: jobgroup=jobexample.
Сам Kubernetes не звертає уваги на мітки з назвою jobgroup. Мітка на всіх Jobs, створених із шаблону, дає змогу зручно працювати з усіма цими Jobs одразу. У першому прикладі ви використали шаблон для створення кількох Jobs. Шаблон гарантує, що кожен Pod також отримує ту саму мітку, тож ви можете перевірити всі Podʼи цих Jobs однією командою.
Примітка:
Ключ мітки jobgroup не є особливим чи зарезервованим. Ви можете обрати власну схему міток. За бажання можна використовувати рекомендовані мітки.
Альтернативи
Якщо ви плануєте створити велику кількість обʼєктів Job, ви можете виявити, що:
Навіть із мітками керувати такою кількістю Jobs незручно.
Якщо ви створюєте багато Jobs одним пакетом, це може створити високе навантаження на панель управління Kubernetes. Крім того, API-сервер Kubernetes може обмежити швидкість ваших запитів, тимчасово відхиляючи їх зі статусом 429.
Ви обмежені квотою ресурсів на Jobs: API-сервер остаточно відхиляє деякі ваші запити, коли ви створюєте багато роботи одним пакетом.
Існують інші шаблони Job, які можна використовувати для обробки великих обсягів роботи без створення дуже великої кількості обʼєктів Job.
Ви також можете розглянути можливість написання власного контролера, щоб автоматично керувати обʼєктами Job.
9.7 - Обробка повторюваних і неповторюваних збоїв Podʼів за допомогою політики збоїв 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).
Вам треба мати кластер Kubernetes, а також інструмент командного рядка kubectl має бути налаштований для роботи з вашим кластером. Рекомендується виконувати ці настанови у кластері, що має щонайменше два вузли, які не виконують роль вузлів управління. Якщо у вас немає кластера, ви можете створити його, за допомогою minikube або використовувати одну з цих пісочниць:
Використання політики збоїв Podʼа для уникнення непотрібних повторних спроб запуску Podʼів
У наведеному нижче прикладі ви дізнаєтеся, як використовувати політику збоїв Podʼа, щоб уникати непотрібних перезапусків Podʼів, коли збій Podʼа вказує на програмну помилку, яку неможливо усунути повторною спробою.
Приблизно через 30 секунд весь Job має завершитися. Перевірте статус Job, виконавши команду:
kubectl get jobs -l job-name=job-pod-failure-policy-failjob -o yaml
У статусі Job відображаються такі стани:
Стан FailureTarget: має поле reason зі значенням PodFailurePolicy і поле message з додатковою інформацією про завершення, наприклад Container main for pod default/job-pod-failure-policy-failjob-8ckj8 failed with exit code 42 matching FailJob rule at index 0. Контролер Job додає цей стан, щойно Job вважається невдалим. Докладніше дивіться Завершення Podʼів Job.
Стан Failed: ті самі reason і message, що й у стану FailureTarget. Контролер Job додає цей стан після завершення всіх Podʼів Job.
Для порівняння: якби політику збоїв Podʼа було вимкнено, Job повторював би спроби до досягнення backoffLimit (6 збоїв). Оскільки повторні спроби використовують експоненційний backoff, а з parallelism: 2 збої відбуваються парами, затримка між спробами зростає з кожною спробою. У результаті в цьому прикладі мало б минути щонайменше 9 хвилин, перш ніж Job зазнає збою.
Використання політики збоїв Podʼа для ігнорування порушень роботи Podʼів
У наведеному нижче прикладі ви дізнаєтеся, як за допомогою політики збоїв Podʼа зробити так, щоб порушення роботи Podʼів не збільшували лічильник повторних спроб Podʼа в межах .spec.backoffLimit.
Увага:
У цьому прикладі важливий час, тому варто прочитати кроки перед виконанням. Щоб спричинити порушення роботи Podʼа, важливо виконати drain вузла, поки Pod працює на ньому (протягом 90 секунд після планування Podʼа).
Перевірте .status.failed, щоб переконатися, що лічильник для Job не збільшено:
kubectl get jobs -l job-name=job-pod-failure-policy-ignore -o yaml
Виконайте uncordon вузла:
kubectl uncordon nodes/$nodeName
Job відновлюється й завершується успішно.
Для порівняння: якби політику збоїв Podʼа було вимкнено, порушення роботи Podʼа призвело б до завершення всього Job (оскільки .spec.backoffLimit дорівнює 0).
Очищення
Видаліть створений Job:
kubectl delete jobs/job-pod-failure-policy-ignore
Кластер автоматично очищає Podʼи.
Використання політики збоїв Podʼа для уникнення непотрібних повторних спроб запуску Podʼів на основі власних станів Podʼа
У наведеному нижче прикладі ви дізнаєтеся, як використовувати політику збоїв Podʼа, щоб уникати непотрібних перезапусків Podʼів на основі власних станів Podʼа.
Примітка:
Наведений нижче приклад працює з версії 1.27, оскільки спирається на перехід видалених Podʼів у фазі Pending до термінальної фази (дивіться Фаза Podʼа).
Зверніть увагу, що Pod лишається у фазі Pending, оскільки не може завантажити неправильно налаштований образ. Це, в принципі, могло б бути тимчасовою проблемою, і образ міг би завантажитися. Однак у цьому випадку образу не існує, тому ми вказуємо на це за допомогою власного стану.
Додайте власний стан. Спочатку підготуйте патч, виконавши команду:
Видаліть Pod, щоб перевести його у фазу Failed, виконавши команду:
kubectl delete pods/$podName
Перевірте статус Job, виконавши:
kubectl get jobs -l job-name=job-pod-failure-policy-config-issue -o yaml
У статусі Job ви побачите стан Failed з полем reason, що дорівнює PodFailurePolicy. Крім того, поле message містить докладнішу інформацію про завершення Job, наприклад Pod default/job-pod-failure-policy-config-issue-k6pvp has condition ConfigIssue matching FailJob rule at index 0.
Примітка:
У промисловому середовищі кроки 3 та 4 має автоматизувати контролер, наданий користувачем.
Використання політики збоїв Podʼа для уникнення непотрібних повторних спроб запуску Podʼів за індексами
Щоб уникнути непотрібних перезапусків Podʼів для кожного індексу, можна використовувати можливості політика збоїв Podʼа й обмеження backoff на індекс. У цьому розділі сторінки показано, як використовувати ці можливості разом.
apiVersion:batch/v1kind:Jobmetadata:name:job-backoff-limit-per-index-failindexspec:completions:4parallelism:2completionMode:IndexedbackoffLimitPerIndex:1template:spec:restartPolicy:Nevercontainers:- name:mainimage:docker.io/library/python:3command:# The script:# - fails the Pod with index 0 with exit code 1, which results in one retry;# - fails the Pod with index 1 with exit code 42 which results# in failing the index without retry.# - succeeds Pods with any other index.- python3- -c- | import os, sys
index = int(os.environ.get("JOB_COMPLETION_INDEX"))
if index == 0:
sys.exit(1)
elif index == 1:
sys.exit(42)
else:
sys.exit(0)backoffLimit:6podFailurePolicy:rules:- action:FailIndexonExitCodes:containerName:mainoperator:Invalues:[42]
Приблизно через 15 секунд перевірте стан Podʼів для Job. Ви можете зробити це, виконавши команду:
kubectl get pods -l job-name=job-backoff-limit-per-index-failindex -o yaml
Ви побачите вивід, подібний до такого:
NAME READY STATUS RESTARTS AGE
job-backoff-limit-per-index-failindex-0-4g4cm 0/1 Error 0 4s
job-backoff-limit-per-index-failindex-0-fkdzq 0/1 Error 0 15s
job-backoff-limit-per-index-failindex-1-2bgdj 0/1 Error 0 15s
job-backoff-limit-per-index-failindex-2-vs6lt 0/1 Completed 0 11s
job-backoff-limit-per-index-failindex-3-s7s47 0/1 Completed 0 6s
Зверніть увагу, що вивід показує таке:
Два Podʼи мають індекс 0, оскільки обмеження backoff дозволило одну повторну спробу для індексу.
Лише один Pod має індекс 1, оскільки код виходу збійного Podʼа збігся з політикою збоїв Podʼа з дією FailIndex.
Перевірте статус Job, виконавши:
kubectl get jobs -l job-name=job-backoff-limit-per-index-failindex -o yaml
У статусі Job поле failedIndexes показує "0,1", оскільки обидва індекси зазнали збою. Оскільки індекс 1 не повторювався, кількість збійних Podʼів, вказана в полі статусу "failed", дорівнює 3.
Ви можете покладатися лише на політику backoff для збоїв Podʼа, вказавши поле .spec.backoffLimit у Job. Однак у багатьох ситуаціях важко знайти баланс: значення .spec.backoffLimit має бути достатньо низьким, щоб уникати непотрібних повторних спроб Podʼів, але достатньо високим, щоб Job не завершувався через порушення роботи Podʼів.
10 - Доступ до застосунків у кластері
Налаштування балансування навантаження, перенаправлення портів, фаєрвола або конфігурації DNS для доступу до застосунків у кластері.
10.1 - Розгортання й доступ до Kubernetes Dashboard
Розгорніть вебінтерфейс (Kubernetes Dashboard) і отримайте до нього доступ.
Kubernetes Dashboard є застарілим та не підтримується.
Проєкт Kubernetes Dashboard заархівовано, і він більше не підтримується активно. Для нових встановлень розгляньте Headlamp.
Dashboard — це вебінтерфейс користувача Kubernetes. За допомогою Dashboard можна розгортати контейнеризовані застосунки в кластері Kubernetes, усувати несправності контейнеризованих застосунків і керувати ресурсами кластера. Також Dashboard дає змогу переглядати застосунки, що працюють у кластері, а ще створювати або змінювати окремі ресурси Kubernetes (як-от Deployments, Jobs, DaemonSets тощо). Наприклад, можна масштабувати Deployment, запустити поетапне оновлення, перезапустити Pod або розгорнути нові застосунки за допомогою майстра розгортання.
Dashboard також надає інформацію про стан ресурсів Kubernetes у кластері та про помилки, що могли виникнути.
Розгортання інтерфейсу Dashboard
Примітка:
Наразі Kubernetes Dashboard підтримує лише встановлення за допомогою Helm, оскільки це швидше й дає нам кращий контроль над усіма залежностями, потрібними для роботи Dashboard.
Стандартно інтерфейс Dashboard не розгорнуто. Щоб розгорнути його, виконайте таку команду:
# Додайте репозиторій kubernetes-dashboardhelm repo add kubernetes-dashboard https://kubernetes.github.io/dashboard/
# Розгорніть Helm Release з назвою "kubernetes-dashboard" за допомогою чарта kubernetes-dashboardhelm upgrade --install kubernetes-dashboard kubernetes-dashboard/kubernetes-dashboard --create-namespace --namespace kubernetes-dashboard
Доступ до інтерфейсу Dashboard
Щоб захистити дані кластера, Dashboard стандартно розгортається з мінімальною конфігурацією RBAC. Наразі Dashboard підтримує лише вхід за допомогою Bearer Token. Щоб створити токен для цієї демонстрації, скористайтеся нашим посібником зі створення зразка користувача.
Попередження:
Зразок користувача, створений у цьому навчальному матеріалі, матиме адміністративні привілеї й призначений лише для навчання.
Проксі з командного рядка
Увімкнути доступ до Dashboard можна за допомогою інструмента командного рядка kubectl, виконавши таку команду:
Доступ до інтерфейсу можливий лише з машини, на якій виконано команду. Більше параметрів дивіться в kubectl port-forward --help.
Примітка:
Метод автентифікації kubeconfig не підтримує зовнішніх постачальників ідентифікації або автентифікацію на основі сертифікатів X.509.
Вітальна сторінка
Коли ви відкриваєте Dashboard у порожньому кластері, показується вітальна сторінка. Вона містить посилання на цей документ, а також кнопку для розгортання вашого першого застосунку. Крім того, можна переглянути, які системні застосунки стандартно працюють у просторі іменkube-system вашого кластера, наприклад сам Dashboard.
Розгортання контейнеризованих застосунків
Dashboard дає змогу створити й розгорнути контейнеризований застосунок як Deployment і необовʼязковий Service за допомогою простого майстра. Можна або вручну вказати параметри застосунку, або завантажити файл маніфесту YAML чи JSON, що містить конфігурацію застосунку.
Натисніть кнопку CREATE у верхньому правому куті будь-якої сторінки, щоб розпочати.
Встановлення параметрів застосунку
Майстер розгортання очікує від вас таку інформацію:
Назва застосунку (обовʼязково): назва вашого застосунку. Мітку з цією назвою буде додано до Deployment і Service (якщо він є), які буде розгорнуто.
Назва застосунку має бути унікальною в межах вибраного простору імен Kubernetes. Вона має починатися з малої літери, закінчуватися малою літерою або цифрою й містити лише малі літери, цифри та дефіси (-). Довжина обмежена 24 символами. Пробіли на початку й у кінці ігноруються.
Образ контейнера (обовʼязково): URL публічного образу контейнера Docker у будь-якому реєстрі або приватного образу (зазвичай розміщеного в Google Container Registry або Docker Hub). Специфікація образу контейнера має закінчуватися двокрапкою.
Кількість Podʼів (обовʼязково): цільова кількість Podʼів, у яких ви хочете розгорнути застосунок. Значення має бути додатним цілим числом.
Буде створено Deployment, щоб підтримувати потрібну кількість Podʼів у вашому кластері.
Service (необовʼязково): для деяких частин застосунку (наприклад, фронтендів) може знадобитися відкрити доступ до Service через зовнішню, можливо публічну, IP-адресу поза кластером (зовнішній Service).
Примітка:
Для зовнішніх Services може знадобитися відкрити один або кілька портів.
Інші Services, видимі лише всередині кластера, називаються внутрішніми Services.
Незалежно від типу Service, якщо ви вирішите створити Service і ваш контейнер слухає порт (вхідний), потрібно вказати два порти. Service буде створено зі зіставленням порту (вхідного) на цільовий порт, який бачить контейнер. Цей Service спрямовуватиме трафік до розгорнутих Podʼів. Підтримувані протоколи: TCP і UDP. Внутрішнім DNS-імʼям цього Service буде значення, вказане вище як назва застосунку.
За потреби можна розгорнути розділ Advanced options, де можна вказати інші налаштування:
Опис: текст, який ви введете тут, буде додано як анотацію до Deployment і показано в деталях застосунку.
Мітки: стандартні мітки застосунку — це його назва та версія. Можна вказати додаткові мітки, які буде застосовано до Deployment, Service (якщо він є) і Podʼів, як-от release, environment, tier, partition і release track.
Простір імен: Kubernetes підтримує кілька віртуальних кластерів на основі одного фізичного кластера. Ці віртуальні кластери називаються просторами імен. Вони дають змогу розділяти ресурси на логічно названі групи.
Dashboard пропонує всі доступні простори імен у випадному списку й дає змогу створити новий простір імен. Назва простору імен може містити не більше 63 алфавітно-цифрових символів і дефісів (-), але не може містити великих літер. Назви просторів імен не повинні складатися лише з цифр. Якщо назву задано як число, наприклад 10, Pod буде розміщено у стандартному просторі імен.
Якщо простір імен створено успішно, його буде вибрано стандартно. Якщо створити його не вдалося, буде вибрано перший простір імен.
Secret для завантаження образу: якщо вказаний образ контейнера Docker приватний, він може потребувати облікових даних із Secret для завантаження образу.
Dashboard пропонує всі доступні Secrets у випадному списку й дає змогу створити новий Secret. Назва Secret має відповідати синтаксису доменного імені DNS, наприклад new.image-pull.secret. Вміст Secret має бути закодований у base64 і вказаний у файлі .dockercfg. Назва Secret може містити не більше 253 символів.
Якщо Secret для завантаження образу створено успішно, його буде вибрано стандартно. Якщо створити його не вдалося, Secret не застосовується.
Вимога до CPU (ядра) та Вимога до памʼяті (MiB): можна вказати мінімальні обмеження ресурсів для контейнера. Стандартно Podʼи працюють без обмежень на CPU і памʼять.
Команда запуску та Аргументи команди запуску: стандартно контейнери виконують команду entrypoint, визначену у вказаному образі Docker. За допомогою параметрів і аргументів команди її можна перевизначити.
Запуск у привілейованому режимі: це налаштування визначає, чи еквівалентні процеси в привілейованих контейнерах процесам, що виконуються від імені root на хості. Привілейовані контейнери можуть використовувати такі можливості, як керування мережевим стеком і доступ до пристроїв.
Змінні середовища: Kubernetes надає відомості про Services через змінні середовища. Можна складати змінні середовища або передавати аргументи командам, використовуючи значення змінних середовища. Їх можна використовувати в застосунках для пошуку Service. Значення можуть посилатися на інші змінні за допомогою синтаксису $(VAR_NAME).
Завантаження файлу YAML або JSON
Kubernetes підтримує декларативну конфігурацію. У цьому стилі вся конфігурація зберігається в маніфестах (файлах конфігурації YAML або JSON). Маніфести використовують схеми ресурсів API Kubernetes.
Замість того щоб вказувати параметри застосунку в майстрі розгортання, можна визначити застосунок в одному чи кількох маніфестах і завантажити файли за допомогою Dashboard.
Використання Dashboard
У наведених нижче розділах описано подання інтерфейсу Kubernetes Dashboard: що вони надають і як їх використовувати.
Навігація
Коли в кластері визначено обʼєкти Kubernetes, Dashboard показує їх у початковому поданні. Стандартно показано лише обʼєкти з простору імен default; це можна змінити за допомогою селектора простору імен у меню навігації.
Dashboard показує більшість типів обʼєктів Kubernetes та групує їх у кілька категорій меню.
Огляд адміністратора
Для адміністраторів кластерів і просторів імен Dashboard перелічує Nodes, Namespaces і PersistentVolumes та має для них детальні подання. Подання списку Nodes містить метрики використання CPU й памʼяті, агреговані за всіма вузлами. Детальне подання показує метрики вузла, його специфікацію, статус, виділені ресурси, події та Podʼи, що працюють на вузлі.
Робочі навантаження
Показує всі застосунки, що працюють у вибраному просторі імен. Подання перелічує застосунки за типом робочого навантаження (наприклад, Deployments, ReplicaSets, StatefulSets). Кожен тип робочого навантаження можна переглядати окремо. Списки узагальнюють практичну інформацію про робочі навантаження, як-от кількість готових Podʼів у ReplicaSet або поточне використання памʼяті Podʼом.
Детальні подання робочих навантажень показують статус і специфікацію, а також звʼязки між обʼєктами. Наприклад, Podʼи, якими керує ReplicaSet, або нові ReplicaSets і HorizontalPodAutoscalers для Deployments.
Services
Показує ресурси Kubernetes, які дають змогу відкривати доступ до сервісів для зовнішнього світу й виявляти їх усередині кластера. Тому подання Service та Ingress показують Podʼи, на які вони спрямовані, внутрішні точки доступу для зʼєднань усередині кластера та зовнішні точки доступу для зовнішніх користувачів.
Сховище
Подання сховища показує ресурси PersistentVolumeClaim, які застосунки використовують для зберігання даних.
ConfigMaps та Secrets
Показує всі ресурси Kubernetes, що використовуються для поточної конфігурації застосунків, які працюють у кластерах. Подання дає змогу редагувати обʼєкти конфігурації й керувати ними та стандартно показує Secrets прихованими.
Переглядач логів
Списки Podʼів і сторінки деталей містять посилання на переглядач логів, вбудований у Dashboard. Переглядач дає змогу детально вивчати логи контейнерів, що належать одному Podʼу.
У цій темі розглянуто кілька способів взаємодії з кластерами.
Перший доступ за допомогою kubectl
Під час першого доступу до Kubernetes API радимо використовувати Kubernetes CLI — kubectl.
Щоб отримати доступ до кластера, потрібно знати його розташування й мати облікові дані для доступу. Зазвичай це налаштовується автоматично, коли ви проходите посібник «Початок роботи», або хтось інший налаштував кластер і надав вам облікові дані та розташування.
Перевірте розташування та облікові дані, про які знає kubectl, за допомогою цієї команди:
kubectl config view
Багато прикладів знайомлять із використанням kubectl, а повну документацію наведено в довіднику kubectl.
Прямий доступ до REST API
kubectl сам знаходить API-сервер і автентифікується на ньому. Якщо ви хочете звертатися до REST API безпосередньо за допомогою http-клієнта, як-от curl або wget, чи браузера, є кілька способів знайти API-сервер і автентифікуватися:
Запустіть kubectl у режимі проксі.
Рекомендований підхід.
Використовує збережене розташування API-сервера.
Перевіряє автентичність API-сервера за допомогою самопідписаного сертифіката. Атака MITM неможлива.
Автентифікується на API-сервері.
У майбутньому може виконувати інтелектуальне балансування навантаження та перемикання в разі відмови на стороні клієнта.
Надайте розташування й облікові дані безпосередньо http-клієнту.
Альтернативний підхід.
Працює з деякими типами клієнтського коду, які збиваються через використання проксі.
Потрібно імпортувати кореневий сертифікат у браузер для захисту від MITM.
Використання kubectl proxy
Наведена нижче команда запускає kubectl у режимі, у якому він працює як зворотний проксі. Він сам знаходить API-сервер і автентифікується. Запустіть її так:
У наведених вище прикладах використано прапорець --insecure. Через це запит вразливий до атак MITM. Коли kubectl звертається до кластера, він використовує збережений кореневий сертифікат і клієнтські сертифікати для доступу до сервера. (Вони встановлені в теці ~/.kube.) Оскільки сертифікати кластера зазвичай самопідписані, щоб http-клієнт використовував кореневий сертифікат, може знадобитися спеціальне налаштування.
У деяких кластерах API-сервер не вимагає автентифікації: він може обслуговувати запити на localhost або бути захищеним фаєрволом. Стандарту для цього немає. У розділі Контроль доступу до API описано, як адміністратор кластера може це налаштувати.
Програмний доступ до API
Kubernetes офіційно підтримує клієнтські бібліотеки для Go та Python.
Клієнт Go
Щоб отримати бібліотеку, виконайте таку команду: go get k8s.io/client-go@kubernetes-<kubernetes-version-number>, докладні інструкції зі встановлення дивіться в INSTALL.md. Підтримувані версії дивіться на https://github.com/kubernetes/client-go.
Напишіть застосунок на основі клієнтів client-go. Зверніть увагу, що client-go визначає власні обʼєкти API, тому за потреби імпортуйте визначення API з client-go, а не з основного репозиторію, наприклад, правильним є import "k8s.io/client-go/kubernetes".
Клієнт Go може використовувати той самий файл kubeconfig, що й CLI kubectl, щоб знайти API-сервер і автентифікуватися на ньому. Дивіться цей приклад.
Якщо застосунок розгорнуто як Pod у кластері, зверніться до наступного розділу.
Клієнт Python може використовувати той самий файл kubeconfig, що й CLI kubectl, щоб знайти API-сервер і автентифікуватися на ньому. Дивіться цей приклад.
Інші мови
Для доступу до API з інших мов існують клієнтські бібліотеки. Про те, як вони автентифікуються, дивіться документацію цих бібліотек.
Доступ до API з Podʼа
Під час доступу до API з Podʼа пошук API-сервера й автентифікація на ньому дещо відрізняються.
У попередньому розділі описано, як підʼєднатися до API-сервера Kubernetes. Про підʼєднання до інших сервісів, що працюють у кластері Kubernetes, дивіться Доступ до сервісів кластера.
Запит перенаправлення
Можливості перенаправлення визнано застарілими й вилучено. Натомість використовуйте проксі (дивіться нижче).
Так багато проксі
Під час роботи з Kubernetes можна зустріти кілька різних проксі:
Проксі або балансувальник навантаження перед API-сервером (або кількома):
наявність і реалізація різняться від кластера до кластера (наприклад, nginx)
розташовується між усіма клієнтами та одним чи кількома API-серверами
працює як балансувальник навантаження, якщо є кілька API-серверів.
Хмарні балансувальники навантаження для зовнішніх сервісів:
надаються деякими хмарними провайдерами (наприклад, AWS ELB, Google Cloud Load Balancer)
створюються автоматично, коли сервіс Kubernetes має тип LoadBalancer
використовують лише UDP/TCP
реалізація залежить від хмарного провайдера.
Користувачам Kubernetes зазвичай не потрібно перейматися нічим, крім перших двох типів. За правильне налаштування решти типів зазвичай відповідає адміністратор кластера.
10.3 - Налаштування доступу до кількох кластерів
На цій сторінці показано, як налаштувати доступ до кількох кластерів за допомогою файлів конфігурації. Після того як кластери, користувачів і контексти визначено в одному чи кількох файлах конфігурації, можна швидко перемикатися між кластерами за допомогою команди kubectl config use-context.
Примітка:
Файл, що використовується для налаштування доступу до кластера, іноді називають файлом kubeconfig. Це загальна назва файлів конфігурації. Це не означає, що існує файл з назвою kubeconfig.
Попередження:
Використовуйте файли kubeconfig лише з надійних джерел. Використання спеціально створеного файлу kubeconfig може призвести до виконання шкідливого коду або розкриття файлів. Якщо вам потрібно використати ненадійний файл kubeconfig, спершу ретельно його перевірте, як перевіряли б скрипт оболонки.
Перш ніж ви розпочнете
Вам треба мати кластер Kubernetes, а також інструмент командного рядка kubectl має бути налаштований для роботи з вашим кластером. Рекомендується виконувати ці настанови у кластері, що має щонайменше два вузли, які не виконують роль вузлів управління. Якщо у вас немає кластера, ви можете створити його, за допомогою minikube або використовувати одну з цих пісочниць:
Щоб перевірити, чи встановлено kubectl, виконайте команду kubectl version --client. Версія kubectl має бути в межах однієї мінорної версії від версії API-сервера вашого кластера.
Визначення кластерів, користувачів і контекстів
Припустимо, у вас є два кластери: один для розробки, а інший для тестування. У кластері development ваші фронтенд-розробники працюють у просторі імен frontend, а розробники сховищ — у просторі імен storage. У кластері test розробники працюють у стандартному просторі імен або створюють додаткові простори імен за потреби. Доступ до кластера розробки вимагає автентифікації за сертифікатом. Доступ до тестового кластера вимагає автентифікації за іменем користувача та паролем.
Створіть теку з назвою config-exercise. У теці config-exercise створіть файл з назвою config-demo з таким вмістом:
Файл конфігурації описує кластери, користувачів і контексти. Ваш файл config-demo містить каркас для опису двох кластерів, двох користувачів і трьох контекстів.
Перейдіть до теки config-exercise. Виконайте ці команди, щоб додати відомості про кластери до файлу конфігурації:
kubectl config --kubeconfig=config-demo set-cluster development --server=https://1.2.3.4 --certificate-authority=fake-ca-file
kubectl config --kubeconfig=config-demo set-cluster test --server=https://5.6.7.8 --insecure-skip-tls-verify
Додайте відомості про користувачів до файлу конфігурації:
Увага:
Зберігання паролів у конфігурації клієнта Kubernetes ризиковано. Кращою альтернативою є використання втулка облікових даних і окреме зберігання цих даних. Дивіться втулки облікових даних client-go.
Відкрийте файл config-demo, щоб побачити додані відомості. Замість відкриття файлу config-demo можна використати команду config view.
kubectl config --kubeconfig=config-demo view
Вивід показує два кластери, двох користувачів і три контексти:
apiVersion:v1clusters:- cluster:certificate-authority:fake-ca-fileserver:https://1.2.3.4name:development- cluster:insecure-skip-tls-verify:trueserver:https://5.6.7.8name:testcontexts:- context:cluster:developmentnamespace:frontenduser:developername:dev-frontend- context:cluster:developmentnamespace:storageuser:developername:dev-storage- context:cluster:testnamespace:defaultuser:experimentername:exp-testcurrent-context:""kind:Configpreferences:{}users:- name:developeruser:client-certificate:fake-cert-fileclient-key:fake-key-file- name:experimenteruser:# Примітка до документації (цей коментар НЕ є частиною виводу команди).# Зберігання паролів у конфігурації клієнта Kubernetes ризиковано.# Кращою альтернативою є використання втулка облікових даних# і окреме зберігання цих даних.# Дивіться https://kubernetes.io/docs/reference/access-authn-authz/authentication/#client-go-credential-pluginspassword:some-passwordusername:exp
Наведені вище fake-ca-file, fake-cert-file і fake-key-file є заповнювачами шляхів до файлів сертифікатів. Вам потрібно замінити їх на справжні шляхи до файлів сертифікатів у вашому середовищі.
Іноді може знадобитися вбудувати сюди дані, закодовані в Base64, замість окремих файлів сертифікатів; у такому разі потрібно додати суфікс -data до ключів, наприклад, certificate-authority-data, client-certificate-data, client-key-data.
Кожен контекст — це трійка (кластер, користувач, простір імен). Наприклад, контекст dev-frontend означає: «Використовувати облікові дані користувача developer для доступу до простору імен frontend кластера development».
Тепер кожна введена команда kubectl застосовуватиметься до кластера й простору імен, зазначених у контексті dev-frontend. Команда використовуватиме облікові дані користувача, зазначеного в контексті dev-frontend.
Щоб побачити лише інформацію про конфігурацію, повʼязану з поточним контекстом, використовуйте прапорець --minify.
Тепер будь-яка введена команда kubectl застосовуватиметься до стандартного простору імен кластера test. Команда використовуватиме облікові дані користувача, зазначеного в контексті exp-test.
Перегляньте конфігурацію, повʼязану з новим поточним контекстом exp-test.
Наведений вище файл конфігурації визначає новий контекст з назвою dev-ramp-up.
Встановіть змінну середовища KUBECONFIG
Перевірте, чи є у вас змінна середовища з назвою KUBECONFIG. Якщо так, збережіть її поточне значення, щоб пізніше відновити його. Наприклад:
Linux
exportKUBECONFIG_SAVED="$KUBECONFIG"
Windows PowerShell
$Env:KUBECONFIG_SAVED=$ENV:KUBECONFIG
Змінна середовища KUBECONFIG — це список шляхів до файлів конфігурації. У Linux і Mac елементи списку розділяються двокрапкою, а у Windows — крапкою з комою. Якщо у вас є змінна середовища KUBECONFIG, ознайомтеся з файлами конфігурації зі списку.
Тимчасово додайте два шляхи до змінної середовища KUBECONFIG. Наприклад:
Вивід показує обʼєднану інформацію з усіх файлів, зазначених у змінній середовища KUBECONFIG. Зокрема, зверніть увагу, що обʼєднана інформація містить контекст dev-ramp-up з файлу config-demo-2 і три контексти з файлу config-demo:
Якщо у вас уже є кластер і ви можете взаємодіяти з ним за допомогою kubectl, то, ймовірно, у теці $HOME/.kube є файл з назвою config.
Перейдіть до теки $HOME/.kube і перегляньте, які файли там є. Зазвичай там є файл з назвою config. У цій теці можуть бути й інші файли конфігурації. Коротко ознайомтеся з їхнім вмістом.
Додайте $HOME/.kube/config до змінної середовища KUBECONFIG
Якщо у вас є файл $HOME/.kube/config і він ще не зазначений у змінній середовища KUBECONFIG, додайте його туди зараз. Наприклад:
Перегляньте інформацію про конфігурацію, обʼєднану з усіх файлів, які тепер зазначені у змінній середовища KUBECONFIG. У теці config-exercise введіть:
kubectl config view
Очищення
Поверніть змінній середовища KUBECONFIG її початкове значення. Наприклад:
Linux
exportKUBECONFIG="$KUBECONFIG_SAVED"
Windows PowerShell
$Env:KUBECONFIG=$ENV:KUBECONFIG_SAVED
Перевірте субʼєкт, представлений kubeconfig
Не завжди очевидно, які атрибути (імʼя користувача, групи) ви отримаєте після автентифікації в кластері. Це може бути ще складніше, якщо ви керуєте більше ніж одним кластером одночасно.
Існує підкоманда kubectl для перевірки атрибутів субʼєкта, таких як імʼя користувача, для вибраного контексту клієнта Kubernetes: kubectl auth whoami.
10.4 - Використання перенаправлення портів для доступу до застосунків у кластері
На цій сторінці показано, як за допомогою kubectl port-forward підʼєднатися до сервера MongoDB, що працює в кластері Kubernetes. Таке підʼєднання може бути корисним для налагодження бази даних.
Перш ніж ви розпочнете
Вам треба мати кластер Kubernetes, а також інструмент командного рядка kubectl має бути налаштований для роботи з вашим кластером. Рекомендується виконувати ці настанови у кластері, що має щонайменше два вузли, які не виконують роль вузлів управління. Якщо у вас немає кластера, ви можете створити його, за допомогою minikube або використовувати одну з цих пісочниць:
Вивід успішної команди підтверджує, що Service створено:
service/mongo created
Перевірте створений Service:
kubectl get service mongo
Вивід показує створений Service:
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
mongo ClusterIP 10.96.41.183 <none> 27017/TCP 11s
Переконайтеся, що сервер MongoDB працює в Podʼі й слухає порт 27017:
# Замініть mongo-75f59d57f4-4nd6q на назву Podʼаkubectl get pod mongo-75f59d57f4-4nd6q --template='{{(index (index .spec.containers 0).ports 0).containerPort}}{{"\n"}}'
Вивід показує порт MongoDB у цьому Podʼі:
27017
27017 — офіційний порт TCP для MongoDB.
Перенаправлення локального порту на порт Podʼа
kubectl port-forward дозволяє використовувати назву ресурсу, наприклад назву Podʼа, щоб вибрати відповідний Pod для перенаправлення порту.
# Замініть mongo-75f59d57f4-4nd6q на назву Podʼаkubectl port-forward mongo-75f59d57f4-4nd6q 28015:27017
Будь-яка з наведених вище команд працює. Вивід подібний до такого:
Forwarding from 127.0.0.1:28015 -> 27017
Forwarding from [::1]:28015 -> 27017
Примітка:
kubectl port-forward не завершується сам. Щоб продовжити вправи, потрібно відкрити інший термінал.
Запустіть інтерфейс командного рядка MongoDB:
mongosh --port 28015
У командному рядку MongoDB введіть команду ping:
db.runCommand( { ping: 1 } )
Успішний запит ping повертає:
{ ok: 1 }
За бажання дозвольте kubectl вибрати локальний порт
Якщо вам не потрібен конкретний локальний порт, ви можете дозволити kubectl вибрати й призначити його, що позбавить вас потреби розвʼязувати конфлікти локальних портів, за допомогою дещо простішого синтаксису:
kubectl port-forward deployment/mongo :27017
Інструмент kubectl вибирає вільний номер локального порту (уникаючи низьких номерів, оскільки їх можуть використовувати інші застосунки). Вивід подібний до такого:
Forwarding from 127.0.0.1:63753 -> 27017
Forwarding from [::1]:63753 -> 27017
Обговорення
Зʼєднання з локальним портом 28015 перенаправляються на порт 27017 Podʼа, у якому працює сервер MongoDB. Завдяки цьому зʼєднанню ви можете налагоджувати базу даних, що працює в Podʼі, зі своєї локальної робочої станції.
Примітка:
kubectl port-forward реалізовано лише для портів TCP. Підтримка протоколу UDP відстежується в issue 47862.
Авторизація та міркування безпеки
Доступ до kubectl port-forward контролюється механізмами авторизації Kubernetes, такими як контроль доступу на основі ролей (RBAC). Авторизацію забезпечує API-сервер Kubernetes, а не клієнт kubectl.
Щоб використовувати kubectl port-forward, користувач повинен мати дозвіл на доступ до цільового ресурсу (наприклад, Pod або Service) і субресурсу portforward. Зазвичай потрібні дозволи get для pods і create для pods/portforward.
Адміністратори кластерів мають ретельно обмежувати ці дозволи, оскільки перенаправлення портів може надавати прямий мережевий доступ до робочих навантажень і обходити засоби контролю на рівні мережі.
10.5 - Використання Service для доступу до застосунку в кластері
На цій сторінці показано, як створити обʼєкт Service у Kubernetes, за допомогою якого зовнішні клієнти можуть отримати доступ до застосунку, що працює в кластері. Service забезпечує балансування навантаження для застосунку, який має два запущені екземпляри.
Перш ніж ви розпочнете
Вам треба мати кластер Kubernetes, а також інструмент командного рядка kubectl має бути налаштований для роботи з вашим кластером. Рекомендується виконувати ці настанови у кластері, що має щонайменше два вузли, які не виконують роль вузлів управління. Якщо у вас немає кластера, ви можете створити його, за допомогою minikube або використовувати одну з цих пісочниць:
Занотуйте значення NodePort для Service. Наприклад, у попередньому виводі значення NodePort становить 31496.
Виведіть Podʼи, на яких працює застосунок Hello World:
kubectl get pods --selector="run=load-balancer-example" --output=wide
Вивід подібний до такого:
NAME READY STATUS ... IP NODE
hello-world-2895499144-bsbk5 1/1 Running ... 10.200.1.4 worker1
hello-world-2895499144-m1pwt 1/1 Running ... 10.200.2.5 worker2
Отримайте публічну IP-адресу одного з вузлів, на якому працює Pod Hello World. Спосіб отримання цієї адреси залежить від того, як налаштовано кластер. Наприклад, якщо ви використовуєте Minikube, адресу вузла можна побачити, виконавши kubectl cluster-info. Якщо ви використовуєте екземпляри Google Compute Engine, переглянути публічні адреси вузлів можна командою gcloud compute instances list.
На вибраному вузлі створіть правило фаєрвола, яке дозволяє TCP-трафік на порт вузла. Наприклад, якщо значення NodePort вашого Service — 31568, створіть правило фаєрвола, яке дозволяє TCP-трафік на порт 31568. Різні хмарні провайдери пропонують різні способи налаштування правил фаєрвола.
Використовуйте адресу вузла та порт вузла для доступу до застосунку Hello World:
curl http://<public-node-ip>:<node-port>
де <public-node-ip> — публічна IP-адреса вашого вузла, а <node-port> — значення NodePort вашого сервісу. Відповідь на успішний запит — вітальне повідомлення:
10.6 - Зʼєднання фронтенду з бекендом за допомогою Services
Це завдання показує, як створити мікросервіси фронтенду й бекенду. Мікросервіс бекенду — це сервіс привітання. Фронтенд відкриває доступ до бекенду за допомогою nginx та обʼєкта Service Kubernetes.
Цілі
Створити й запустити приклад мікросервісу бекенду hello за допомогою обʼєкта Deployment.
Використовувати обʼєкт Service для надсилання трафіку до кількох реплік мікросервісу бекенду.
Створити й запустити мікросервіс фронтенду nginx, також за допомогою обʼєкта Deployment.
Налаштувати мікросервіс фронтенду на надсилання трафіку до мікросервісу бекенду.
Використати обʼєкт Service type=LoadBalancer, щоб відкрити доступ до мікросервісу фронтенду ззовні кластера.
Перш ніж ви розпочнете
Вам треба мати кластер Kubernetes, а також інструмент командного рядка kubectl має бути налаштований для роботи з вашим кластером. Рекомендується виконувати ці настанови у кластері, що має щонайменше два вузли, які не виконують роль вузлів управління. Якщо у вас немає кластера, ви можете створити його, за допомогою minikube або використовувати одну з цих пісочниць:
Name: backend
Namespace: default
CreationTimestamp: Mon, 24 Oct 2016 14:21:02 -0700
Labels: app=hello
tier=backend
track=stable
Annotations: deployment.kubernetes.io/revision=1
Selector: app=hello,tier=backend,track=stable
Replicas: 3 desired | 3 updated | 3 total | 3 available | 0 unavailable
StrategyType: RollingUpdate
MinReadySeconds: 0
RollingUpdateStrategy: 1 max unavailable, 1 max surge
Pod Template:
Labels: app=hello
tier=backend
track=stable
Containers:
hello:
Image: "gcr.io/google-samples/hello-go-gke:1.0"
Port: 80/TCP
Environment: <none>
Mounts: <none>
Volumes: <none>
Conditions:
Type Status Reason
---- ------ ------
Available True MinimumReplicasAvailable
Progressing True NewReplicaSetAvailable
OldReplicaSets: <none>
NewReplicaSet: hello-3621623197 (3/3 replicas created)
Events:
...
Створення обʼєкта Service hello
Ключовим для надсилання запитів із фронтенду до бекенду є Service бекенду. Service створює постійну IP-адресу й запис імені DNS, щоб мікросервіс бекенду завжди був доступний. Service використовує селектори, щоб визначити Podʼи, до яких спрямовувати трафік.
На цьому етапі у вас є Deployment backend, що виконує три репліки застосунку hello, і Service, який може спрямовувати до них трафік. Однак цей сервіс недоступний і не розвʼязується ззовні кластера.
Створення фронтенду
Тепер, коли бекенд працює, можна створити фронтенд, доступний ззовні кластера, який підʼєднується до бекенду, проксіюючи до нього запити.
Фронтенд надсилає запити до робочих Podʼів бекенду, використовуючи DNS-імʼя, надане Service бекенду. DNS-імʼя — hello, це значення поля name у файлі конфігурації examples/service/access/backend-service.yaml.
Podʼи в Deployment фронтенду запускають образ nginx, налаштований на проксіювання запитів до Service бекенду hello. Ось файл конфігурації nginx:
# The identifier Backend is internal to nginx, and used to name this specific upstream
upstream Backend {
# hello is the internal DNS name used by the backend Service inside Kubernetes
server hello;
}
server {
listen 80;
location / {
# The following statement will proxy traffic to the upstream named Backend
proxy_pass http://Backend;
}
}
Як і бекенд, фронтенд має Deployment і Service. Важлива відмінність між сервісами бекенду й фронтенду в тому, що конфігурація Service фронтенду має type: LoadBalancer, тобто Service використовує балансувальник навантаження, наданий вашим хмарним провайдером, і буде доступний ззовні кластера.
10.7 - Створення зовнішнього балансувальника навантаження
На цій сторінці показано, як створити зовнішній балансувальник навантаження.
Під час створення Service ви можете автоматично створити хмарний балансувальник навантаження. Він надає доступну ззовні IP-адресу, яка спрямовує трафік на потрібний порт вузлів кластера, за умови, що ваш кластер працює в підтримуваному середовищі й налаштований із відповідним пакетом постачальника хмарного балансувальника навантаження.
Ви також можете використовувати Ingress замість Service. Докладніше дивіться в документації про Ingress.
Перш ніж ви розпочнете
Вам треба мати кластер Kubernetes, а також інструмент командного рядка kubectl має бути налаштований для роботи з вашим кластером. Рекомендується виконувати ці настанови у кластері, що має щонайменше два вузли, які не виконують роль вузлів управління. Якщо у вас немає кластера, ви можете створити його, за допомогою minikube або використовувати одну з цих пісочниць:
IP-адреса балансувальника навантаження вказана поруч з LoadBalancer Ingress.
Примітка:
Якщо ви запускаєте сервіс у Minikube, призначену IP-адресу й порт можна знайти за допомогою:
minikube service example-service --url
Збереження вихідної IP-адреси клієнта
Стандартно вихідна IP-адреса, яку бачить цільовий контейнер, не є початковою вихідною IP-адресою клієнта. Щоб увімкнути збереження IP-адреси клієнта, можна налаштувати такі поля в .spec Service:
.spec.externalTrafficPolicy — визначає, чи має цей Service маршрутизувати зовнішній трафік до точок доступу на локальному вузлі чи до точок доступу в усьому кластері. Є два варіанти: Cluster (стандартно) і Local. Cluster приховує вихідну IP-адресу клієнта й може спричинити другий перехід на інший вузол, але має добре загальне розподілення навантаження. Local зберігає вихідну IP-адресу клієнта й уникає другого переходу для Services типів LoadBalancer і NodePort, але створює ризик нерівномірного розподілення трафіку.
.spec.healthCheckNodePort — задає порт вузла для перевірки справності (числовий номер порту) для сервісу. Якщо ви не вкажете healthCheckNodePort, контролер сервісів виділить порт із діапазону NodePort вашого кластера. Цей діапазон можна налаштувати параметром командного рядка API-сервера --service-node-port-range. Service використовуватиме вказане користувачем значення healthCheckNodePort, якщо ви його задасте, за умови, що type Service — LoadBalancer, а externalTrafficPolicy — Local.
Значення Local для externalTrafficPolicy у маніфесті Service вмикає цю можливість. Наприклад:
Застереження й обмеження під час збереження вихідних IP-адрес
Сервіси балансування навантаження деяких хмарних провайдерів не дозволяють налаштувати різну вагу для кожної цілі.
Коли всі цілі мають однакову вагу під час надсилання трафіку на вузли, зовнішній трафік розподіляється між різними Podʼами нерівномірно. Зовнішній балансувальник навантаження не знає, скільки Podʼів на кожному вузлі використовується як ціль.
Коли NumServicePods << NumNodes або NumServicePods >> NumNodes, розподіл буде досить близьким до рівномірного навіть без ваг.
Внутрішній трафік між Podʼами має поводитися так само, як у Services типу ClusterIP, з однаковою ймовірністю для всіх Podʼів.
Збір сміття балансувальників навантаження
СТАН ФУНКЦІОНАЛУ:GA since Kubernetes v1.17
Зазвичай відповідні ресурси балансувальника навантаження в хмарного провайдера мають бути очищені незабаром після видалення Service типу LoadBalancer. Але відомо, що існують різні крайні випадки, коли хмарні ресурси лишаються без власника після видалення повʼязаного Service. Щоб цьому запобігти, було введено захист Service типу LoadBalancer завершувачами. Завдяки завершувачам ресурс Service не буде видалено, доки не будуть видалені й відповідні ресурси балансувальника навантаження.
Зокрема, якщо Service має type LoadBalancer, контролер сервісів додає завершувач з назвою service.kubernetes.io/load-balancer-cleanup. Завершувач вилучається лише після очищення ресурсу балансувальника навантаження. Це запобігає появі завислих ресурсів балансувальника навантаження навіть у крайніх випадках, наприклад під час збою контролера сервісів.
Постачальники зовнішніх балансувальників навантаження
Важливо зазначити, що шлях даних для цієї можливості забезпечує балансувальник навантаження, зовнішній щодо кластера Kubernetes.
Коли type Service встановлено в LoadBalancer, Kubernetes надає Podʼам у кластері можливості, рівнозначні type ClusterIP, і розширює їх, програмуючи (зовнішній щодо Kubernetes) балансувальник навантаження записами для вузлів, на яких розміщені відповідні Podʼи Kubernetes. Панель управління Kubernetes автоматизує створення зовнішнього балансувальника навантаження, перевірки справності (за потреби) і правила фільтрації пакетів (за потреби). Після того як хмарний провайдер виділить IP-адресу для балансувальника навантаження, панель управління отримує цю зовнішню IP-адресу й заносить її в обʼєкт Service.
10.8 - Отримання переліку всіх образів контейнерів, що працюють у кластері
На цій сторінці показано, як за допомогою kubectl отримати перелік усіх образів контейнерів для Podʼів, що працюють у кластері.
Перш ніж ви розпочнете
Вам треба мати кластер Kubernetes, а також інструмент командного рядка kubectl має бути налаштований для роботи з вашим кластером. Рекомендується виконувати ці настанови у кластері, що має щонайменше два вузли, які не виконують роль вузлів управління. Якщо у вас немає кластера, ви можете створити його, за допомогою minikube або використовувати одну з цих пісочниць:
У цій вправі ви за допомогою kubectl отримаєте всі Podʼи, що працюють у кластері, і відформатуєте вивід, щоб отримати перелік контейнерів для кожного з них.
Перелік усіх образів контейнерів у всіх просторах імен
Отримайте всі Podʼи у всіх просторах імен за допомогою kubectl get pods --all-namespaces.
Відформатуйте вивід, щоб він містив лише перелік назв образів контейнерів, за допомогою -o jsonpath={.items[*].spec['initContainers', 'containers'][*].image}. Це рекурсивно витягне поле image з отриманого json.
['initContainers', 'containers'][*]: для кожного контейнера.
.image: отримати образ.
Примітка:
Під час отримання одного Podʼа за назвою, наприклад kubectl get pod nginx, частину шляху .items[*] слід пропустити, оскільки повертається один Pod, а не список елементів.
Перелік образів контейнерів за Podʼами
Форматування можна додатково контролювати за допомогою операції range, щоб перебирати елементи окремо.
kubectl get pods --all-namespaces -o jsonpath='{range .items[*]}{"\n"}{.metadata.name}{":\t"}{range .spec.containers[*]}{.image}{", "}{end}{end}'|\
sort
Перелік образів контейнерів із фільтрацією за міткою Podʼа
Щоб вибрати лише Podʼи з певною міткою, використовуйте прапорець -l. Наведена нижче команда вибирає лише Podʼи з міткою app=nginx.
kubectl get pods --all-namespaces -o jsonpath="{.items[*].spec.containers[*].image}" -l app=nginx
Перелік образів контейнерів із фільтрацією за простором імен Podʼа
Щоб вибрати лише Podʼи в певному просторі імен, використовуйте прапорець namespace. Наведена нижче команда вибирає лише Podʼи в просторі імен kube-system.
kubectl get pods --namespace kube-system -o jsonpath="{.items[*].spec.containers[*].image}"
Перелік образів контейнерів за допомогою go-template замість jsonpath
Як альтернативу jsonpath kubectl підтримує go-templates для форматування виводу:
kubectl get pods --all-namespaces -o go-template --template="{{range .items}}{{range .spec.containers}}{{.image}} {{end}}{{end}}"
10.9 - Взаємодія контейнерів в одному Podʼі за допомогою спільного тому
На цій сторінці показано, як використовувати том для взаємодії двох контейнерів, що працюють в одному Podʼі. Дивіться також, як дозволити процесам взаємодіяти через спільний простір імен процесів між контейнерами.
Перш ніж ви розпочнете
Вам треба мати кластер Kubernetes, а також інструмент командного рядка kubectl має бути налаштований для роботи з вашим кластером. Рекомендується виконувати ці настанови у кластері, що має щонайменше два вузли, які не виконують роль вузлів управління. Якщо у вас немає кластера, ви можете створити його, за допомогою minikube або використовувати одну з цих пісочниць:
У цій вправі ви створите Pod, який запускає два контейнери. Ці контейнери спільно використовують том, через який вони можуть взаємодіяти. Ось файл конфігурації Podʼа:
apiVersion:v1kind:Podmetadata:name:two-containersspec:restartPolicy:Nevervolumes:- name:shared-dataemptyDir:{}containers:- name:nginx-containerimage:nginxvolumeMounts:- name:shared-datamountPath:/usr/share/nginx/html- name:debian-containerimage:debianvolumeMounts:- name:shared-datamountPath:/pod-datacommand:["/bin/sh"]args:["-c","echo Hello from the debian container > /pod-data/index.html"]
У файлі конфігурації видно, що Pod має том з назвою shared-data.
Перший контейнер, вказаний у файлі конфігурації, запускає сервер nginx. Шлях монтування спільного тому — /usr/share/nginx/html. Другий контейнер базується на образі debian і має шлях монтування /pod-data. Другий контейнер виконує таку команду, а потім завершується.
echo Hello from the debian container > /pod-data/index.html
Зверніть увагу, що другий контейнер записує файл index.html в кореневу теку сервера nginx.
USER PID ... STAT START TIME COMMAND
root 1 ... Ss 21:12 0:00 nginx: master process nginx -g daemon off;
Згадайте, що контейнер debian створив файл index.html у кореневій теці nginx. Використайте curl, щоб надіслати GET-запит на сервер nginx:
root@two-containers:/# curl localhost
Вивід показує, що nginx обслуговує вебсторінку, записану контейнером debian:
Hello from the debian container
Обговорення
Основна причина, чому Podʼи можуть мати кілька контейнерів, — підтримка допоміжних застосунків, які допомагають основному застосунку. Типові приклади допоміжних застосунків — програми для отримання й надсилання даних, а також проксі. Допоміжні й основні застосунки часто мають взаємодіяти між собою. Зазвичай це робиться через спільну файлову систему, як показано в цій вправі, або через петлевий мережевий інтерфейс localhost. Приклад такого шаблону — вебсервер разом із допоміжною програмою, яка перевіряє наявність нових оновлень у репозиторії Git.
Том у цій вправі надає контейнерам спосіб взаємодіяти протягом життя Podʼа. Якщо Pod видалено й створено заново, усі дані, збережені в спільному томі, втрачаються.
Kubernetes пропонує надбудову DNS для кластера, яка стандартно ввімкнена в більшості підтримуваних середовищ. У Kubernetes версії 1.11 і новіших рекомендовано CoreDNS, який стандартно встановлюється з kubeadm.
10.11 - Доступ до сервісів, що працюють у кластерах
На цій сторінці показано, як підʼєднатися до сервісів, що працюють у кластері Kubernetes.
Перш ніж ви розпочнете
Вам треба мати кластер Kubernetes, а також інструмент командного рядка kubectl має бути налаштований для роботи з вашим кластером. Рекомендується виконувати ці настанови у кластері, що має щонайменше два вузли, які не виконують роль вузлів управління. Якщо у вас немає кластера, ви можете створити його, за допомогою minikube або використовувати одну з цих пісочниць:
У Kubernetes вузли, Podʼи і сервіси мають власні IP-адреси. У багатьох випадках IP-адреси вузлів, Podʼів і деяких сервісів у кластері не маршрутизуються, тому вони недосяжні з машини поза кластером, наприклад із вашого настільного компʼютера.
Способи підʼєднання
Є кілька варіантів підʼєднання до вузлів, Podʼів і сервісів ззовні кластера:
Доступ до сервісів через публічні IP-адреси.
Використайте Service типу NodePort або LoadBalancer, щоб зробити сервіс доступним ззовні кластера. Дивіться документацію про Services і kubectl expose.
Залежно від середовища кластера сервіс може стати доступним лише у вашій корпоративній мережі або в інтернеті. Подумайте, чи є сервіс, до якого відкривається доступ, безпечним. Чи виконує він власну автентифікацію?
Розміщуйте Podʼи за сервісами. Щоб отримати доступ до одного конкретного Podʼа з набору реплік, наприклад для налагодження, додайте до Podʼа унікальну мітку й створіть новий Service, який вибирає цю мітку.
У більшості випадків розробнику застосунків не потрібно звертатися до вузлів безпосередньо за їхніми nodeIP.
Доступ до сервісів, вузлів або Podʼів за допомогою дієслова Proxy.
Виконує автентифікацію й авторизацію на API-сервері перед доступом до віддаленого сервісу. Використовуйте це, якщо сервіси недостатньо безпечні для відкриття в інтернет, для доступу до портів на IP-адресі вузла або для налагодження.
Проксі можуть викликати проблеми для деяких вебзастосунків.
Запустіть Pod, а потім підʼєднайтеся до оболонки в ньому за допомогою kubectl exec. З цієї оболонки підʼєднуйтеся до інших вузлів, Podʼів і сервісів.
Деякі кластери дозволяють підʼєднатися до вузла кластера через ssh. Звідти ви зможете отримати доступ до сервісів кластера. Це нестандартний спосіб, який працює на одних кластерах і не працює на інших. Браузери та інші інструменти можуть бути не встановлені. DNS кластера може не працювати.
Виявлення вбудованих сервісів
Зазвичай у кластері є кілька сервісів, запущених у kube-system. Отримайте їх список командою kubectl cluster-info:
kubectl cluster-info
Вивід подібний до такого:
Kubernetes master is running at https://192.0.2.1
elasticsearch-logging is running at https://192.0.2.1/api/v1/namespaces/kube-system/services/elasticsearch-logging/proxy
kibana-logging is running at https://192.0.2.1/api/v1/namespaces/kube-system/services/kibana-logging/proxy
coredns is running at https://192.0.2.1/api/v1/namespaces/kube-system/services/kube-dns/proxy
grafana is running at https://192.0.2.1/api/v1/namespaces/kube-system/services/monitoring-grafana/proxy
heapster is running at https://192.0.2.1/api/v1/namespaces/kube-system/services/monitoring-heapster/proxy
Тут показано URL проксі-дієслова для доступу до кожного сервісу. Наприклад, у цьому кластері ввімкнено логування на рівні кластера (за допомогою Elasticsearch), до якого можна звернутися за адресою https://192.0.2.1/api/v1/namespaces/kube-system/services/elasticsearch-logging/proxy/ за наявності відповідних облікових даних або через kubectl proxy, наприклад за адресою http://localhost:8080/api/v1/namespaces/kube-system/services/elasticsearch-logging/proxy/.
Як згадано вище, URL проксі сервісу можна отримати командою kubectl cluster-info. Щоб створити URL проксі, які містять точки доступу сервісу, суфікси й параметри, додайте їх до URL проксі сервісу: http://kubernetes_master_address/api/v1/namespaces/namespace_name/services/[https:]service_name[:port_name]/proxy
Якщо ви не задали назву порту, port_name в URL вказувати не потрібно. Також можна використовувати номер порту замість port_name як для іменованих, так і для неіменованих портів.
Стандартно API-сервер проксіює запити до вашого сервісу через HTTP. Щоб використовувати HTTPS, додайте до назви сервісу префікс https:: http://<kubernetes_master_address>/api/v1/namespaces/<namespace_name>/services/<service_name>/proxy
Підтримувані формати сегмента <service_name> в URL:
<service_name> — проксіює до стандартного або неіменованого порту через http
<service_name>:<port_name> — проксіює до вказаної назви порту або номера порту через http
https:<service_name>: — проксіює до стандартного або неіменованого порту через https (зверніть увагу на двокрапку в кінці)
https:<service_name>:<port_name> — проксіює до вказаної назви порту або номера порту через https
Приклади
Щоб отримати доступ до точки доступу _search?q=user:kimchy сервісу Elasticsearch, використайте:
Використання браузерів для доступу до сервісів, що працюють у кластері
Ви можете ввести URL проксі API-сервера в адресний рядок браузера. Однак:
Браузери зазвичай не можуть передавати токени, тому може знадобитися базова автентифікація (пароль). API-сервер можна налаштувати на прийняття базової автентифікації, але ваш кластер може бути не налаштований на це.
Деякі вебзастосунки можуть не працювати, особливо ті, що мають клієнтський javascript, який створює URL, не враховуючи префікс шляху проксі.
11 - Розширення Kubernetes
Розуміння розширених способів адаптації кластера Kubernetes до потреб вашого робочого середовища.
11.1 - Використання власних ресурсів
11.2 - Налаштування шару агрегації
Налаштування шару агрегації дає змогу розширити API-сервер Kubernetes додатковими API, які не є частиною основних API Kubernetes.
Перш ніж ви розпочнете
Вам треба мати кластер Kubernetes, а також інструмент командного рядка kubectl має бути налаштований для роботи з вашим кластером. Рекомендується виконувати ці настанови у кластері, що має щонайменше два вузли, які не виконують роль вузлів управління. Якщо у вас немає кластера, ви можете створити його, за допомогою minikube або використовувати одну з цих пісочниць:
Щоб шар агрегації працював у вашому середовищі й підтримував взаємну автентифікацію 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-сервером розширення.
У цьому розділі описано, як працюють потоки автентифікації та авторизації та як їх налаштувати.
Загальний потік такий:
API-сервер Kubernetes: автентифікація користувача, що надсилає запит, і авторизація його прав на запитаний шлях API.
API-сервер Kubernetes: проксіювання запиту до API-сервера розширення
API-сервер розширення: автентифікація запиту від API-сервера Kubernetes
API-сервер розширення: авторизація запиту від початкового користувача
API-сервер розширення: виконання
У решті цього розділу ці кроки описано докладно.
Потік показано на наведеній нижче схемі.
Джерело наведених вище 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-сервера розширення, зареєстрованого для обробки цього запиту. Для цього йому потрібно знати кілька речей:
Як API-серверу Kubernetes автентифікуватися в API-сервері розширення, повідомляючи йому, що запит, який надходить мережею, походить від дійсного API-сервера Kubernetes?
Як 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-сервер розширення вважав запит дійсним, мають виконуватися такі умови:
Зʼєднання має бути встановлене за допомогою клієнтського сертифіката, підписаного CA, сертифікат якого міститься в --requestheader-client-ca-file.
Зʼєднання має бути встановлене за допомогою клієнтського сертифіката, CN якого є одним із перелічених у --requestheader-allowed-names.
Примітка:
Ви можете залишити цей параметр порожнім: --requestheader-allowed-names="". Це вкаже API-серверу розширення, що будь-який CN прийнятний.
Після запуску з цими параметрами API-сервер Kubernetes:
Використовуватиме їх для автентифікації в API-сервері розширення.
Створить 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-сервер розширення перевіряє це так:
Отримує наведене нижче з ConfigMap у kube-system, як описано вище:
Сертифікат CA клієнта
Список дозволених імен (CN)
Назви заголовків для імені користувача, групи та додаткової інформації
Перевіряє, що зʼєднання 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/v1kind:APIServicemetadata: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>
Коли API-сервер Kubernetes визначив, що запит потрібно надіслати до API-сервера розширення, йому потрібно знати, як із ним звʼязатися.
Блок service — це посилання на сервіс API-сервера розширення. Простір імен і назва сервісу обовʼязкові. Порт необовʼязковий, стандартно 443.
Ось приклад API-сервера розширення, налаштованого на виклики через порт "1234" і перевірку зʼєднання TLS за ServerName my-service-name.my-service-namespace.svc з використанням власного набору CA.
Налаштування API-сервера розширення для роботи із шаром агрегації дає змогу розширювати API-сервер Kubernetes додатковими API, які не є частиною основних API Kubernetes.
Перш ніж ви розпочнете
Вам треба мати кластер Kubernetes, а також інструмент командного рядка kubectl має бути налаштований для роботи з вашим кластером. Рекомендується виконувати ці настанови у кластері, що має щонайменше два вузли, які не виконують роль вузлів управління. Якщо у вас немає кластера, ви можете створити його, за допомогою minikube або використовувати одну з цих пісочниць:
Налаштування API-сервера розширення для роботи із шаром агрегації
Наведені нижче кроки описують налаштування API-сервера розширення на високому рівні. Ці кроки застосовні незалежно від того, чи використовуєте ви конфігурації YAML, чи API. Ми намагаємося окремо вказати всі відмінності між цими двома підходами. Конкретний приклад їх реалізації за допомогою конфігурацій YAML дивіться в sample-apiserver у репозиторії Kubernetes.
Також можна використати наявне стороннє рішення, як-от apiserver-builder, яке має згенерувати каркас і автоматизувати всі наведені нижче кроки за вас.
Переконайтеся, що API APIService увімкнено (перевірте --runtime-config). Стандартно він має бути увімкнений, якщо його свідомо не вимкнули у вашому кластері.
Можливо, вам потрібно створити правило RBAC, яке дозволяє додавати обʼєкти APIService, або попросити про це адміністратора кластера. (Оскільки розширення API впливають на весь кластер, не рекомендовано тестувати, розробляти чи налагоджувати розширення API в робочому кластері.)
Створіть простір імен Kubernetes, у якому ви хочете запустити свій api-service розширення.
Створіть або отримайте сертифікат CA, який використовуватиметься для підпису серверного сертифіката, що його API-сервер розширення використовує для HTTPS.
Створіть серверний сертифікат і ключ, які API-сервер використовуватиме для HTTPS. Цей сертифікат має бути підписаний наведеним вище CA. Він також повинен мати CN з іменем Kube DNS. Це імʼя походить від сервісу Kubernetes і має вигляд <service name>.<service name namespace>.svc
Створіть Secret Kubernetes із серверним сертифікатом і ключем у вашому просторі імен.
Створіть Deployment Kubernetes для API-сервера розширення й переконайтеся, що завантажуєте Secret як том. Він має містити посилання на робочий образ вашого API-сервера розширення. Deployment також має бути у вашому просторі імен.
Переконайтеся, що ваш API-сервер розширення завантажує ці сертифікати з цього тому і що вони використовуються під час рукостискання HTTPS.
Створіть службовий обліковий запис Kubernetes у вашому просторі імен.
Створіть кластерну роль Kubernetes для операцій, які ви хочете дозволити над вашими ресурсами.
Створіть привʼязку кластерної ролі Kubernetes від службового облікового запису у вашому просторі імен до створеної кластерної ролі.
Створіть привʼязку кластерної ролі Kubernetes від службового облікового запису у вашому просторі імен до кластерної ролі system:auth-delegator, щоб делегувати рішення щодо автентифікації основному API-серверу Kubernetes.
Створіть привʼязку ролі Kubernetes від службового облікового запису у вашому просторі імен до ролі extension-apiserver-authentication-reader. Це дає вашому API-серверу розширення доступ до ConfigMap extension-apiserver-authentication.
Створіть apiservice Kubernetes. Наведений вище сертифікат CA має бути закодований у base64, без нових рядків, і використаний як spec.caBundle в apiservice. Він не має належати до простору імен. Якщо ви використовуєте kube-aggregator API, передавайте лише набір CA у кодуванні PEM, оскільки кодування base64 виконується за вас.
Використайте kubectl, щоб отримати ваш ресурс. Під час виконання kubectl має повернути "No resources found.". Це повідомлення вказує, що все спрацювало, але наразі у вас немає створених обʼєктів цього типу ресурсу.
Kubernetes постачається зі стандартним планувальником, описаним тут. Якщо стандартний планувальник не відповідає вашим потребам, ви можете реалізувати власний. Більше того, можна одночасно запускати кілька планувальників поряд зі стандартним і вказувати Kubernetes, який планувальник використовувати для кожного з ваших Podʼів. Розгляньмо на прикладі, як запускати кілька планувальників у Kubernetes.
Докладний опис реалізації планувальника виходить за межі цього документа. Канонічний приклад дивіться в реалізації kube-scheduler у pkg/scheduler у теці вихідного коду Kubernetes.
Перш ніж ви розпочнете
Вам треба мати кластер Kubernetes, а також інструмент командного рядка kubectl має бути налаштований для роботи з вашим кластером. Рекомендується виконувати ці настанови у кластері, що має щонайменше два вузли, які не виконують роль вузлів управління. Якщо у вас немає кластера, ви можете створити його, за допомогою minikube або використовувати одну з цих пісочниць:
Упакуйте бінарний файл планувальника в образ контейнера. Для цього прикладу можна використати стандартний планувальник (kube-scheduler) як другий планувальник. Клонуйте вихідний код Kubernetes із GitHub і зберіть його.
git clone https://github.com/kubernetes/kubernetes.git
cd kubernetes
make
Створіть образ контейнера, що містить бінарний файл kube-scheduler. Ось Dockerfile для збирання образу:
FROM busyboxADD ./_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:
У наведеному вище маніфесті використано 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.
Перед розгортанням кількох планувальників або профілів планування ознайомтеся з розділом Запуск кількох планувальників, щоб зрозуміти різні стратегії розгортання та уникнути конфліктів планування ресурсів.
Щоб запустити планувальник у кластері 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, як у наведеному нижче прикладі:
Тепер, коли другий планувальник працює, створіть кілька Podʼів і вкажіть, щоб їх планував або стандартний планувальник, або той, який ви розгорнули. Щоб запланувати певний Pod за допомогою конкретного планувальника, вкажіть назву планувальника у специфікації цього Podʼа. Розгляньмо три приклади.
Планувальник задається вказанням його назви як значення spec.schedulerName. У цьому випадку ми вказуємо назву стандартного планувальника, тобто default-scheduler.
Збережіть цей файл як pod2.yaml і надішліть його до кластера Kubernetes.
У цьому випадку ми вказуємо, що цей 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ʼа на відповідних вузлах панелі управління.
11.5 - Використання HTTP-проксі для доступу до Kubernetes API
На цій сторінці показано, як використовувати HTTP-проксі для доступу до Kubernetes API.
Перш ніж ви розпочнете
Вам треба мати кластер Kubernetes, а також інструмент командного рядка kubectl має бути налаштований для роботи з вашим кластером. Рекомендується виконувати ці настанови у кластері, що має щонайменше два вузли, які не виконують роль вузлів управління. Якщо у вас немає кластера, ви можете створити його, за допомогою minikube або використовувати одну з цих пісочниць:
11.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. Використання змінної середовища:
exportHTTPS_PROXY=socks5://localhost:1080
Щоб завжди використовувати це налаштування в конкретному контексті kubectl, вкажіть атрибут proxy-url у відповідному записі cluster у файлі ~/.kube/config. Наприклад:
apiVersion:v1clusters:- cluster:certificate-authority-data:LRMEMMW2# скорочено для читабельностіserver:https://<API_SERVER_IP_ADDRESS>:6443 # сервер "Kubernetes API", тобто IP-адреса kubernetes-remote-server.exampleproxy-url:socks5://localhost:1080 # "SSH SOCKS5 проксі" на діаграмі вищеname:defaultcontexts:- context:cluster:defaultuser:defaultname:defaultcurrent-context:defaultkind:Configpreferences:{}users:- name:defaultuser: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-трафіку через проксі.
Служба Konnectivity надає проксі на рівні TCP для звʼязку панелі управління з кластером.
Перш ніж ви розпочнете
Вам потрібен кластер Kubernetes, а інструмент командного рядка kubectl має бути налаштований на звʼязок із вашим кластером. Рекомендовано виконувати цей навчальний матеріал на кластері щонайменше з двома вузлами, які не є хостами панелі управління. Якщо у вас ще немає кластера, ви можете створити його за допомогою minikube.
Налаштування служби Konnectivity
Для виконання наведених нижче кроків потрібна конфігурація egress, наприклад:
apiVersion:apiserver.k8s.io/v1beta1kind:EgressSelectorConfigurationegressSelections:# 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:clusterconnection:# 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:GRPCtransport:# 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 і спрямування мережевого трафіку на вузли кластера:
Згенеруйте або отримайте сертифікат і kubeconfig для konnectivity-server. Наприклад, можна використати інструмент командного рядка OpenSSL, щоб видати сертифікат X.509 за допомогою сертифіката CA кластера /etc/kubernetes/pki/ca.crt з хоста панелі управління.
Розгорніть сервер Konnectivity на вузлі панелі управління. Наданий маніфест konnectivity-server.yaml передбачає, що компоненти Kubernetes розгорнуто як статичний Pod у вашому кластері. Якщо ні, сервер Konnectivity можна розгорнути як DaemonSet.
apiVersion:v1kind:Podmetadata:name:konnectivity-servernamespace:kube-systemspec:priorityClassName:system-cluster-criticalhostNetwork:truecontainers:- name:konnectivity-server-containerimage:registry.k8s.io/kas-network-proxy/proxy-server:v0.0.37command:["/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:HTTPhost:127.0.0.1port:8134path:/healthzinitialDelaySeconds:30timeoutSeconds:60ports:- name:agentportcontainerPort:8132hostPort:8132- name:adminportcontainerPort:8133hostPort:8133- name:healthportcontainerPort:8134hostPort:8134volumeMounts:- name:k8s-certsmountPath:/etc/kubernetes/pkireadOnly:true- name:kubeconfigmountPath:/etc/kubernetes/konnectivity-server.confreadOnly:true- name:konnectivity-udsmountPath:/etc/kubernetes/konnectivity-serverreadOnly:falsevolumes:- name:k8s-certshostPath:path:/etc/kubernetes/pki- name:kubeconfighostPath:path:/etc/kubernetes/konnectivity-server.conftype:FileOrCreate- name:konnectivity-udshostPath:path:/etc/kubernetes/konnectivity-servertype:DirectoryOrCreate
Потім розгорніть агентів Konnectivity у вашому кластері:
apiVersion:apps/v1# Як альтернативу, ви можете розгорнути агентів як Deployment. Не обовʼязково# мати агента на кожному вузлі.kind:DaemonSetmetadata:labels:addonmanager.kubernetes.io/mode:Reconcilek8s-app:konnectivity-agentnamespace:kube-systemname:konnectivity-agentspec:selector:matchLabels:k8s-app:konnectivity-agenttemplate:metadata:labels:k8s-app:konnectivity-agentspec:priorityClassName:system-cluster-criticaltolerations:- key:"CriticalAddonsOnly"operator:"Exists"containers:- image:us.gcr.io/k8s-artifacts-prod/kas-network-proxy/proxy-agent:v0.0.37name:konnectivity-agentcommand:["/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/tokensname:konnectivity-agent-tokenlivenessProbe:httpGet:port:8134path:/healthzinitialDelaySeconds:15timeoutSeconds:15serviceAccountName:konnectivity-agentvolumes:- name:konnectivity-agent-tokenprojected:sources:- serviceAccountToken:path:konnectivity-agent-tokenaudience:system:konnectivity-server
Нарешті, якщо RBAC увімкнено у вашому кластері, створіть відповідні правила RBAC:
Дізнайтеся, як захистити трафік у кластері за допомогою Transport Layer Security (TLS).
12.1 - Видача сертифіката для клієнта API Kubernetes за допомогою CertificateSigningRequest
Kubernetes дозволяє використовувати інфраструктуру відкритих ключів (PKI) для автентифікації в кластері як клієнт.
Щоб звичайний користувач міг автентифікуватися й викликати API, потрібно виконати кілька кроків. Спочатку цей користувач повинен мати сертифікат X.509, виданий органом, якому довіряє ваш кластер Kubernetes. Потім клієнт повинен предʼявити цей сертифікат API Kubernetes.
У цьому процесі ви використовуєте CertificateSigningRequest; ви або інший субʼєкт маєте схвалити запит.
Ви створите приватний ключ, потім отримаєте виданий сертифікат і, нарешті, налаштуєте цей приватний ключ для клієнта.
Перш ніж ви розпочнете
Вам треба мати кластер Kubernetes, а також інструмент командного рядка kubectl має бути налаштований для роботи з вашим кластером. Рекомендується виконувати ці настанови у кластері, що має щонайменше два вузли, які не виконують роль вузлів управління. Якщо у вас немає кластера, ви можете створити його, за допомогою minikube або використовувати одну з цих пісочниць:
Вам знадобляться утиліти kubectl, openssl та base64.
Ця сторінка передбачає, що ви використовуєте контроль доступу на основі ролей (RBAC) Kubernetes. Якщо у вас є альтернативні або додаткові механізми безпеки для авторизації, їх також потрібно врахувати.
Створіть приватний ключ
На цьому кроці ви створюєте приватний ключ. Цей приватний ключ потрібно тримати в таємниці; будь-хто, хто ним володіє, може видавати себе за цього користувача.
Це не те саме, що API CertificateSigningRequest з подібною назвою; файл, який ви тут генеруєте, передається в CertificateSigningRequest.
Важливо встановити атрибути CN та O для CSR. CN — це імʼя користувача, а O — група, до якої належатиме цей користувач. Стандартні групи описано на сторінці RBAC.
# Змініть загальне імʼя "myuser" на фактичне імʼя користувача, яке ви хочете використовуватиopenssl req -new -key myuser.key -out myuser.csr -subj "/CN=myuser"
Створіть CertificateSigningRequest Kubernetes
Закодуйте документ CSR за допомогою цієї команди:
cat myuser.csr | base64 | tr -d "\n"
Створіть CertificateSigningRequest і надішліть його до кластера Kubernetes за допомогою kubectl. Нижче наведено фрагмент команд оболонки, за допомогою якого можна згенерувати CertificateSigningRequest.
cat <<EOF | kubectl apply -f -
apiVersion: certificates.k8s.io/v1
kind: CertificateSigningRequest
metadata:
name: myuser # example
spec:
# Це закодований CSR. Змініть його на вміст myuser.csr у кодуванні base64
request: LS0tLS1CRUdJTiBDRVJUSUZJQ0FURSBSRVFVRVNULS0tLS0KTUlJQ1ZqQ0NBVDRDQVFBd0VURVBNQTBHQTFVRUF3d0dZVzVuWld4aE1JSUJJakFOQmdrcWhraUc5dzBCQVFFRgpBQU9DQVE4QU1JSUJDZ0tDQVFFQTByczhJTHRHdTYxakx2dHhWTTJSVlRWMDNHWlJTWWw0dWluVWo4RElaWjBOCnR2MUZtRVFSd3VoaUZsOFEzcWl0Qm0wMUFSMkNJVXBGd2ZzSjZ4MXF3ckJzVkhZbGlBNVhwRVpZM3ExcGswSDQKM3Z3aGJlK1o2MVNrVHF5SVBYUUwrTWM5T1Nsbm0xb0R2N0NtSkZNMUlMRVI3QTVGZnZKOEdFRjJ6dHBoaUlFMwpub1dtdHNZb3JuT2wzc2lHQ2ZGZzR4Zmd4eW8ybmlneFNVekl1bXNnVm9PM2ttT0x1RVF6cXpkakJ3TFJXbWlECklmMXBMWnoyalVnald4UkhCM1gyWnVVV1d1T09PZnpXM01LaE8ybHEvZi9DdS8wYk83c0x0MCt3U2ZMSU91TFcKcW90blZtRmxMMytqTy82WDNDKzBERHk5aUtwbXJjVDBnWGZLemE1dHJRSURBUUFCb0FBd0RRWUpLb1pJaHZjTgpBUUVMQlFBRGdnRUJBR05WdmVIOGR4ZzNvK21VeVRkbmFjVmQ1N24zSkExdnZEU1JWREkyQTZ1eXN3ZFp1L1BVCkkwZXpZWFV0RVNnSk1IRmQycVVNMjNuNVJsSXJ3R0xuUXFISUh5VStWWHhsdnZsRnpNOVpEWllSTmU3QlJvYXgKQVlEdUI5STZXT3FYbkFvczFqRmxNUG5NbFpqdU5kSGxpT1BjTU1oNndLaTZzZFhpVStHYTJ2RUVLY01jSVUyRgpvU2djUWdMYTk0aEpacGk3ZnNMdm1OQUxoT045UHdNMGM1dVJVejV4T0dGMUtCbWRSeEgvbUNOS2JKYjFRQm1HCkkwYitEUEdaTktXTU0xMzhIQXdoV0tkNjVoVHdYOWl4V3ZHMkh4TG1WQzg0L1BHT0tWQW9FNkpsYWFHdTlQVmkKdjlOSjVaZlZrcXdCd0hKbzZXdk9xVlA3SVFjZmg3d0drWm89Ci0tLS0tRU5EIENFUlRJRklDQVRFIFJFUVVFU1QtLS0tLQo=
signerName: kubernetes.io/kube-apiserver-client
expirationSeconds: 86400 # one day
usages:
- client auth
EOF
Також можна створити файл маніфесту YAML і застосувати його за допомогою kubectl:
apiVersion:certificates.k8s.io/v1kind:CertificateSigningRequestmetadata:name:myuser# examplespec:# This is an encoded CSR. Change this to the base64-encoded contents of myuser.csrrequest:LS0tLS1CRUdJTiBDRVJUSUZJQ0FURSBSRVFVRVNULS0tLS0KTUlJQ1ZqQ0NBVDRDQVFBd0VURVBNQTBHQTFVRUF3d0dZVzVuWld4aE1JSUJJakFOQmdrcWhraUc5dzBCQVFFRgpBQU9DQVE4QU1JSUJDZ0tDQVFFQTByczhJTHRHdTYxakx2dHhWTTJSVlRWMDNHWlJTWWw0dWluVWo4RElaWjBOCnR2MUZtRVFSd3VoaUZsOFEzcWl0Qm0wMUFSMkNJVXBGd2ZzSjZ4MXF3ckJzVkhZbGlBNVhwRVpZM3ExcGswSDQKM3Z3aGJlK1o2MVNrVHF5SVBYUUwrTWM5T1Nsbm0xb0R2N0NtSkZNMUlMRVI3QTVGZnZKOEdFRjJ6dHBoaUlFMwpub1dtdHNZb3JuT2wzc2lHQ2ZGZzR4Zmd4eW8ybmlneFNVekl1bXNnVm9PM2ttT0x1RVF6cXpkakJ3TFJXbWlECklmMXBMWnoyalVnald4UkhCM1gyWnVVV1d1T09PZnpXM01LaE8ybHEvZi9DdS8wYk83c0x0MCt3U2ZMSU91TFcKcW90blZtRmxMMytqTy82WDNDKzBERHk5aUtwbXJjVDBnWGZLemE1dHJRSURBUUFCb0FBd0RRWUpLb1pJaHZjTgpBUUVMQlFBRGdnRUJBR05WdmVIOGR4ZzNvK21VeVRkbmFjVmQ1N24zSkExdnZEU1JWREkyQTZ1eXN3ZFp1L1BVCkkwZXpZWFV0RVNnSk1IRmQycVVNMjNuNVJsSXJ3R0xuUXFISUh5VStWWHhsdnZsRnpNOVpEWllSTmU3QlJvYXgKQVlEdUI5STZXT3FYbkFvczFqRmxNUG5NbFpqdU5kSGxpT1BjTU1oNndLaTZzZFhpVStHYTJ2RUVLY01jSVUyRgpvU2djUWdMYTk0aEpacGk3ZnNMdm1OQUxoT045UHdNMGM1dVJVejV4T0dGMUtCbWRSeEgvbUNOS2JKYjFRQm1HCkkwYitEUEdaTktXTU0xMzhIQXdoV0tkNjVoVHdYOWl4V3ZHMkh4TG1WQzg0L1BHT0tWQW9FNkpsYWFHdTlQVmkKdjlOSjVaZlZrcXdCd0hKbzZXdk9xVlA3SVFjZmg3d0drWm89Ci0tLS0tRU5EIENFUlRJRklDQVRFIFJFUVVFU1QtLS0tLQo=signerName:kubernetes.io/kube-apiserver-clientexpirationSeconds:86400# one dayusages:- client auth
Застосуйте маніфест:
kubectl apply -f myuser.yaml --server-side
Зверніть увагу на кілька моментів:
usages має бути client auth.
expirationSeconds можна зробити довшим (наприклад, 864000 для десяти днів) або коротшим (наприклад, 3600 для однієї години). Не можна запитати тривалість менше ніж 10 хвилин.
request — це закодоване в base64 значення вмісту файлу CSR.
Схваліть CertificateSigningRequest
Використайте kubectl, щоб знайти створений вами CSR, і схваліть його вручну.
Отримайте список CSR:
kubectl get csr
Схваліть CSR:
kubectl certificate approve myuser
Отримайте сертифікат
Отримайте сертифікат із CSR, щоб перевірити, чи він виглядає правильно.
kubectl get csr/myuser -o yaml
Значення сертифіката міститься у форматі Base64 у .status.certificate.
Експортуйте виданий сертифікат з CertificateSigningRequest.
kubectl get csr myuser -o jsonpath='{.status.certificate}'| base64 -d > myuser.crt
Налаштуйте сертифікат у kubeconfig
Наступний крок — додати цього користувача до файлу kubeconfig.
Ви маєте побачити вивід, який підтверджує, що ви — «myuser».
Створіть Role та RoleBinding
Примітка:
Якщо ви не використовуєте RBAC Kubernetes, пропустіть цей крок і внесіть відповідні зміни для механізму авторизації, який фактично використовує ваш кластер.
Після створення сертифіката настав час визначити Role і RoleBinding, щоб цей користувач мав доступ до ресурсів кластера Kubernetes.
Це приклад команди для створення Role для цього нового користувача:
kubectl create role developer --verb=create --verb=get --verb=list --verb=update --verb=delete --resource=pods
Kubernetes надає API certificates.k8s.io, який дозволяє отримувати сертифікати TLS, підписані центром сертифікації (CA), який ви контролюєте. Ці CA й сертифікати ваші робочі навантаження можуть використовувати для встановлення довіри.
API certificates.k8s.io використовує протокол, подібний до чернетки ACME.
Примітка:
Сертифікати, створені за допомогою API certificates.k8s.io, підписуються окремим CA. Кластер можна налаштувати на використання для цього кореневого CA кластера, але ніколи не слід на це покладатися. Не вважайте, що ці сертифікати проходитимуть перевірку кореневим CA кластера.
Перш ніж ви розпочнете
Вам треба мати кластер Kubernetes, а також інструмент командного рядка kubectl має бути налаштований для роботи з вашим кластером. Рекомендується виконувати ці настанови у кластері, що має щонайменше два вузли, які не виконують роль вузлів управління. Якщо у вас немає кластера, ви можете створити його, за допомогою minikube або використовувати одну з цих пісочниць:
Деякі кроки на цій сторінці використовують інструмент jq. Якщо у вас немає jq, ви можете встановити його із джерел програмного забезпечення вашої операційної системи або завантажити з https://jqlang.github.io/jq/.
Довіра до TLS у кластері
Довіра до власного CA із застосунку, що працює як Pod, зазвичай потребує додаткової конфігурації застосунку. Потрібно додати набір сертифікатів CA до списку сертифікатів CA, яким довіряє клієнт або сервер TLS. Наприклад, у конфігурації TLS у Golang для цього можна розібрати ланцюжок сертифікатів і додати розібрані сертифікати до поля RootCAs у структурі tls.Config.
Примітка:
Хоча власний сертифікат CA може бути у файловій системі (у ConfigMap kube-root-ca.crt), не слід використовувати цей центр сертифікації для будь-яких цілей, окрім перевірки внутрішніх точок доступу Kubernetes. Приклад внутрішньої точки доступу Kubernetes — Service з назвою kubernetes у просторі імен default.
Якщо ви хочете використовувати власний центр сертифікації для робочих навантажень, слід згенерувати цей CA окремо й розповсюдити його сертифікат CA за допомогою ConfigMap, який ваші Podʼи можуть читати.
Запит сертифіката
У наведеному нижче розділі показано, як створити сертифікат TLS для сервісу Kubernetes, до якого звертаються через DNS.
Примітка:
У цьому навчальному матеріалі використовується CFSSL: набір інструментів PKI та TLS від Cloudflare. Докладніше дивіться в статті блогу Cloudflare Introducing CFSSL - CloudFlare's PKI toolkit.
Створення запиту на підписання сертифіката
Згенеруйте приватний ключ і запит на підписання сертифіката (CSR), виконавши таку команду:
Де 192.0.2.24 — кластерний IP сервісу, my-svc.my-namespace.svc.cluster.local — DNS-імʼя сервісу, 10.0.34.2 — IP Podʼа, а my-pod.my-namespace.pod.cluster.local — DNS-імʼя Podʼа. Ви маєте побачити вивід, подібний до такого:
Ця команда генерує два файли: server.csr із запитом на сертифікат PKCS#10 у кодуванні PEM і server-key.pem із ключем у кодуванні PEM до сертифіката, який ще буде створено.
Створення обʼєкта CertificateSigningRequest для надсилання до API Kubernetes
Згенеруйте маніфест CSR (у форматі YAML) і надішліть його на API-сервер. Для цього виконайте таку команду:
Зверніть увагу, що файл server.csr, створений на кроці 1, закодовано в base64 і поміщено в поле .spec.request. Ви також запитуєте сертифікат із використаннями ключа "digital signature", "key encipherment" і "server auth", підписаний прикладом підписувача example.com/serving. Потрібно запитати конкретний signerName. Докладніше дивіться в документації про підтримувані назви підписувачів.
Тепер CSR має бути видимий в API у стані Pending. Його можна побачити, виконавши:
kubectl describe csr my-svc.my-namespace
Name: my-svc.my-namespace
Labels: <none>
Annotations: <none>
CreationTimestamp: Tue, 01 Feb 2022 11:49:15 -0500
Requesting User: yourname@example.com
Signer: example.com/serving
Status: Pending
Subject:
Common Name: my-pod.my-namespace.pod.cluster.local
Serial Number:
Subject Alternative Names:
DNS Names: my-pod.my-namespace.pod.cluster.local
my-svc.my-namespace.svc.cluster.local
IP Addresses: 192.0.2.24
10.0.34.2
Events: <none>
Отримання схвалення CertificateSigningRequest
Схвалення запиту на підписання сертифіката виконується або автоматичним процесом схвалення, або разово адміністратором кластера. Якщо ви маєте право схвалювати запити на сертифікати, це можна зробити вручну за допомогою kubectl; наприклад:
NAME AGE SIGNERNAME REQUESTOR REQUESTEDDURATION CONDITION
my-svc.my-namespace 10m example.com/serving yourname@example.com <none> Approved
Це означає, що запит на сертифікат схвалено і він чекає, поки запитаний підписувач його підпише.
Підписання CertificateSigningRequest
Далі ви зіграєте роль підписувача сертифікатів, видасте сертифікат і завантажите його в API.
Підписувач зазвичай відстежує в API CertificateSigningRequest обʼєкти зі своїм signerName, перевіряє, що їх схвалено, підписує сертифікати для цих запитів і оновлює статус обʼєкта API, додаючи виданий сертифікат.
Створення центру сертифікації
Вам потрібен центр сертифікації, який надасть цифровий підпис для нового сертифіката.
Спочатку створіть сертифікат для підписування, виконавши таку команду:
cat <<EOF | cfssl gencert -initca - | cfssljson -bare ca
{
"CN": "My Example Signer",
"key": {
"algo": "rsa",
"size": 2048
}
}
EOF
Ви маєте побачити вивід, подібний до такого:
2022/02/01 11:50:39 [INFO] generating a new CA key and certificate from CSR
2022/02/01 11:50:39 [INFO] generate received request
2022/02/01 11:50:39 [INFO] received CSR
2022/02/01 11:50:39 [INFO] generating key: rsa-2048
2022/02/01 11:50:39 [INFO] encoded CSR
2022/02/01 11:50:39 [INFO] signed certificate with serial number 263983151013686720899716354349605500797834580472
Це створює файл ключа центру сертифікації (ca-key.pem) і сертифікат (ca.pem).
Використайте конфігурацію підписування server-signing-config.json, а також файл ключа й сертифікат центру сертифікації, щоб підписати запит на сертифікат:
Тут використовується інструмент командного рядка jq для заповнення поля .status.certificate вмістом, закодованим у base64. Якщо у вас немає jq, можна також зберегти вивід JSON у файл, заповнити це поле вручну й завантажити отриманий файл.
Після схвалення CSR і завантаження підписаного сертифіката виконайте:
kubectl get csr
Вивід подібний до такого:
NAME AGE SIGNERNAME REQUESTOR REQUESTEDDURATION CONDITION
my-svc.my-namespace 20m example.com/serving yourname@example.com <none> Approved,Issued
Завантаження сертифіката та його використання
Тепер як користувач, що подав запит, ви можете завантажити виданий сертифікат і зберегти його у файл server.crt, виконавши таку команду:
Тепер ви можете додати server.crt і server-key.pem до Secret, який пізніше можна змонтувати в Pod (наприклад, для використання з вебсервером, що обслуговує HTTPS).
kubectl create secret tls server --cert server.crt --key server-key.pem
secret/server created
Нарешті, ви можете зберегти ca.pem у ConfigMap і використовувати його як корінь довіри для перевірки серверного сертифіката:
Адміністратор Kubernetes (з відповідними дозволами) може вручну схвалювати або відхиляти CertificateSigningRequests за допомогою команд kubectl certificate approve і kubectl certificate deny. Однак якщо ви плануєте активно використовувати цей API, варто розглянути написання автоматизованого контролера сертифікатів.
Увага:
Можливість схвалювати CSR визначає, хто кому довіряє у вашому середовищі. Цю можливість не слід надавати широко або легковажно.
Перш ніж надати дозвіл approve, переконайтеся, що ви впевнено розумієте і вимоги до перевірки, покладені на схвалювача, і наслідки видачі конкретного сертифіката.
Незалежно від того, чи є схвалювач машиною, чи людиною, що використовує kubectl, як описано вище, роль схвалювача полягає в перевірці, що CSR відповідає двом вимогам:
Субʼєкт CSR контролює приватний ключ, використаний для підписання CSR. Це усуває загрозу того, що третя сторона видаватиме себе за авторизованого субʼєкта. У наведеному вище прикладі цей крок полягав би в перевірці, що Pod контролює приватний ключ, використаний для генерації CSR.
Субʼєкт CSR має право діяти в запитаному контексті. Це усуває загрозу приєднання до кластера небажаного субʼєкта. У наведеному вище прикладі цей крок полягав би в перевірці, що Pod має право брати участь у запитаному сервісі.
Схвалювач має схвалити CSR тоді й лише тоді, коли виконано ці дві вимоги; інакше він має відхилити CSR.
Ця сторінка передбачає, що підписувач налаштований обслуговувати API сертифікатів. Менеджер контролерів Kubernetes надає стандартну реалізацію підписувача. Щоб увімкнути її, передайте менеджеру контролерів параметри --cluster-signing-cert-file і --cluster-signing-key-file зі шляхами до пари ключів вашого центру сертифікації.
12.3 - Налаштування ротації сертифікатів для kubelet
На цій сторінці показано, як увімкнути й налаштувати ротацію сертифікатів для kubelet.
СТАН ФУНКЦІОНАЛУ:GA since Kubernetes v1.19
Перш ніж ви розпочнете
Потрібна версія Kubernetes 1.8.0 або новіша
Огляд
kubelet використовує сертифікати для автентифікації в API Kubernetes. Стандартно ці сертифікати видаються на один рік, щоб їх не потрібно було оновлювати надто часто.
Kubernetes містить ротацію сертифікатів kubelet, яка автоматично генерує новий ключ і запитує новий сертифікат в API Kubernetes, коли строк дії поточного сертифіката наближається до завершення. Щойно новий сертифікат стане доступним, він використовуватиметься для автентифікації зʼєднань з API Kubernetes.
Увімкнення ротації клієнтських сертифікатів
Процес kubelet приймає аргумент --rotate-certificates, який визначає, чи автоматично kubelet запитуватиме новий сертифікат, коли наближається завершення строку дії поточного сертифіката.
Процес kube-controller-manager приймає аргумент --cluster-signing-duration (--experimental-cluster-signing-duration до версії 1.19), який визначає, на який строк видаватимуться сертифікати.
Розуміння налаштувань ротації сертифікатів
Якщо під час запуску kubelet налаштований на початкове завантаження (за допомогою прапорця --bootstrap-kubeconfig), він використає свій початковий сертифікат, щоб підʼєднатися до API Kubernetes і надіслати запит на підписання сертифіката. Переглянути стан запитів на підписання сертифікатів можна за допомогою:
kubectl get csr
Спочатку запит на підписання сертифіката від kubelet на вузлі матиме статус Pending. Якщо запит відповідає певним критеріям, менеджер контролерів автоматично схвалить його, і він матиме статус Approved. Далі менеджер контролерів підпише сертифікат, виданий на строк, вказаний параметром --cluster-signing-duration, і підписаний сертифікат буде прикріплено до запиту на підписання сертифіката.
kubelet отримає підписаний сертифікат з API Kubernetes і запише його на диск у місце, вказане в --cert-dir. Потім kubelet використовуватиме новий сертифікат для підʼєднання до API Kubernetes.
Коли наближається завершення строку дії підписаного сертифіката, kubelet автоматично надсилає новий запит на підписання сертифіката через API Kubernetes. Це може статися в будь-який момент, коли лишається від 30% до 10% строку дії сертифіката. Менеджер контролерів знову автоматично схвалює запит на сертифікат і прикріплює підписаний сертифікат до запиту на підписання сертифіката. kubelet отримує новий підписаний сертифікат з API Kubernetes і записує його на диск. Потім він оновлює свої зʼєднання з API Kubernetes, щоб перепідʼєднатися з новим сертифікатом.
12.4 - Ручна ротація сертифікатів центру сертифікації (CA)
На цій сторінці показано, як вручну виконати ротацію сертифікатів центру сертифікації (CA).
Перш ніж ви розпочнете
Вам треба мати кластер Kubernetes, а також інструмент командного рядка kubectl має бути налаштований для роботи з вашим кластером. Рекомендується виконувати ці настанови у кластері, що має щонайменше два вузли, які не виконують роль вузлів управління. Якщо у вас немає кластера, ви можете створити його, за допомогою minikube або використовувати одну з цих пісочниць:
Докладніше про автентифікацію в Kubernetes дивіться в розділі Автентифікація.
Докладніше про рекомендації щодо сертифікатів CA дивіться в розділі Один кореневий CA.
Ручна ротація сертифікатів CA
Увага:
Обовʼязково створіть резервну копію теки сертифікатів разом із файлами конфігурації та іншими потрібними файлами.
Цей підхід передбачає роботу панелі управління Kubernetes у конфігурації HA з кількома API-серверами. Також передбачається коректне завершення роботи API-сервера, щоб клієнти могли чисто відʼєднатися від одного API-сервера й підʼєднатися до іншого.
Конфігурації з одним API-сервером будуть недоступні під час перезапуску API-сервера.
Розподіліть нові сертифікати CA й приватні ключі (наприклад, ca.crt, ca.key, front-proxy-ca.crt і front-proxy-ca.key) на всі вузли панелі управління в теку сертифікатів Kubernetes.
Оновіть прапорець --root-ca-file для kube-controller-manager, щоб він містив і старий, і новий CA, а потім перезапустіть kube-controller-manager.
Будь-який ServiceAccount, створений після цього, отримає Secrets, що містять і старий, і новий CA.
Примітка:
Файли, вказані у прапорцях kube-controller-manager --client-ca-file і --cluster-signing-cert-file, не можуть бути наборами CA. Якщо ці прапорці та --root-ca-file вказують на той самий файл ca.crt, який тепер є набором (містить і старий, і новий CA), ви отримаєте помилку. Щоб обійти цю проблему, скопіюйте новий CA в окремий файл і вкажіть цю копію в прапорцях --client-ca-file і --cluster-signing-cert-file. Коли ca.crt більше не буде набором, ви зможете знову вказати ca.crt у цих прапорцях і видалити копію.
Issue 1350 для kubeadm відстежує помилку, через яку kube-controller-manager не може прийняти набір CA.
Зачекайте, поки менеджер контролерів оновить ca.crt у Secrets для ServiceAccount, щоб вони містили і старі, і нові сертифікати CA.
Якщо якісь Podʼи запускаються до того, як API-сервери почнуть використовувати новий CA, нові Podʼи отримають це оновлення й довірятимуть і старим, і новим CA.
Перезапустіть усі Podʼи, що використовують конфігурації всередині кластера (наприклад, kube-proxy, CoreDNS тощо), щоб вони могли використовувати оновлені дані центру сертифікації із Secrets, повʼязаних із ServiceAccounts.
Переконайтеся, що CoreDNS, kube-proxy та інші Podʼи, які використовують конфігурації всередині кластера, працюють належним чином.
Додайте і старий, і новий CA до файлу, вказаного у прапорцях --client-ca-file і --kubelet-certificate-authority, у конфігурації kube-apiserver.
Додайте і старий, і новий CA до файлу, вказаного у прапорці --client-ca-file, у конфігурації kube-scheduler.
Оновіть сертифікати облікових записів користувачів, замінивши вміст client-certificate-data і client-key-data відповідно.
Крім того, оновіть розділ certificate-authority-data у файлах kubeconfig, вказавши відповідно закодовані в Base64 дані старого й нового центру сертифікації.
Оновіть прапорець --root-ca-file для Cloud Controller Manager, щоб він містив і старий, і новий CA, а потім перезапустіть cloud-controller-manager.
Примітка:
Якщо у вашому кластері немає cloud-controller-manager, цей крок можна пропустити.
Виконайте наведені нижче кроки поетапно.
Перезапустіть усі інші агреговані API-сервери або обробники вебхуків, щоб вони довіряли новим сертифікатам CA.
Перезапустіть kubelet, оновивши файл, вказаний у clientCAFile у конфігурації kubelet, і certificate-authority-data у kubelet.conf, щоб використовувати і старий, і новий CA на всіх вузлах.
Якщо ваш kubelet не використовує ротацію клієнтських сертифікатів, оновіть client-certificate-data і client-key-data у kubelet.conf на всіх вузлах, а також файл клієнтського сертифіката kubelet, який зазвичай міститься в /var/lib/kubelet/pki.
Перезапустіть API-сервери із сертифікатами (apiserver.crt, apiserver-kubelet-client.crt і front-proxy-client.crt), підписаними новим CA. Ви можете використовувати наявні або нові приватні ключі. Якщо ви змінили приватні ключі, оновіть їх і в теці сертифікатів Kubernetes.
Оскільки Podʼи у вашому кластері довіряють і старим, і новим CA, буде короткочасне відʼєднання, після якого клієнти Kubernetes у Podʼах перепідʼєднаються до нового API-сервера. Новий API-сервер використовує сертифікат, підписаний новим CA.
Перезапустіть kube-scheduler, щоб він використовував нові CA й довіряв їм.
Переконайтеся, що логи компонентів панелі управління не містять помилок TLS.
Примітка:
Щоб згенерувати сертифікати й приватні ключі для вашого кластера за допомогою інструмента командного рядка `openssl`, дивіться [Сертифікати (`openssl`)](/docs/tasks/administer-cluster/certificates/#openssl). Також можна використовувати [`cfssl`](/docs/tasks/administer-cluster/certificates/#cfssl).
Додайте анотації до DaemonSets і Deployments, щоб запустити заміну Podʼів безпечнішим поетапним способом.
for namespace in $(kubectl get namespace -o jsonpath='{.items[*].metadata.name}');dofor name in $(kubectl get deployments -n $namespace -o jsonpath='{.items[*].metadata.name}');do kubectl patch deployment -n ${namespace}${name} -p '{"spec":{"template":{"metadata":{"annotations":{"ca-rotation": "1"}}}}}';donefor name in $(kubectl get daemonset -n $namespace -o jsonpath='{.items[*].metadata.name}');do kubectl patch daemonset -n ${namespace}${name} -p '{"spec":{"template":{"metadata":{"annotations":{"ca-rotation": "1"}}}}}';donedone
Примітка:
Щоб обмежити кількість одночасних порушень, яких зазнає ваш застосунок, дивіться [налаштування бюджету порушень Podʼів](/docs/tasks/run-application/configure-pdb/).
Залежно від того, як ви використовуєте StatefulSets, вам також може знадобитися виконати подібну поетапну заміну.
Якщо ваш кластер використовує токени початкового завантаження для приєднання вузлів, оновіть ConfigMap cluster-info у просторі імен kube-public, додавши новий CA.
Перевірте логи компонентів панелі управління, а також kubelet і kube-proxy. Переконайтеся, що ці компоненти не повідомляють про помилки TLS; докладніше дивіться в розділі перегляд логів.
Перевірте логи агрегованих API-серверів і Podʼів, що використовують конфігурацію всередині кластера.
Після успішної перевірки роботи кластера:
Оновіть усі токени ServiceAccount, щоб вони містили лише новий сертифікат CA.
Усі Podʼи, що використовують kubeconfig всередині кластера, зрештою потрібно буде перезапустити, щоб вони отримали новий Secret і жоден Pod не залежав від старого CA кластера.
Перезапустіть компоненти панелі управління, вилучивши старий CA з файлів kubeconfig і файлів, вказаних у прапорцях --client-ca-file і --root-ca-file відповідно.
На кожному вузлі перезапустіть kubelet, вилучивши старий CA з файлу, вказаного в прапорці clientCAFile, і з файлу kubeconfig kubelet. Виконуйте це як поетапне оновлення.
Якщо ваш кластер дозволяє внести цю зміну, ви також можете розгорнути її заміною вузлів, а не їх переналаштуванням.
13 - Керування демонами кластера
Виконуйте поширені завдання керування DaemonSet, наприклад поетапне оновлення.
13.1 - Створення базового DaemonSet
На цій сторінці показано, як створити базовий DaemonSet, який запускає Pod на кожному вузлі кластера Kubernetes. Вона охоплює простий сценарій монтування файлу з хоста, логування його вмісту за допомогою init-контейнера і використання контейнера pause.
Перш ніж ви розпочнете
Вам треба мати кластер Kubernetes, а також інструмент командного рядка kubectl має бути налаштований для роботи з вашим кластером. Рекомендується виконувати ці настанови у кластері, що має щонайменше два вузли, які не виконують роль вузлів управління. Якщо у вас немає кластера, ви можете створити його, за допомогою minikube або використовувати одну з цих пісочниць:
Кластер Kubernetes щонайменше з двома вузлами (один вузол панелі управління та один робочий вузол), щоб продемонструвати поведінку DaemonSets.
Визначення DaemonSet
У цьому завданні створюється базовий DaemonSet, який гарантує, що копія Podʼа планується на кожен вузол. Pod використовуватиме init-контейнер для читання й логування вмісту /etc/machine-id з хоста, а основним контейнером буде контейнер pause, який підтримує роботу Podʼа.
Цей простий приклад DaemonSet знайомить із ключовими компонентами, такими як init-контейнери й томи hostPath, які можна розширювати для складніших сценаріїв. Докладніше дивіться DaemonSet.
На цій сторінці показано, як виконати поетапне оновлення DaemonSet.
Перш ніж ви розпочнете
Вам треба мати кластер Kubernetes, а також інструмент командного рядка kubectl має бути налаштований для роботи з вашим кластером. Рекомендується виконувати ці настанови у кластері, що має щонайменше два вузли, які не виконують роль вузлів управління. Якщо у вас немає кластера, ви можете створити його, за допомогою minikube або використовувати одну з цих пісочниць:
OnDelete: Зі стратегією оновлення OnDelete після оновлення шаблону DaemonSet нові Podʼи DaemonSet створюватимуться лише тоді, коли ви вручну видалите старі Podʼи DaemonSet. Така сама поведінка була в DaemonSet у Kubernetes версії 1.5 або раніше.
RollingUpdate: Це стандартна стратегія оновлення. Зі стратегією оновлення RollingUpdate після оновлення шаблону DaemonSet старі Podʼи DaemonSet буде завершено, а нові Podʼи DaemonSet буде автоматично створено контрольованим чином. Протягом усього процесу оновлення на кожному вузлі працюватиме щонайбільше один Pod DaemonSet.
Виконання поетапного оновлення
Щоб увімкнути поетапне оновлення DaemonSet, потрібно встановити .spec.updateStrategy.type у RollingUpdate.
apiVersion:apps/v1kind:DaemonSetmetadata:name:fluentd-elasticsearchnamespace:kube-systemlabels:k8s-app:fluentd-loggingspec:selector:matchLabels:name:fluentd-elasticsearchupdateStrategy:type:RollingUpdaterollingUpdate:maxUnavailable:1template:metadata:labels:name:fluentd-elasticsearchspec:tolerations:# ці tolerations дозволяють запускати DaemonSet на вузлах панелі управління# видаліть їх, якщо ваші вузли панелі управління не повинні запускати Podʼи- key:node-role.kubernetes.io/control-planeoperator:Existseffect:NoSchedule- key:node-role.kubernetes.io/masteroperator:Existseffect:NoSchedulecontainers:- name:fluentd-elasticsearchimage:quay.io/fluentd_elasticsearch/fluentd:v5.0.1volumeMounts:- name:varlogmountPath:/var/log- name:varlibdockercontainersmountPath:/var/lib/docker/containersreadOnly:trueterminationGracePeriodSeconds:30volumes:- name:varloghostPath:path:/var/log- name:varlibdockercontainershostPath:path:/var/lib/docker/containers
Перевіривши стратегію оновлення в маніфесті DaemonSet, створіть DaemonSet:
Якщо вивід не RollingUpdate, поверніться й відповідно змініть обʼєкт DaemonSet або маніфест.
Оновлення шаблону DaemonSet
Будь-які оновлення .spec.template у DaemonSet зі стратегією RollingUpdate запускають поетапне оновлення. Оновімо DaemonSet, застосувавши новий файл YAML. Це можна зробити кількома різними командами kubectl.
apiVersion:apps/v1kind:DaemonSetmetadata:name:fluentd-elasticsearchnamespace:kube-systemlabels:k8s-app:fluentd-loggingspec:selector:matchLabels:name:fluentd-elasticsearchupdateStrategy:type:RollingUpdaterollingUpdate:maxUnavailable:1template:metadata:labels:name:fluentd-elasticsearchspec:tolerations:# ці tolerations дозволяють запускати DaemonSet на вузлах панелі управління# видаліть їх, якщо ваші вузли панелі управління не повинні запускати Podʼи- key:node-role.kubernetes.io/control-planeoperator:Existseffect:NoSchedule- key:node-role.kubernetes.io/masteroperator:Existseffect:NoSchedulecontainers:- name:fluentd-elasticsearchimage:quay.io/fluentd_elasticsearch/fluentd:v5.0.1resources:limits:memory:200Mirequests:cpu:100mmemory:200MivolumeMounts:- name:varlogmountPath:/var/log- name:varlibdockercontainersmountPath:/var/lib/docker/containersreadOnly:trueterminationGracePeriodSeconds:30volumes:- name:varloghostPath:path:/var/log- name:varlibdockercontainershostPath:path:/var/lib/docker/containers
Декларативні команди
Якщо ви оновлюєте DaemonSets за допомогою файлів конфігурації, використовуйте kubectl apply:
Якщо вам потрібно оновити лише образ контейнера у шаблоні DaemonSet, тобто
.spec.template.spec.containers[*].image, використовуйте kubectl set image:
kubectl set image ds/fluentd-elasticsearch fluentd-elasticsearch=quay.io/fluentd_elasticsearch/fluentd:v2.6.0 -n kube-system
Спостереження за станом поетапного оновлення
Нарешті, спостерігайте за станом розгортання останнього поетапного оновлення DaemonSet:
kubectl rollout status ds/fluentd-elasticsearch -n kube-system
Коли розгортання завершиться, вивід буде подібний до такого:
daemonset "fluentd-elasticsearch" successfully rolled out
Усунення несправностей
Поетапне оновлення DaemonSet застрягло
Іноді поетапне оновлення DaemonSet може застрягнути. Ось деякі можливі причини:
На деяких вузлах вичерпуються ресурси
Розгортання застрягло, оскільки нові Podʼи DaemonSet не можна запланувати щонайменше на один вузол. Таке можливо, коли на вузлі вичерпуються ресурси.
Коли це трапляється, знайдіть вузли, на яких не заплановано Podʼи DaemonSet, порівнявши вивід kubectl get nodes з виводом:
kubectl get pods -l name=fluentd-elasticsearch -o wide -n kube-system
Знайшовши ці вузли, видаліть із них деякі Podʼи, що не належать до DaemonSet, щоб звільнити місце для нових Podʼів DaemonSet.
Примітка:
Це спричинить порушення роботи сервісу, якщо видалені Podʼи не контролюються жодним контролером або не мають реплік. Це також не враховує PodDisruptionBudget.
Невдале розгортання
Якщо останнє оновлення шаблону DaemonSet невдале, наприклад контейнер постійно аварійно завершується (crash looping) або образу контейнера не існує (часто через одруківку), розгортання DaemonSet не просуватиметься.
Щоб виправити це, ще раз оновіть шаблон DaemonSet. Нове розгортання не блокуватиметься попередніми несправними розгортаннями.
Невідповідність годинників
Якщо в DaemonSet задано .spec.minReadySeconds, невідповідність годинників між панеллю управління та вузлами не дасть DaemonSet правильно визначати перебіг розгортання.
На цій сторінці показано, як виконати відкочування DaemonSet.
Перш ніж ви розпочнете
Вам треба мати кластер Kubernetes, а також інструмент командного рядка kubectl має бути налаштований для роботи з вашим кластером. Рекомендується виконувати ці настанови у кластері, що має щонайменше два вузли, які не виконують роль вузлів управління. Якщо у вас немає кластера, ви можете створити його, за допомогою minikube або використовувати одну з цих пісочниць:
Причина зміни копіюється з анотації DaemonSet kubernetes.io/change-cause до його ревізій під час їх створення. Ви можете вказати --record=true у kubectl, щоб записати виконану команду в анотацію причини зміни.
Щоб переглянути подробиці конкретної ревізії:
kubectl rollout history daemonset <daemonset-name> --revision=1
# Вкажіть номер ревізії, отриманий на кроці 1, у --to-revisionkubectl rollout undo daemonset <daemonset-name> --to-revision=<revision>
Якщо команда виконається успішно, вона поверне:
daemonset "<daemonset-name>" rolled back
Примітка:
Якщо прапорець --to-revision не вказано, kubectl обирає найновішу ревізію.
Крок 3: Спостерігайте за перебігом відкочування DaemonSet
kubectl rollout undo daemonset наказує серверу почати відкочування DaemonSet. Фактичне відкочування виконується асинхронно всередині панелі управління кластера.
Щоб спостерігати за перебігом відкочування:
kubectl rollout status ds/<daemonset-name>
Коли відкочування завершиться, вивід буде подібний до такого:
daemonset "<daemonset-name>" successfully rolled out
Розуміння ревізій DaemonSet
На попередньому кроці kubectl rollout history ви отримали список ревізій DaemonSet. Кожна ревізія зберігається в ресурсі під назвою ControllerRevision.
Щоб побачити, що зберігається в кожній ревізії, знайдіть необроблені ресурси ревізій DaemonSet:
kubectl get controllerrevision -l <daemonset-selector-key>=<daemonset-selector-value>
Це поверне список ControllerRevisions:
NAME CONTROLLER REVISION AGE
<daemonset-name>-<revision-hash> DaemonSet/<daemonset-name> 1 1h
<daemonset-name>-<revision-hash> DaemonSet/<daemonset-name> 2 1h
Кожен ControllerRevision зберігає анотації та шаблон ревізії DaemonSet.
kubectl rollout undo бере конкретний ControllerRevision і замінює шаблон DaemonSet шаблоном, збереженим у ControllerRevision. kubectl rollout undo рівнозначний оновленню шаблону DaemonSet до попередньої ревізії іншими командами, такими як kubectl edit або kubectl apply.
Примітка:
Ревізії DaemonSet рухаються лише вперед. Тобто після завершення відкочування номер ревізії (поле .revision) ControllerRevision, до якого відбулося відкочування, збільшується. Наприклад, якщо в системі є ревізії 1 і 2 і ви відкочуєтеся з ревізії 2 до ревізії 1, ControllerRevision із .revision: 1 стане .revision: 3.
На цій сторінці показано, як запускати Podʼи лише на деяких вузлах у складі DaemonSet
Перш ніж ви розпочнете
Вам треба мати кластер Kubernetes, а також інструмент командного рядка kubectl має бути налаштований для роботи з вашим кластером. Рекомендується виконувати ці настанови у кластері, що має щонайменше два вузли, які не виконують роль вузлів управління. Якщо у вас немає кластера, ви можете створити його, за допомогою minikube або використовувати одну з цих пісочниць:
Уявімо, що ви хочете запустити DaemonSet, але ці Podʼи демонів потрібно запускати лише на вузлах із локальним твердотільним сховищем (SSD). Наприклад, Pod може надавати вузлу сервіс кешування, а кеш корисний лише тоді, коли доступне локальне сховище з низькою затримкою.
Створіть DaemonSet з маніфесту, використовуючи kubectl create або kubectl apply.
Додамо мітку ssd=true ще одному вузлу.
kubectl label nodes example-node-3 ssd=true
Додавання мітки вузлу автоматично спонукає панель управління (а саме контролер DaemonSet) запустити новий Pod демона на цьому вузлі.
kubectl get pods -o wide
Вивід подібний до такого:
NAME READY STATUS RESTARTS AGE IP NODE
<daemonset-name><some-hash-01> 1/1 Running 0 13s ..... example-node-1
<daemonset-name><some-hash-02> 1/1 Running 0 13s ..... example-node-2
<daemonset-name><some-hash-03> 1/1 Running 0 5s ..... example-node-3
14 - Мережа
Дізнайтеся, як налаштувати мережу для вашого кластера.
14.1 - Розширення діапазонів IP-адрес Service
СТАН ФУНКЦІОНАЛУ:GA since Kubernetes v1.33
More information about this feature
This is a stable feature in Kubernetes, and has been since version v1.33. It was first available in the v1.27 release. You can no longer disable or opt out of this feature or behavior (it is locked); if you explicitly set a value for the associated feature gate MultiCIDRServiceAllocator, Kubernetes ignores it but does not report any error.
У цьому документі описано, як розширити наявний діапазон IP-адрес Service, призначений кластеру.
Перш ніж ви розпочнете
Вам треба мати кластер Kubernetes, а також інструмент командного рядка kubectl має бути налаштований для роботи з вашим кластером. Рекомендується виконувати ці настанови у кластері, що має щонайменше два вузли, які не виконують роль вузлів управління. Якщо у вас немає кластера, ви можете створити його, за допомогою minikube або використовувати одну з цих пісочниць:
Версія вашого Kubernetes сервера має бути не старішою ніж v1.29.
Для перевірки версії введіть kubectl version.
Примітка:
Хоча цю можливість можна використовувати в раніших версіях, вона є GA й офіційно підтримується лише з v1.33.
Розширення діапазонів IP-адрес Service
Панель управління забезпечує наявність спеціального обʼєкта ServiceCIDR із загальновідомою назвою kubernetes, який визначає діапазон IP-адрес на основі значення аргументу командного рядка --service-cluster-ip-range для kube-apiserver.
kubectl get servicecidr
NAME CIDRS AGE
kubernetes 10.96.0.0/28 17d
Загальновідомий Service kubernetes, який відкриває Podʼам доступ до точки доступу kube-apiserver, обчислює першу IP-адресу зі стандартного діапазону ServiceCIDR і використовує її як свою кластерну IP-адресу.
kubectl get service kubernetes
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
kubernetes ClusterIP 10.96.0.1 <none> 443/TCP 17d
Стандартний Service у цьому випадку використовує ClusterIP 10.96.0.1, що має відповідний обʼєкт IPAddress.
kubectl get ipaddress 10.96.0.1
NAME PARENTREF
10.96.0.1 services/default/kubernetes
ServiceCIDRs захищені завершувачами, щоб ClusterIP у Service не лишалися без батьківського обʼєкта; завершувач вилучається лише тоді, коли існує інша підмережа з наявними IPAddresses або немає IPAddresses, що належать до цієї підмережі.
Розширення кількості доступних IP-адрес для Services
Іноді користувачам потрібно збільшити кількість адрес, доступних для Services. Раніше збільшення діапазону Service було операцією з порушенням роботи, яка також могла спричинити втрату даних. Завдяки цій новій можливості користувачам достатньо додати новий ServiceCIDR, щоб збільшити кількість доступних адрес.
Додавання нового ServiceCIDR
У кластері з діапазоном 10.96.0.0/28 для Services доступно лише 2^(32-28) - 2 = 14 IP-адрес. Service kubernetes.default створюється завжди; у цьому прикладі лишається лише 13 можливих Services.
for i in $(seq 1 13);do kubectl create service clusterip "test-$i" --tcp 80 -o json | jq -r .spec.clusterIP;done
10.96.0.11
10.96.0.5
10.96.0.12
10.96.0.13
10.96.0.14
10.96.0.2
10.96.0.3
10.96.0.4
10.96.0.6
10.96.0.7
10.96.0.8
10.96.0.9
error: failed to create ClusterIP service: Internal error occurred: failed to allocate a serviceIP: range is full
Ви можете збільшити кількість IP-адрес, доступних для Services, створивши новий ServiceCIDR, який розширює наявні або додає нові діапазони IP-адрес.
і це дозволить створювати нові Services з ClusterIP, вибраними з цього нового діапазону.
for i in $(seq 13 16);do kubectl create service clusterip "test-$i" --tcp 80 -o json | jq -r .spec.clusterIP;done
10.96.0.48
10.96.0.200
10.96.0.121
10.96.0.144
Видалення ServiceCIDR
Ви не можете видалити ServiceCIDR, якщо є IPAddresses, які залежать від цього ServiceCIDR.
kubectl delete servicecidr newcidr1
servicecidr.networking.k8s.io "newcidr1" deleted
Kubernetes використовує завершувач на ServiceCIDR, щоб відстежувати цю залежність.
kubectl get servicecidr newcidr1 -o yaml
apiVersion:networking.k8s.io/v1kind:ServiceCIDRmetadata:creationTimestamp:"2023-10-12T15:11:07Z"deletionGracePeriodSeconds:0deletionTimestamp:"2023-10-12T15:12:45Z"finalizers:- networking.k8s.io/service-cidr-finalizername:newcidr1resourceVersion:"1133"uid:5ffd8afe-c78f-4e60-ae76-cec448a8af40spec:cidrs:- 10.96.0.0/24status:conditions:- lastTransitionTime:"2023-10-12T15:12:45Z"message:There are still IPAddresses referencing the ServiceCIDR, please removethem or create a new ServiceCIDRreason:OrphanIPAddressstatus:"False"type:Ready
Видаляючи Services з IP-адресами, які блокують видалення ServiceCIDR,
for i in $(seq 13 16);do kubectl delete service "test-$i";done
service "test-13" deleted
service "test-14" deleted
service "test-15" deleted
service "test-16" deleted
панель управління помічає це видалення. Потім панель управління вилучає свій завершувач, і ServiceCIDR, що очікував на видалення, справді буде видалено.
kubectl get servicecidr newcidr1
Error from server (NotFound): servicecidrs.networking.k8s.io "newcidr1" not found
Політики Service CIDR у Kubernetes
Адміністратори кластера можуть застосовувати політики для контролю створення й зміни ресурсів ServiceCIDR у кластері. Це дає змогу централізовано керувати діапазонами IP-адрес, які використовуються для Services, і запобігає ненавмисним або конфліктним конфігураціям. Kubernetes надає для застосування цих правил такі механізми, як валідаційні політики допуску (Validating Admission Policies).
Запобігання несанкціонованому створенню й оновленню ServiceCIDR за допомогою валідаційної політики допуску
Іноді адміністратори кластера хочуть обмежити дозволені діапазони або повністю заборонити будь-які зміни діапазонів IP-адрес Service кластера.
Примітка:
Стандартний ServiceCIDR "kubernetes" створюється kube-apiserver для забезпечення узгодженості в кластері й потрібен для роботи кластера, тому його завжди потрібно дозволяти. Щоб ValidatingAdmissionPolicy не обмежувала стандартний ServiceCIDR, додайте таку умову:
Обмеження діапазонів Service CIDR конкретними діапазонами
Нижче наведено приклад ValidatingAdmissionPolicy, яка дозволяє створювати ServiceCIDR, лише якщо вони є піддіапазонами заданих діапазонів allowed. (Отже, ця політика дозволить ServiceCIDR з cidrs: ['10.96.1.0/24'] або cidrs: ['2001:db8:0:0:ffff::/80', '10.96.0.0/20'], але не дозволить ServiceCIDR з cidrs: ['172.20.0.0/16'].) Ви можете скопіювати цю політику й змінити значення allowed на відповідне для вашого кластера.
apiVersion:admissionregistration.k8s.io/v1kind:ValidatingAdmissionPolicymetadata:name:"servicecidrs.default"spec:failurePolicy:FailmatchConstraints:resourceRules:- apiGroups:["networking.k8s.io"]apiVersions:["v1"]operations:["CREATE","UPDATE"]resources:["servicecidrs"]matchConditions:- name:'exclude-default-servicecidr'expression:"object.metadata.name != 'kubernetes'"variables:- name:allowedexpression:"['10.96.0.0/16','2001:db8::/64']"validations:- expression:"object.spec.cidrs.all(newCIDR, variables.allowed.exists(allowedCIDR, cidr(allowedCIDR).containsCIDR(newCIDR)))"# For all CIDRs (newCIDR) listed in the spec.cidrs of the submitted ServiceCIDR# object, check if there exists at least one CIDR (allowedCIDR) in the `allowed`# list of the VAP such that the allowedCIDR fully contains the newCIDR.---apiVersion:admissionregistration.k8s.io/v1kind:ValidatingAdmissionPolicyBindingmetadata:name:"servicecidrs-default-binding"spec:policyName:"servicecidrs.default"validationActions:[Deny,Audit]
Щоб дізнатися більше про CEL і написати власний expression для валідації, дивіться документацію CEL.
Обмеження будь-якого використання API ServiceCIDR
Наведений нижче приклад показує, як використовувати ValidatingAdmissionPolicy та її привʼязку, щоб обмежити створення будь-яких нових діапазонів Service CIDR, окрім стандартного ServiceCIDR "kubernetes":
apiVersion:admissionregistration.k8s.io/v1kind:ValidatingAdmissionPolicymetadata:name:"servicecidrs.deny"spec:failurePolicy:FailmatchConstraints:resourceRules:- apiGroups:["networking.k8s.io"]apiVersions:["v1"]operations:["CREATE","UPDATE"]resources:["servicecidrs"]validations:# Deny changes to all ServiceCIDRs except the default one- expression:"object.metadata.name == 'kubernetes'"message:"you can only create or update the default ServiceCIDR"# Deny changes from all users except kube-apiserver- expression:"request.userInfo.username == 'system:apiserver' && 'system:masters' in request.userInfo.groups"message:"you can not create or update ServiceCIDR objects"---apiVersion:admissionregistration.k8s.io/v1kind:ValidatingAdmissionPolicyBindingmetadata:name:"servicecidrs-deny-binding"spec:policyName:"servicecidrs.deny"validationActions:[Deny,Audit]
14.2 - Перевірка подвійного стека IPv4/IPv6
У цьому документі описано, як перевірити кластери Kubernetes з увімкненим подвійним стеком IPv4/IPv6.
Перш ніж ви розпочнете
Підтримка мереж із подвійним стеком з боку постачальника (хмарний провайдер або інший постачальник має забезпечити вузли Kubernetes маршрутизованими мережевими інтерфейсами IPv4/IPv6)
Версія вашого Kubernetes сервера має бути не старішою ніж v1.23.
Для перевірки версії введіть kubectl version.
Примітка:
Хоча перевірку можна виконати й на раніших версіях, ця можливість є GA й офіційно підтримується лише з v1.23.
Перевірка адресації
Перевірка адресації вузлів
Кожен вузол із подвійним стеком повинен мати виділений один блок IPv4 і один блок IPv6. Перевірте, що діапазони адрес Podʼів IPv4/IPv6 налаштовано, виконавши наведену нижче команду. Замініть назву вузла з прикладу на назву дійсного вузла з подвійним стеком у вашому кластері. У цьому прикладі назва вузла — k8s-linuxpool1-34450317-0:
kubectl get nodes k8s-linuxpool1-34450317-0 -o go-template --template='{{range .spec.podCIDRs}}{{printf "%s\n" .}}{{end}}'
10.244.1.0/24
2001:db8::/64
Має бути виділено один блок IPv4 та один блок IPv6.
Перевірте, що на вузлі виявлено інтерфейси IPv4 та IPv6. Замініть назву вузла на назву дійсного вузла з кластера. У цьому прикладі назва вузла — k8s-linuxpool1-34450317-0:
Перевірте, що Podʼу призначено адреси IPv4 та IPv6. Замініть назву Podʼа на назву дійсного Podʼа у вашому кластері. У цьому прикладі назва Podʼа — pod01:
kubectl get pods pod01 -o go-template --template='{{range .status.podIPs}}{{printf "%s\n" .ip}}{{end}}'
10.244.1.4
2001:db8::4
Ви також можете перевірити IP-адреси Podʼа за допомогою Downward API через fieldPath status.podIPs. Наведений нижче фрагмент показує, як надати IP-адреси Podʼа контейнеру через змінну середовища MY_POD_IPS.
Наведена нижче команда виводить значення змінної середовища MY_POD_IPS усередині контейнера. Значення — це список, розділений комами, який відповідає адресам IPv4 та IPv6 Podʼа.
kubectl exec -it pod01 -- set| grep MY_POD_IPS
MY_POD_IPS=10.244.1.4,2001:db8::4
IP-адреси Podʼа також записуються в /etc/hosts усередині контейнера. Наведена нижче команда виконує cat для /etc/hosts у Podʼі з подвійним стеком. З виводу можна перевірити адреси IPv4 та IPv6 Podʼа.
Створіть наведений нижче Service, який явно не визначає .spec.ipFamilyPolicy. Kubernetes призначить Service кластерний IP з першого налаштованого service-cluster-ip-range і встановить .spec.ipFamilyPolicy у SingleStack.
Використайте kubectl, щоб переглянути YAML цього Service.
kubectl get svc my-service -o yaml
Service має .spec.ipFamilyPolicy зі значенням SingleStack і .spec.clusterIP з адресою IPv4 із першого налаштованого діапазону, заданого прапорцем --service-cluster-ip-range у kube-controller-manager.
Створіть наведений нижче Service, який явно визначає IPv6 як перший елемент масиву .spec.ipFamilies. Kubernetes призначить Service кластерний IP із діапазону IPv6, налаштованого в service-cluster-ip-range, і встановить .spec.ipFamilyPolicy у SingleStack.
Використайте kubectl, щоб переглянути YAML цього Service.
kubectl get svc my-service -o yaml
Service має .spec.ipFamilyPolicy зі значенням SingleStack і .spec.clusterIP з адресою IPv6 із діапазону IPv6, заданого прапорцем --service-cluster-ip-range у kube-controller-manager.
Створіть наведений нижче Service, який явно визначає PreferDualStack у .spec.ipFamilyPolicy. Kubernetes призначить адреси IPv4 та IPv6 (оскільки в цьому кластері ввімкнено подвійний стек) і вибере .spec.ClusterIP зі списку .spec.ClusterIPs на основі сімейства адрес першого елемента масиву .spec.ipFamilies.
Команда kubectl get svc показує лише основну IP-адресу в полі CLUSTER-IP.
kubectl get svc -l app.kubernetes.io/name=MyApp
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
my-service ClusterIP 10.0.216.242 <none> 80/TCP 5s
Перевірте за допомогою kubectl describe, що Service отримує кластерні IP з блоків адрес IPv4 та IPv6. Потім можна перевірити доступ до сервісу через IP-адреси й порти.
Створення Service з подвійним стеком і балансуванням навантаження
Якщо хмарний провайдер підтримує надання зовнішніх балансувальників навантаження з підтримкою IPv6, створіть наведений нижче Service із PreferDualStack у .spec.ipFamilyPolicy, IPv6 як першим елементом масиву .spec.ipFamilies і полем type зі значенням LoadBalancer.
Перевірте, що Service отримує адресу CLUSTER-IP із блоку адрес IPv6 разом з EXTERNAL-IP. Потім можна перевірити доступ до сервісу через IP-адресу й порт.
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
my-service LoadBalancer 2001:db8:fd00::7ebc 2603:1030:805::5 80:30790/TCP 35s
14.3 - Додавання записів до файлу /etc/hosts у Podʼі за допомогою HostAliases
Додавання записів до файлу /etc/hosts у Podʼі дає змогу перевизначити розвʼязання імен хостів на рівні Podʼа, коли DNS та інші варіанти не підходять. Ви можете додавати ці власні записи за допомогою поля HostAliases у PodSpec.
Проєкт Kubernetes рекомендує змінювати конфігурацію DNS за допомогою поля hostAliases (частина .spec Podʼа), а не за допомогою init-контейнера чи інших засобів безпосереднього редагування /etc/hosts. Зміни, внесені іншим способом, kubelet може перезаписати під час створення або перезапуску Podʼа.
Стандартний вміст файлу hosts
Запустіть Pod із Nginx, якому призначено IP-адресу Podʼа:
kubectl run nginx --image nginx
pod/nginx created
Перевірте IP-адресу Podʼа:
kubectl get pods --output=wide
NAME READY STATUS RESTARTS AGE IP NODE
nginx 1/1 Running 0 13s 10.200.0.4 worker0
Стандартно файл hosts містить лише шаблонні записи IPv4 та IPv6, такі як localhost і власне імʼя хоста.
Додавання додаткових записів за допомогою hostAliases
Крім стандартних шаблонних записів, ви можете додати до файлу hosts інші записи. Наприклад, щоб розвʼязувати foo.local, bar.local у 127.0.0.1, а foo.remote, bar.remote у 10.1.2.3, налаштуйте HostAliases для Podʼа в полі .spec.hostAliases:
kubelet керує файлом hosts для кожного контейнера Podʼа, щоб середовище виконання контейнерів не змінювало цей файл після запуску контейнерів. Історично Kubernetes завжди використовував Docker Engine як середовище виконання контейнерів, а Docker Engine змінював файл /etc/hosts після запуску кожного контейнера.
Поточний Kubernetes може використовувати різні середовища виконання контейнерів; попри це, kubelet керує файлом hosts у кожному контейнері, щоб результат був очікуваним незалежно від середовища виконання контейнерів, яке ви використовуєте.
Увага:
Уникайте ручних змін файлу hosts усередині контейнера.
Якщо ви вносите ручні зміни до файлу hosts, ці зміни втрачаються, коли контейнер завершує роботу.
This is a stable feature in Kubernetes, and has been since version v1.33. It was first available in the v1.27 release. You can no longer disable or opt out of this feature or behavior (it is locked); if you explicitly set a value for the associated feature gate MultiCIDRServiceAllocator, Kubernetes ignores it but does not report any error.
У цьому документі описано, як переналаштувати стандартні діапазони IP-адрес Service, призначені кластеру.
Перш ніж ви розпочнете
Вам треба мати кластер Kubernetes, а також інструмент командного рядка kubectl має бути налаштований для роботи з вашим кластером. Рекомендується виконувати ці настанови у кластері, що має щонайменше два вузли, які не виконують роль вузлів управління. Якщо у вас немає кластера, ви можете створити його, за допомогою minikube або використовувати одну з цих пісочниць:
У цьому документі пояснено, як керувати діапазоном IP-адрес Service у кластері Kubernetes, що також впливає на сімейства IP, які кластер підтримує для Services.
Сімейства IP, доступні для ClusterIP у Service, визначаються прапорцем --service-cluster-ip-range у kube-apiserver. Щоб краще зрозуміти виділення IP-адрес Service, дивіться документацію Відстеження виділення IP-адрес Services.
Починаючи з Kubernetes 1.33, сімейства IP Service, налаштовані для кластера, відображаються в обʼєкті ServiceCIDR з назвою kubernetes. Обʼєкт ServiceCIDR kubernetes створює перший запущений екземпляр kube-apiserver на основі свого налаштованого прапорця --service-cluster-ip-range. Щоб забезпечити узгоджену поведінку кластера, усі екземпляри kube-apiserver мають бути налаштовані з однаковими значеннями --service-cluster-ip-range, які мають відповідати стандартному обʼєкту ServiceCIDR kubernetes.
Категорії переналаштування ServiceCIDR Kubernetes
Переналаштування ServiceCIDR зазвичай належить до однієї з таких категорій:
Розширення наявних ServiceCIDR: Це можна зробити динамічно, додавши нові обʼєкти ServiceCIDR без переналаштування kube-apiserver. Дивіться окрему документацію про Розширення діапазонів IP-адрес Service.
Перетворення з одного стека на подвійний стек зі збереженням первинного ServiceCIDR: Це передбачає додавання вторинного сімейства IP (IPv6 до кластера лише з IPv4 або IPv4 до кластера лише з IPv6) зі збереженням початкового сімейства IP як первинного. Для цього потрібно оновити конфігурацію kube-apiserver і відповідно змінити різні компоненти кластера, які мають працювати з цим додатковим сімейством IP. Серед цих компонентів, зокрема, kube-proxy, CNI або мережевий втулок, реалізації service mesh і сервіси DNS.
Перетворення з подвійного стека на один зі збереженням первинного ServiceCIDR: Це передбачає вилучення вторинного сімейства IP з кластера з подвійним стеком і повернення до одного сімейства IP зі збереженням початкового первинного сімейства IP. Окрім переналаштування компонентів відповідно до нового сімейства IP, може знадобитися розібратися з Services, які явно налаштовані на використання вилученого сімейства IP.
Усе, що призводить до зміни первинного ServiceCIDR: Повна заміна стандартного ServiceCIDR — складна операція. Якщо новий ServiceCIDR не перетинається з наявним, потрібно буде перенумерувати всі наявні Services і змінити Service kubernetes.default. Випадок, коли змінюється ще й первинне сімейство IP, ще складніший і може потребувати зміни кількох компонентів кластера (kubelet, мережевих втулків тощо) відповідно до нового первинного сімейства IP.
Ручні операції для заміни стандартного ServiceCIDR
Переналаштування стандартного ServiceCIDR потребує ручних дій з боку оператора кластера, адміністратора або програмного забезпечення, що керує життєвим циклом кластера. Зазвичай це такі дії:
Оновлення конфігурації kube-apiserver: змініть прапорець --service-cluster-ip-range, указавши нові діапазони IP.
Переналаштування мережевих компонентів: це критичний крок, і конкретна процедура залежить від мережевих компонентів, що використовуються. Він може охоплювати оновлення файлів конфігурації, перезапуск Podʼів агентів або оновлення компонентів для керування новими ServiceCIDR і бажаною конфігурацією сімейства IP для Podʼів. Такими компонентами можуть бути реалізація Services Kubernetes, наприклад kube-proxy, налаштований мережевий втулок і, можливо, інші мережеві компоненти, такі як контролери service mesh і сервери DNS, щоб вони могли правильно обробляти трафік і виконувати виявлення сервісів із новою конфігурацією сімейства IP.
Керування наявними Services: Services з IP-адресами зі старого CIDR потрібно обробити, якщо вони не входять до нових налаштованих діапазонів. Варіанти: повторне створення (що призводить до простою і призначення нових IP-адрес) або потенційно складніші стратегії переналаштування.
Повторне створення внутрішніх сервісів Kubernetes: Service kubernetes.default потрібно видалити й створити заново, щоб отримати IP-адресу з нового ServiceCIDR, якщо первинне сімейство IP змінено або замінено іншою мережею.
Приклад кроків переналаштування
Наведені нижче кроки описують контрольоване переналаштування з повною заміною стандартного ServiceCIDR і повторним створенням Service kubernetes.default:
Запустіть kube-apiserver з початковим --service-cluster-ip-range.
Створіть початкові Services, які отримують IP-адреси з цього діапазону.
Створіть новий ServiceCIDR як тимчасову ціль переналаштування.
Позначте стандартний ServiceCIDR kubernetes для видалення (він лишатиметься в очікуванні через наявні IP-адреси й завершувачі). Це запобігає новим виділенням зі старого діапазону.
Повторно створіть наявні Services. Тепер вони мають отримати IP-адреси з нового тимчасового ServiceCIDR.
Перезапустіть kube-apiserver із налаштованими новими ServiceCIDR і вимкніть старий екземпляр.
Видаліть Service kubernetes.default. Новий kube-apiserver створить його заново в новому ServiceCIDR.
Розширюйте kubectl, створюючи та встановлюючи втулки kubectl.
Цей посібник показує, як встановлювати й створювати розширення для kubectl. Розглядаючи основні команди kubectl як базові будівельні блоки для взаємодії з кластером Kubernetes, адміністратор кластера може вважати втулки засобом використання цих блоків для створення складнішої поведінки. Втулки розширюють kubectl новими підкомандами, додаючи нові й власні можливості, яких немає в основному дистрибутиві kubectl.
Перш ніж ви розпочнете
Вам потрібен встановлений робочий бінарний файл kubectl.
Встановлення втулків для kubectl
Втулок — це окремий виконуваний файл, назва якого починається з kubectl-. Щоб установити втулок, перемістіть його виконуваний файл у будь-яке місце у вашому PATH.
Ви також можете шукати й встановлювати втулки kubectl із відкритим кодом за допомогою Krew. Krew — це менеджер втулків, який підтримує спільнота Kubernetes SIG CLI.
Увага:
Втулки kubectl, доступні через індекс втулків Krew, не проходять перевірки безпеки. Сторонні втулки ви встановлюєте й запускаєте на власний ризик, оскільки це довільні програми, що виконуються на вашому компʼютері.
Пошук втулків
kubectl надає команду kubectl plugin list, яка шукає у вашому PATH дійсні виконувані файли втулків. Виконання цієї команди спричиняє обхід усіх файлів у вашому PATH. Усі файли, які є виконуваними й починаються з kubectl-, зʼявляться у виводі цієї команди у тому порядку, в якому вони розташовані у вашому PATH. Для всіх файлів, що починаються з kubectl- і не є виконуваними, буде показано попередження. Також буде показано попередження для всіх дійсних файлів втулків, назви яких перекривають одна одну.
Ви можете використовувати Krew, щоб шукати й встановлювати втулки kubectl з індексу втулків, який підтримує спільнота.
Створення втулків
kubectl дозволяє втулкам додавати власні команди створення вигляду kubectl create something: для цього в PATH має бути виконуваний файл kubectl-create-something.
Обмеження
Наразі неможливо створити втулки, які перезаписують наявні команди kubectl або розширюють інші команди, крім create. Наприклад, якщо створити втулок kubectl-version, він ніколи не виконуватиметься, оскільки наявна команда kubectl version завжди матиме пріоритет. Через це обмеження також не можна використовувати втулки для додавання нових підкоманд до наявних команд kubectl. Наприклад, якщо додати підкоманду kubectl attach vm, назвавши втулок kubectl-attach-vm, цей втулок буде проігноровано.
kubectl plugin list показує попередження для всіх дійсних втулків, які намагаються це зробити.
Написання втулків для kubectl
Ви можете написати втулок будь-якою мовою програмування або скриптом, що дозволяє створювати команди командного рядка.
Втулки не потребують встановлення чи попереднього завантаження. Виконувані файли втулків успадковують середовище від бінарного файлу kubectl. Втулок визначає шлях команди, який він реалізує, за своєю назвою. Наприклад, втулок із назвою kubectl-foo надає команду kubectl foo. Виконуваний файл втулка потрібно встановити десь у вашому PATH.
Приклад втулка
#!/bin/bash
# необовʼязкова обробка аргументівif[["$1"=="version"]]thenecho"1.0.0"exit0fi# необовʼязкова обробка аргументівif[["$1"=="config"]]thenecho"$KUBECONFIG"exit0fiecho"I am a plugin named kubectl-foo"
Використання втулка
Щоб використовувати втулок, зробіть його виконуваним:
sudo chmod +x ./kubectl-foo
і помістіть його в будь-яке місце у вашому PATH:
sudo mv ./kubectl-foo /usr/local/bin
Тепер ви можете викликати втулок як команду kubectl:
kubectl foo
I am a plugin named kubectl-foo
Усі аргументи та прапорці передаються виконуваному файлу без змін:
kubectl foo version
1.0.0
Усі змінні середовища також передаються виконуваному файлу без змін:
Крім того, першим аргументом, який передається втулку, завжди буде повний шлях до місця, де його викликано ($0 дорівнюватиме /usr/local/bin/kubectl-foo у наведеному вище прикладі).
Іменування втулків
Як видно з наведеного вище прикладу, втулок визначає шлях команди, яку він реалізує, за назвою свого файлу. Усі підкоманди в шляху команди, на яку націлений втулок, розділені дефісом (-). Наприклад, втулок, який має викликатися щоразу, коли користувач виконує команду kubectl foo bar baz, матиме назву файлу kubectl-foo-bar-baz.
Обробка прапорців та аргументів
Примітка:
Механізм втулків не створює жодних власних, специфічних для втулка значень або змінних середовища для процесу втулка.
Старіший механізм втулків kubectl надавав змінні середовища, такі як KUBECTL_PLUGINS_CURRENT_NAMESPACE; тепер такого немає.
Втулки kubectl мають самостійно розбирати та перевіряти всі передані їм аргументи. Докладніше про бібліотеку Go для авторів втулків дивіться в розділі використання пакунка command line runtime.
Нижче наведено кілька додаткових випадків, коли користувачі викликають ваш втулок із додатковими прапорцями та аргументами. Вони ґрунтуються на втулку kubectl-foo-bar-baz із наведеного вище сценарію.
Якщо ви виконаєте kubectl foo bar baz arg1 --flag=value arg2, механізм втулків kubectl спочатку спробує знайти втулок із найдовшою можливою назвою, у цьому випадку kubectl-foo-bar-baz-arg1. Не знайшовши такого втулка, kubectl вважатиме останнє значення, відокремлене дефісом, аргументом (тут arg1) і спробує знайти наступну найдовшу можливу назву, kubectl-foo-bar-baz. Знайшовши втулок із такою назвою, kubectl викличе його, передаючи всі аргументи й прапорці після назви втулка як аргументи процесу втулка.
Приклад:
# створимо втулокecho -e '#!/bin/bash\n\necho "My first command-line argument was $1"' > kubectl-foo-bar-baz
sudo chmod +x ./kubectl-foo-bar-baz
# встановимо ваш втулок, перемістивши його у теку з $PATHsudo mv ./kubectl-foo-bar-baz /usr/local/bin
# перевіримо, що kubectl розпізнав ваш втулокkubectl plugin list
The following kubectl-compatible plugins are available:
/usr/local/bin/kubectl-foo-bar-baz
# перевірте, що виклик вашого втулка через команду "kubectl" працює
# навіть тоді, коли користувач передає додаткові аргументи та прапорці
# до виконуваного файлу вашого втулка.
kubectl foo bar baz arg1 --meaningless-flag=true
My first command-line argument was arg1
Як бачите, ваш втулок було знайдено за командою kubectl, вказаною користувачем, а всі додаткові аргументи та прапорці після цього передано виконуваному файлу втулка без змін.
Назви з дефісами та підкреслюваннями
Хоча механізм втулків kubectl використовує дефіс (-) у назвах файлів втулків для розділення послідовності підкоманд, які обробляє втулок, усе ж можна створити команду втулка з дефісами у виклику з командного рядка, використовуючи підкреслення (_) у назві файлу.
Приклад:
# створимо втулок, що містить підкреслення в назві файлуecho -e '#!/bin/bash\n\necho "I am a plugin with a dash in my name"' > ./kubectl-foo_bar
sudo chmod +x ./kubectl-foo_bar
# перемістимо втулок у теку з $PATHsudo mv ./kubectl-foo_bar /usr/local/bin
# тепер ви можете викликати свій втулок через kubectl:kubectl foo-bar
I am a plugin with a dash in my name
Зверніть увагу, що підкреслення в назві файлу втулка не заважає використовувати команди на кшталт kubectl foo_bar. Команду з наведеного вище прикладу можна викликати і з дефісом (-), і з підкресленням (_):
# Ви можете викликати вашу власну команду з дефісомkubectl foo-bar
I am a plugin with a dash in my name
# Ви також можете викликати свою власну команду з підкресленнямиkubectl foo_bar
I am a plugin with a dash in my name
Конфлікти назв і перекриття
У вашому PATH може бути кілька втулків з однаковою назвою файлу в різних розташуваннях. Наприклад, якщо PATH має значення PATH=/usr/local/bin/plugins:/usr/local/bin/moreplugins, копія втулка kubectl-foo може існувати в /usr/local/bin/plugins і /usr/local/bin/moreplugins, і тоді вивід команди kubectl plugin list буде таким:
PATH=/usr/local/bin/plugins:/usr/local/bin/moreplugins kubectl plugin list
The following kubectl-compatible plugins are available:
/usr/local/bin/plugins/kubectl-foo
/usr/local/bin/moreplugins/kubectl-foo
- warning: /usr/local/bin/moreplugins/kubectl-foo is overshadowed by a similarly named plugin: /usr/local/bin/plugins/kubectl-foo
error: one plugin warning was found
У цьому сценарії попередження під /usr/local/bin/moreplugins/kubectl-foo повідомляє, що цей втулок ніколи не буде виконано. Натомість механізм втулків kubectl завжди спершу знайде й виконає файл, який першим трапляється у вашому PATH, тобто /usr/local/bin/plugins/kubectl-foo.
Щоб розвʼязати цю проблему, переконайтеся, що розташування втулка, який ви хочете використовувати з kubectl, завжди стоїть першим у вашому PATH. Наприклад, якщо ви хочете завжди використовувати /usr/local/bin/moreplugins/kubectl-foo під час виклику команди kubectl foo, змініть значення PATH на /usr/local/bin/moreplugins:/usr/local/bin/plugins.
Виклик за найдовшою назвою виконуваного файлу
Існує ще один вид перекриття, який може виникнути з назвами файлів втулків. Якщо в PATH користувача є два втулки, kubectl-foo-bar і kubectl-foo-bar-baz, механізм втулків kubectl завжди вибиратиме найдовшу можливу назву втулка для заданої команди користувача. Наведені нижче приклади це пояснюють:
# для заданої команди kubectl завжди вибиратиметься втулок із найдовшою можливою назвою файлуkubectl foo bar baz
Plugin kubectl-foo-bar-baz is executed
kubectl foo bar
Plugin kubectl-foo-bar is executed
kubectl foo bar baz buz
Plugin kubectl-foo-bar-baz is executed, with "buz" as its first argument
kubectl foo bar buz
Plugin kubectl-foo-bar is executed, with "buz" as its first argument
Таке проєктне рішення гарантує, що підкоманди втулка можна за потреби реалізувати в кількох файлах і вкладати їх під «батьківську» команду втулка:
Ви можете скористатися згаданою вище командою kubectl plugin list, щоб переконатися, що kubectl бачить ваш втулок, і перевірити, що немає попереджень, які заважають викликати його як команду kubectl.
kubectl plugin list
The following kubectl-compatible plugins are available:
test/fixtures/pkg/kubectl/plugins/kubectl-foo
/usr/local/bin/kubectl-foo
- warning: /usr/local/bin/kubectl-foo is overshadowed by a similarly named plugin: test/fixtures/pkg/kubectl/plugins/kubectl-foo
plugins/kubectl-invalid
- warning: plugins/kubectl-invalid identified as a kubectl plugin, but it is not executable
error: 2 plugin warnings were found
Використання пакунка command line runtime
Якщо ви пишете втулок для kubectl мовою Go, ви можете скористатися допоміжними бібліотеками cli-runtime.
Ці бібліотеки надають допоміжні засоби для розбору чи оновлення файлу kubeconfig користувача, для виконання запитів у стилі REST до API-сервера або для привʼязування прапорців, повʼязаних із конфігурацією та виводом.
Приклад використання інструментів із репозиторію CLI Runtime дивіться в Sample CLI Plugin.
Розповсюдження втулків для kubectl
Якщо ви розробили втулок для інших користувачів, варто подумати, як ви його пакуватимете, розповсюджуватимете й доставлятимете оновлення своїм користувачам.
Krew
Krew пропонує кросплатформний спосіб пакування й розповсюдження ваших втулків. Так ви використовуєте єдиний формат пакування для всіх цільових платформ (Linux, Windows, macOS тощо) і доставляєте оновлення своїм користувачам. Krew також підтримує індекс втулків, щоб інші люди могли знайти ваш втулок і встановити його.
Нативне / платформозалежне керування пакунками
Також ви можете використовувати традиційні менеджери пакунків, такі як apt або dnf у Linux, Chocolatey у Windows і Homebrew у macOS. Підійде будь-який менеджер пакунків, який може розмістити нові виконувані файли десь у PATH користувача. Якщо ви як автор втулка обираєте цей варіант, вам також доведеться оновлювати пакунок розповсюдження вашого втулка kubectl на кількох платформах для кожного випуску.
Вихідний код
Ви можете опублікувати вихідний код, наприклад як репозиторій Git. Якщо ви обираєте цей варіант, той, хто хоче використовувати цей втулок, має отримати код, налаштувати середовище збірки (якщо потрібна компіляція) і розгорнути втулок. Якщо ви також надаєте скомпільовані пакунки або використовуєте Krew, встановлення стане простішим.
Що далі
Перегляньте репозиторій Sample CLI Plugin, де є докладний приклад втулка, написаного мовою Go. Якщо виникнуть запитання, звертайтеся до команди SIG CLI.
Прочитайте про Krew, менеджер пакунків для втулків kubectl.
16 - Керування HugePages
Налаштування та керування великими сторінками як ресурсом, придатним для планування, у кластері.
This is a stable feature in Kubernetes, and has been since the 1.14 release. You can no longer toggle this feature (the associated feature gate has been removed).
Kubernetes підтримує виділення та використання застосунками в Podʼі заздалегідь виділених великих сторінок (huge pages). На цій сторінці описано, як користувачі можуть використовувати великі сторінки.
Вузол може заздалегідь виділяти великі сторінки кількох розмірів; наприклад, такий рядок у /etc/default/grub виділяє 2*1GiB сторінок розміром 1 GiB і 512*2 MiB сторінок розміром 2 MiB:
Для динамічно виділених сторінок (після завантаження системи) kubelet потрібно перезапустити, щоб нові виділення відобразилися.
API
Великі сторінки можна використовувати через вимоги до ресурсів на рівні контейнера з назвою ресурсу hugepages-<size>, де <size> — найкомпактніше двійкове позначення з цілочисельними значеннями, підтримуваними на конкретному вузлі. Наприклад, якщо вузол підтримує розміри сторінок 2048KiB і 1048576KiB, він надаватиме ресурси, придатні для планування, hugepages-2Mi та hugepages-1Gi. На відміну від CPU або памʼяті, великі сторінки не підтримують надмірне виділення (overcommit). Зверніть увагу, що під час запиту ресурсів великих сторінок також потрібно запитувати ресурси памʼяті або CPU.
Pod може використовувати кілька розмірів великих сторінок в одній специфікації Podʼа. У цьому випадку для всіх монтувань томів потрібно використовувати нотацію medium: HugePages-<hugepagesize>.
Запити великих сторінок мають дорівнювати обмеженням. Так відбувається стандартно, якщо обмеження вказано, а запити — ні.
Великі сторінки ізольовані на рівні контейнера, тому кожен контейнер має власне обмеження у своїй пісочниці cgroup, як запитано в специфікації контейнера.
Томи EmptyDir на основі великих сторінок не можуть споживати більше памʼяті великих сторінок, ніж запитує Pod.
Застосунки, що використовують великі сторінки через shmget() із SHM_HUGETLB, мають працювати з допоміжною групою, яка відповідає proc/sys/vm/hugetlb_shm_group.
Використанням великих сторінок у просторі імен можна керувати через ResourceQuota, подібно до інших обчислювальних ресурсів, таких як cpu або memory, за допомогою токена hugepages-<size>.
17 - Планування GPU
Налаштування та планування GPU для використання як ресурсу вузлів у кластері.
СТАН ФУНКЦІОНАЛУ:GA since Kubernetes v1.26
Kubernetes містить стабільну підтримку керування GPU (графічними процесорами) AMD і NVIDIA на різних вузлах вашого кластера за допомогою втулків пристроїв.
На цій сторінці описано, як користувачі можуть використовувати GPU, і наведено деякі обмеження реалізації.
Використання втулків пристроїв
Kubernetes реалізує втулки пристроїв, щоб надати Podʼам доступ до спеціалізованих апаратних можливостей, таких як GPU.
Примітка: Цей розділ містить посилання на проєкти сторонніх розробників, які надають функціонал, необхідний для Kubernetes. Автори проєкту Kubernetes не несуть відповідальності за ці проєкти. Проєкти вказано в алфавітному порядку. Щоб додати проєкт до цього списку, ознайомтеся з посібником з контенту перед надсиланням змін. Докладніше.
Як адміністратору вам потрібно встановити на вузлах драйвери GPU від відповідного постачальника обладнання й запустити відповідний втулок пристроїв від постачальника GPU. Ось кілька посилань на інструкції постачальників:
Після встановлення втулка ваш кластер надає власний ресурс, придатний для планування, наприклад amd.com/gpu або nvidia.com/gpu.
Ви можете використовувати ці GPU у своїх контейнерах, запитуючи власний ресурс GPU так само, як ви запитуєте cpu чи memory. Однак є деякі обмеження щодо того, як вказувати вимоги до ресурсів для власних пристроїв.
GPU слід вказувати лише в розділі limits, що означає:
Ви можете вказати limits для GPU без requests, оскільки Kubernetes стандартно використовує обмеження як значення запиту.
Ви можете вказати GPU і в limits, і в requests, але ці два значення мають бути однаковими.
Ви не можете вказати requests для GPU без limits.
Ось приклад маніфесту для Podʼа, який запитує GPU:
apiVersion:v1kind:Podmetadata:name:example-vector-addspec:restartPolicy:OnFailurecontainers:- name:example-vector-addimage:"registry.example/example-vector-add:v42"resources:limits:gpu-vendor.example/example-gpu:1# запит на 1 GPU
Керування кластерами з різними типами GPU
Якщо різні вузли вашого кластера мають різні типи GPU, ви можете використовувати мітки вузлів і селектори вузлів для планування Podʼів на відповідні вузли.
Наприклад:
# Додайте вузлам мітки з типом прискорювача, який вони мають.kubectl label nodes node1 accelerator=example-gpu-x100
kubectl label nodes node2 accelerator=other-gpu-k915
Ключ мітки accelerator — лише приклад; за бажання ви можете використовувати інший ключ мітки.
Автоматичне додавання міток вузлам
Як адміністратор ви можете автоматично виявляти всі вузли з підтримкою GPU й додавати їм мітки, розгорнувши Kubernetes Node Feature Discovery (NFD). NFD виявляє апаратні можливості, доступні на кожному вузлі кластера Kubernetes. Зазвичай NFD налаштовують оголошувати ці можливості як мітки вузлів, але NFD також може додавати розширені ресурси, анотації та taints вузлів. NFD сумісний з усіма підтримуваними версіями Kubernetes. Стандартно NFD створює мітки можливостей для виявлених можливостей. Адміністратори також можуть використовувати NFD, щоб додавати taints вузлам із певними можливостями, і тоді на цих вузлах можна буде планувати лише Podʼи, що запитують ці можливості.
Вам також потрібен втулок для NFD, який додає відповідні мітки вашим вузлам; це можуть бути загальні мітки або мітки конкретного постачальника. Ваш постачальник GPU може надавати сторонній втулок для NFD; докладніше дивіться в його документації.
apiVersion:v1kind:Podmetadata:name:example-vector-addspec:restartPolicy:OnFailure# Ви можете використовувати спорідненість вузлів Kubernetes, щоб запланувати цей Pod на вузол,# який надає тип GPU, потрібний його контейнеру для роботиaffinity:nodeAffinity:requiredDuringSchedulingIgnoredDuringExecution:nodeSelectorTerms:- matchExpressions:- key:"gpu.gpu-vendor.example/installed-memory"operator:Gt# (більше ніж)values:["40535"]- key:"feature.node.kubernetes.io/pci-10.present"# мітка можливості NFDvalues:["true"]# (необовʼязково) планувати лише на вузли з пристроєм PCI 10containers:- name:example-vector-addimage:"registry.example/example-vector-add:v42"resources:limits:gpu-vendor.example/example-gpu:1# запит на 1 GPU