Це багатосторінковий друкований вигляд цього розділу. Натисність щоб друкувати.

Повернутися до звичайного перегляду сторінки.

Завдання

Цей розділ документації Kubernetes містить сторінки, які показують, як виконувати окремі завдання. Сторінка завдання показує, як виконати одну дію, зазвичай за допомогою короткої послідовності кроків.

Якщо ви хочете написати сторінку завдання, дивіться Створення запиту на злиття для документації.

1 - Встановлення інструментів

Налаштування інструментів Kubernetes на вашому компʼютері.

Примітка:

Щоб налаштувати середовище для практики, дивіться сторінку Навчальне середовище.

kubectl

Інструмент командного рядка Kubernetes, kubectl, дозволяє виконувати команди в кластерах Kubernetes. За допомогою kubectl можна розгортати застосунки, оглядати ресурси кластера й керувати ними, а також переглядати логи. Докладніше, зокрема повний перелік операцій kubectl, дивіться в довідковій документації kubectl.

kubectl можна встановити на різних платформах Linux, macOS і Windows. Виберіть свою операційну систему нижче.

kind

kind дозволяє запускати Kubernetes на вашому локальному компʼютері. Для цього інструмента потрібно встановити Docker або Podman.

На сторінці kind Quick Start показано, що потрібно зробити, щоб почати працювати з kind.

Переглянути посібник kind Quick Start

minikube

Подібно до kind, minikube — це інструмент, який дозволяє запускати Kubernetes локально. minikube запускає локальний кластер Kubernetes «все в одному» або багатовузловий кластер на вашому персональному компʼютері (зокрема на ПК з Windows, macOS і Linux), щоб ви могли випробувати Kubernetes або використовувати його для щоденної розробки.

Якщо ваша мета — встановити інструмент, скористайтеся офіційним посібником Get Started!.

Переглянути посібник minikube Get Started!

Коли minikube запрацює, ви зможете використовувати його для запуску застосунку-прикладу.

kubeadm

Ви можете використовувати інструмент kubeadm для створення кластерів Kubernetes і керування ними. Він виконує дії, потрібні для зручного запуску мінімально життєздатного захищеного кластера.

На сторінці Встановлення kubeadm показано, як встановити kubeadm. Після встановлення ви можете використовувати його для створення кластера.

Переглянути посібник зі встановлення kubeadm

1.1 - Встановлення та налаштування kubectl у Linux

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

Вам потрібно використовувати версію kubectl, яка має мінорну версію, що відрізняється не більше ніж на одиницю від мінорної версії вашого кластера. Наприклад, клієнт v1.37 може співпрацювати з панелями управління v1.36, v1.37 та v1.38. Використання останньої сумісної версії kubectl допомагає уникнути непередбачуваних проблем.

Встановлення kubectl у Linux

Існують наступні методи встановлення kubectl у Linux:

Встановлення бінарного файлу kubectl за допомогою curl у Linux

  1. Завантажте останній випуск за допомогою команди:

    
       curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"
       
    
       curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/arm64/kubectl"
       

    Примітка:

    Щоб завантажити певну версію, замініть частину команди $(curl -L -s https://dl.k8s.io/release/stable.txt) конкретною версією.

    Наприклад, щоб завантажити версію 1.37.0 у Linux x86-64, введіть:

    curl -LO https://dl.k8s.io/release/v1.37.0/bin/linux/amd64/kubectl
    

    А для Linux ARM64:

    curl -LO https://dl.k8s.io/release/v1.37.0/bin/linux/arm64/kubectl
    
  2. Перевірте бінарний файл (необовʼязково)

    Завантажте файл контрольної суми kubectl:

    
       curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl.sha256"
       
    
       curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/arm64/kubectl.sha256"
       

    Перевірте бінарний файл kubectl за допомогою файлу контрольної суми:

    echo "$(cat kubectl.sha256)  kubectl" | sha256sum --check
    

    Якщо перевірка успішна, вивід буде таким:

    kubectl: OK
    

    Якщо перевірка не пройшла, sha256 поверне ненульовий статус і виведе повідомлення подібне до:

    kubectl: FAILED
    sha256sum: WARNING: 1 computed checksum did NOT match
    

    Примітка:

    Завантажте ту саму версію бінарного файлу та файлу контрольної суми.
  3. Встановіть kubectl

    sudo install -o root -g root -m 0755 kubectl /usr/local/bin/kubectl
    

    Примітка:

    Якщо у вас немає прав root на цільовій системі, все одно можна встановити kubectl у теку ~/.local/bin:

    chmod +x kubectl
    mkdir -p ~/.local/bin
    mv ./kubectl ~/.local/bin/kubectl
    # а потім додайте (в початок чи кінець) ~/.local/bin до $PATH
    
  4. Перевірте, щоб переконатися, що встановлена вами версія є актуальною:

    kubectl version --client
    

    Або скористайтеся цим для детального перегляду версії:

    kubectl version --client --output=yaml
    

Встановлення за допомогою стандартного пакетного менеджера

  1. Оновіть індекс пакунків apt та встановіть пакунки, необхідні для використання репозиторію apt Kubernetes:

    sudo apt-get update
    # apt-transport-https може бути макетним пакетом; якщо так, ви можете пропустити цей пакет
    sudo apt-get install -y apt-transport-https ca-certificates curl gnupg
    
  2. Завантажте публічний ключ підпису для репозиторіїв пакунків Kubernetes. Той самий ключ підпису використовується для всіх репозиторіїв, тому ви можете проігнорувати версію в URL:

    # Якщо тека `/etc/apt/keyrings` не існує, її слід створити перед запуском curl, прочитайте примітку нижче.
    # sudo mkdir -p -m 755 /etc/apt/keyrings
    curl -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.
  1. Додайте відповідний репозиторій Kubernetes apt. Якщо ви хочете використовувати версію Kubernetes, відмінну від v1.37, замініть v1.37 на потрібну мінорну версію в команді нижче:

    # Це перезапише будь-яку існуючу конфігурацію в /etc/apt/sources.list.d/kubernetes.list
    echo '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.
  1. Оновіть індекс пакунків apt, а потім встановіть kubectl:

    sudo apt-get update
    sudo apt-get install -y kubectl
    
  1. Додайте репозиторій Kubernetes yum. Якщо ви хочете використовувати версію Kubernetes, відмінну від v1.37, замініть v1.37 на потрібну мінорну версію в команді нижче.

    # Це перезапише будь-яку існуючу конфігурацію у /etc/yum.repos.d/kubernetes.repo
    cat <<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.
  1. Встановіть kubectl за допомогою dnf:

    sudo dnf install -y kubectl
    
  1. Додайте репозиторій Kubernetes zypper. Якщо ви хочете використовувати версію Kubernetes, відмінну від v1.37, замініть v1.37 на потрібну мінорну версію в команді нижче.

    # Це перезапише будь-яку існуючу конфігурацію у /etc/zypp/repos.d/kubernetes.repo
    cat <<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.
  1. Оновіть 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
    
  2. Встановіть 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 в усіх сеансах оболонки. Це можна зробити двома способами:


echo 'source <(kubectl completion bash)' >>~/.bashrc

kubectl completion bash | sudo tee /etc/bash_completion.d/kubectl > /dev/null
sudo chmod a+r /etc/bash_completion.d/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. Завантажте останній випуск за допомогою наступної команди:

    
       curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl-convert"
       
    
       curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/arm64/kubectl-convert"
       
  2. Перевірте бінарний файл (необовʼязково)

    Завантажте файл контрольної суми для kubectl-convert:

    
       curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl-convert.sha256"
       
    
       curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/arm64/kubectl-convert.sha256"
       

    Перевірте бінарний файл kubectl-convert за допомогою файлу контрольної суми:

    echo "$(cat kubectl-convert.sha256) kubectl-convert" | sha256sum --check
    

    Якщо перевірка пройшла успішно, вивід буде таким:

    kubectl-convert: OK
    

    Якщо перевірка не вдалася, sha256 виходить з ненульовим статусом і виводить подібне повідомлення:

    kubectl-convert: FAILED
    sha256sum: WARNING: 1 computed checksum did NOT match
    

    Примітка:

    Завантажте ту саму версію бінарного файлу та файлу контрольної суми.
  3. Встановіть kubectl-convert

    sudo install -o root -g root -m 0755 kubectl-convert /usr/local/bin/kubectl-convert
    
  4. Перевірте, чи втулок успішно встановлено

    kubectl convert --help
    

    Якщо ви не бачите помилку, це означає, що втулок успішно встановлено.

  5. Після встановлення втулка вилучіть файли встановлення:

    rm kubectl-convert kubectl-convert.sha256
    

Що далі

1.2 - Встановлення та налаштування kubectl у macOS

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

Вам потрібно використовувати версію kubectl, яка має мінорну версію, що відрізняється не більше ніж на одиницю від мінорної версії вашого кластера. Наприклад, клієнт v1.37 може співпрацювати з панелями управління v1.36, v1.37 та v1.38. Використання останньої сумісної версії kubectl допомагає уникнути непередбачуваних проблем.

Встановлення kubectl у macOS

Існують наступні методи встановлення kubectl у macOS:

Встановлення бінарного файлу kubectl за допомогою curl у macOS

  1. Завантажте останній випуск:

    
       curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/darwin/amd64/kubectl"
       
    
       curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/darwin/arm64/kubectl"
       

    Примітка:

    Щоб завантажити певну версію, замініть частину $(curl -L -s https://dl.k8s.io/release/stable.txt) команди на конкретну версію.

    Наприклад, щоб завантажити версію 1.37.0 на Intel macOS, введіть:

    curl -LO "https://dl.k8s.io/release/v1.37.0/bin/darwin/amd64/kubectl"
    

    А для macOS на Apple Silicon, введіть:

    curl -LO "https://dl.k8s.io/release/v1.37.0/bin/darwin/arm64/kubectl"
    
  2. Перевірте бінарний файл (необовʼязково)

    Завантажте файл контрольної суми для kubectl:

    
       curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/darwin/amd64/kubectl.sha256"
       
    
       curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/darwin/arm64/kubectl.sha256"
       

    Перевірте бінарний файл kubectl за допомогою файлу контрольної суми:

    echo "$(cat kubectl.sha256)  kubectl" | shasum -a 256 --check
    

    Якщо перевірка пройшла успішно, вивід буде таким:

    kubectl: OK
    

    Якщо перевірка не вдалася, shasum виходить з ненульовим статусом і виводить подібне повідомлення:

    kubectl: FAILED
    shasum: WARNING: 1 computed checksum did NOT match
    

    Примітка:

    Завантажте ту саму версію бінарного файлу та файлу контрольної суми.
  3. Зробіть бінарний файл kubectl виконуваним.

    chmod +x ./kubectl
    
  4. Перемістіть бінарний файл kubectl до теки, що входить до PATH вашої системи.

    sudo mv ./kubectl /usr/local/bin/kubectl
    sudo chown root: /usr/local/bin/kubectl
    

    Примітка:

    Переконайтеся, що /usr/local/bin є у вашій змінній середовища PATH.
  5. Перевірте, що встановлена версія kubectl актуальна:

    kubectl version --client
    

    Або використовуйте це для детального перегляду версії:

    kubectl version --client --output=yaml
    
  6. Після встановлення та перевірки kubectl видаліть файл контрольної суми:

    rm kubectl.sha256
    

Встановлення за допомогою Homebrew у macOS

Якщо ви користуєтеся macOS і пакетним менеджером Homebrew, ви можете встановити kubectl за допомогою Homebrew.

  1. Виконайте команду встановлення:

    brew install kubectl
    

    або

    brew install kubernetes-cli
    
  2. Перевірте, що встановлена версія актуальна:

    kubectl version --client
    

Встановлення за допомогою Macports у macOS

Якщо ви користуєтеся macOS і пакетним менеджером Macports, ви можете встановити kubectl за допомогою Macports.

  1. Виконайте команду встановлення:

    sudo port selfupdate
    sudo port install kubectl
    
  2. Перевірте, що встановлена версія актуальна:

    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:

brew_etc="$(brew --prefix)/etc" && [[ -r "${brew_etc}/profile.d/bash_completion.sh" ]] && . "${brew_etc}/profile.d/bash_completion.sh"

Перезавантажте оболонку й перевірте, що bash-completion v2 правильно встановлено, за допомогою type _init_completion.

Увімкнення автодоповнення kubectl

Тепер потрібно забезпечити підключення скрипта автодоповнення kubectl в усіх сеансах оболонки. Це можна зробити кількома способами:

  • Підключіть скрипт автодоповнення у файлі ~/.bash_profile:

    echo 'source <(kubectl completion bash)' >>~/.bash_profile
    
  • Додайте скрипт автодоповнення до теки /usr/local/etc/bash_completion.d:

    kubectl completion bash >/usr/local/etc/bash_completion.d/kubectl
    
  • Якщо у вас є псевдонім для 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. Завантажте останній випуск за допомогою команди:

    
       curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/darwin/amd64/kubectl-convert"
       
    
       curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/darwin/arm64/kubectl-convert"
       
  2. Перевірте бінарний файл (необовʼязково)

    Завантажте файл контрольної суми для kubectl-convert:

    
       curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/darwin/amd64/kubectl-convert.sha256"
       
    
       curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/darwin/arm64/kubectl-convert.sha256"
       

    Перевірте бінарний файл kubectl-convert за допомогою файлу контрольної суми:

    echo "$(cat kubectl-convert.sha256)  kubectl-convert" | shasum -a 256 --check
    

    Якщо перевірка пройшла успішно, вивід буде таким:

    kubectl-convert: OK
    

    Якщо перевірка не вдалася, shasum виходить з ненульовим статусом і виводить подібне повідомлення:

    kubectl-convert: FAILED
    shasum: WARNING: 1 computed checksum did NOT match
    

    Примітка:

    Завантажте ту саму версію бінарного файлу та файлу контрольної суми.
  3. Зробіть бінарний файл kubectl-convert виконуваним.

    chmod +x ./kubectl-convert
    
  4. Перемістіть бінарний файл kubectl-convert до теки, що входить до PATH вашої системи.

    sudo mv ./kubectl-convert /usr/local/bin/kubectl-convert
    sudo chown root: /usr/local/bin/kubectl-convert
    

    Примітка:

    Переконайтеся, що /usr/local/bin є у вашій змінній середовища PATH.
  5. Перевірте, що втулок успішно встановлено

    kubectl convert --help
    

    Якщо ви не бачите жодних помилок, втулок було встановлено успішно.

  6. Після встановлення втулка вилучіть файли встановлення:

    rm kubectl-convert kubectl-convert.sha256
    

Видалення kubectl у macOS

Залежно від того, як ви встановили kubectl, використовуйте один з наступних методів.

Видалення kubectl за допомогою командного рядка

  1. Знайдіть бінарний файл kubectl у вашій системі:

    which kubectl
    
  2. Видаліть бінарний файл kubectl:

    sudo rm <path>
    

    Замініть <path> на шлях до бінарного файлу kubectl з попереднього кроку. Наприклад, sudo rm /usr/local/bin/kubectl.

Видалення kubectl за допомогою Homebrew

Якщо ви встановили kubectl за допомогою Homebrew, виконайте наступну команду:

brew remove kubectl

Що далі

1.3 - Встановлення та налаштування kubectl у Windows

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

Вам потрібно використовувати версію kubectl, яка має мінорну версію, що відрізняється не більше ніж на одиницю від мінорної версії вашого кластера. Наприклад, клієнт v1.37 може співпрацювати з панелями управління v1.36, v1.37 та v1.38. Використання останньої сумісної версії kubectl допомагає уникнути непередбачуваних проблем.

Встановлення kubectl у Windows

Існують наступні методи встановлення kubectl у Windows:

Встановлення бінарного файлу kubectl у Windows (через пряме завантаження або curl)

  1. У вас є два варіанти встановлення kubectl на вашому пристрої з Windows

    • Безпосереднє завантаження:

      Завантажте останню версію 1.37 патчу безпосередньо для вашої архітектури, відвідавши сторінку випуску Kubernetes. Переконайтеся, що вибрано правильний двійковий файл для вашої архітектури (наприклад, amd64, arm64 тощо).

    • Використовуючи curl:

      Якщо у вас встановлено curl, використайте цю команду:

      curl.exe -LO "https://dl.k8s.io/release/v1.37.0/bin/windows/amd64/kubectl.exe"
      

    Примітка:

    Щоб дізнатися останню стабільну версію (наприклад, для скриптів), перегляньте https://dl.k8s.io/release/stable.txt.
  2. Перевірте бінарний файл (необовʼязково)

    Завантажте файл контрольної суми для kubectl:

    curl.exe -LO "https://dl.k8s.io/v1.37.0/bin/windows/amd64/kubectl.exe.sha256"
    

    Перевірте бінарний файл kubectl за допомогою файлу контрольної суми:

    • Використовуючи командний рядок для ручного порівняння виводу CertUtil з завантаженим файлом контрольної суми:

      CertUtil -hashfile kubectl.exe SHA256
      type kubectl.exe.sha256
      
    • Використовуючи PowerShell для автоматизації перевірки за допомогою оператора -eq для отримання результату True або False:

       $(Get-FileHash -Algorithm SHA256 .\kubectl.exe).Hash -eq $(Get-Content .\kubectl.exe.sha256)
      
  3. Додайте на початок чи в кінець змінної середовища PATH шлях до теки з kubectl.

  4. Перевірте, що версія 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

  1. Для встановлення kubectl у Windows ви можете використовувати пакетний менеджер Chocolatey, командний інсталятор Scoop, або менеджер пакунків winget.

    choco install kubernetes-cli
    
    scoop install kubectl
    
    winget install -e --id Kubernetes.kubectl
    
  2. Перевірте, що встановлена версія актуальна:

    kubectl version --client
    
  3. Перейдіть до вашої домашньої теки:

    # Якщо ви використовуєте cmd.exe, виконайте: cd %USERPROFILE%
    cd ~
    
  4. Створіть теку .kube:

    mkdir .kube
    
  5. Перейдіть до теки .kube, що ви щойно створили:

    cd .kube
    
  6. Налаштуйте kubectl для використання віддаленого кластера Kubernetes:

    New-Item config -type file
    

Примітка:

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

Те саме повідомлення про помилку може мати й інші причини, не повʼязані з цією зміною.

Необовʼязкові налаштування та втулки kubectl

Увімкнення автодоповнення оболонки

kubectl надає підтримку автодоповнення для оболонок Bash, Zsh, Fish та PowerShell, що може значно зекономити ваш час при введенні команд.

Нижче подані процедури для налаштування автодоповнення для PowerShell.

Скрипт автодоповнення kubectl для PowerShell можна згенерувати командою kubectl completion powershell.

Щоб зробити це в усіх сеансах оболонки, додайте такий рядок до файлу $PROFILE:

kubectl completion powershell | Out-String | Invoke-Expression

Ця команда генеруватиме скрипт автодоповнення під час кожного запуску PowerShell. Ви також можете додати згенерований скрипт безпосередньо до файлу $PROFILE.

Щоб додати згенерований скрипт до файлу $PROFILE, виконайте такий рядок у командному рядку PowerShell:

kubectl completion powershell >> $PROFILE

Після перезавантаження оболонки автодоповнення kubectl має працювати.

Налаштування kuberc

Дивіться kuberc для отримання докладної інформації.

Встановлення втулка kubectl convert

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

  1. Завантажте останній випуск за допомогою команди:

    curl.exe -LO "https://dl.k8s.io/release/v1.37.0/bin/windows/amd64/kubectl-convert.exe"
    
  2. Перевірте бінарний файл (необовʼязково).

    Завантажте файл контрольної суми для kubectl-convert:

    curl.exe -LO "https://dl.k8s.io/v1.37.0/bin/windows/amd64/kubectl-convert.exe.sha256"
    

    Перевірте бінарний файл kubectl-convert за допомогою файлу контрольної суми:

    • Використовуючи командний рядок для ручного порівняння виводу CertUtil з завантаженим файлом контрольної суми:

      CertUtil -hashfile kubectl-convert.exe SHA256
      type kubectl-convert.exe.sha256
      
    • Використовуючи PowerShell для автоматизації перевірки за допомогою оператора -eq для отримання результату True або False:

       $($(CertUtil -hashfile .\kubectl-convert.exe SHA256)[1] -replace " ", "") -eq $(type .\kubectl-convert.exe.sha256)
      
  3. Додайте на початок чи в кінець змінної середовища PATH шлях до теки з kubectl-convert.

  4. Перевірте, що втулок успішно встановлено.

    kubectl convert --help
    

    Якщо ви не бачите помилки, це означає, що втулок успішно встановлено.

  5. Після встановлення втулка вилучіть файли встановлення:

    del kubectl-convert.exe
    del kubectl-convert.exe.sha256
    

Що далі

2 - Адміністрування кластера

Дізнайтеся про поширені завдання адміністрування кластера.

2.1 - Адміністрування з kubeadm

Якщо у вас ще немає кластера, дивіться створення кластерів за допомогою kubeadm.

Завдання в цьому розділі призначені для тих, хто адмініструє наявний кластер:

2.1.1 - Оновлення вузлів Linux

Ця сторінка пояснює, як оновити робочі вузли Linux, створені за допомогою kubeadm.

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

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

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

Зміна репозиторію пакунків

Якщо ви використовуєте репозиторії пакунків, що належать спільноті (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> імʼям вузла, для якого ви виконуєте drain
kubectl drain <node-to-drain> --ignore-daemonsets

Оновлення kubelet

  1. Оновіть 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
    
  2. Перезапустіть kubelet:

    sudo systemctl daemon-reload
    sudo systemctl restart kubelet
    

Виконайте uncordon вузла

Поверніть вузол в роботу, позначивши його як придатний для планування:

# виконайте цю команду на вузлі панелі управління
# замініть <node-to-uncordon> імʼям вашого вузла
kubectl uncordon <node-to-uncordon>

Що далі

2.1.2 - Оновлення вузлів Windows

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

Ця сторінка пояснює, як оновити вузол Windows, створений за допомогою kubeadm.

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

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

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

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

Оновлення робочих вузлів

Оновлення kubeadm

  1. З вузла Windows оновіть kubeadm:

    # замініть 1.37.0 на вашу бажану версію
    curl.exe -Lo <path-to-kubeadm.exe>  "https://dl.k8s.io/v1.37.0/bin/windows/amd64/kubeadm.exe"
    

Виконайте drain вузла

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

    # замініть <node-to-drain> імʼям вашого вузла, для якого ви виконуєте drain
    kubectl drain <node-to-drain> --ignore-daemonsets
    

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

    node/ip-172-31-85-18 cordoned
    node/ip-172-31-85-18 drained
    

Оновлення конфігурації kubelet

  1. З вузла Windows виконайте таку команду, щоб синхронізувати нову конфігурацію kubelet:

    kubeadm upgrade node
    

Оновлення kubelet та kube-proxy

  1. З вузла Windows оновіть та перезапустіть kubelet:

    stop-service kubelet
    curl.exe -Lo <path-to-kubelet.exe> "https://dl.k8s.io/v1.37.0/bin/windows/amd64/kubelet.exe"
    restart-service kubelet
    
  2. З вузла Windows оновіть та перезапустіть kube-proxy.

    stop-service kube-proxy
    curl.exe -Lo <path-to-kube-proxy.exe> "https://dl.k8s.io/v1.37.0/bin/windows/amd64/kube-proxy.exe"
    restart-service kube-proxy
    

Примітка:

Якщо ви запускаєте kube-proxy в контейнері HostProcess всередині Podʼа, а не як службу Windows, ви можете оновити kube-proxy, застосувавши нову версію ваших маніфестів kube-proxy.

Виконайте uncordon вузла

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

    # замініть <node-to-drain> імʼям вашого вузла
    kubectl uncordon <node-to-drain>
    

Що далі

2.2 - Міграція з dockershim

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

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

Ці завдання допоможуть вам здійснити міграцію:

Що далі

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 для вашої хмари:

  1. Створіть пакунок Go з реалізацією, яка задовольняє cloudprovider.Interface.
  2. Використовуйте main.go у cloud-controller-manager з ядра Kubernetes як шаблон для свого main.go. Як зазначено вище, єдина відмінність полягатиме у пакунку хмари, який буде імпортуватися.
  3. Імпортуйте свій пакунок хмари в main.go, переконайтеся, що ваш пакунок має блок init для запуску cloudprovider.RegisterCloudProvider.

Багато постачальників хмар публікують код свого менеджера контролерів як відкритий код. Якщо ви створюєте новий cloud-controller-manager з нуля, за відправну точку можна взяти наявний зовнішній cloud-controller-manager.

У коді Kubernetes

Для внутрішніх постачальників хмар можна запустити внутрішній cloud-controller-manager як DaemonSet у вашому кластері. Докладніше дивіться Адміністрування Cloud Controller Manager.

2.6 - Посилення безпеки динамічного виділення ресурсів у вашому кластері

Ця сторінка показує адміністраторам кластера, як посилити авторизацію для динамічного виділення ресурсів (DRA) з акцентом на доступ з мінімальними привілеями для оновлень статусу ResourceClaim.

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

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

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

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

Визначте компоненти DRA, які оновлюють статус

Задокументуйте, які ідентичності (зазвичай ServiceAccount) оновлюють статус ResourceClaim у вашому кластері. Типові компоненти, що записують статус:

  • kube-scheduler або власний контролер виділення
  • драйвери DRA, локальні для вузла
  • багатовузлові контролери статусу DRA

Надання мінімально необхідних дозволів для синтетичних субресурсів

Починаючи з Kubernetes v1.36, оновлення статусу DRA вимагають дозволів на синтетичні субресурси на додаток до resourceclaims/status.

Надання дозволів для планувальника та контролера виділення

Застосуйте роль, яка дозволяє оновлення, повʼязані з привʼязкою:

apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: dra-binding-updater
rules:
  - apiGroups: ["resource.k8s.io"]
    resources: ["resourceclaims/status"]
    verbs: ["get", "patch", "update"]
  - apiGroups: ["resource.k8s.io"]
    resources: ["resourceclaims/binding"]
    verbs: ["patch", "update"]

Надання дозволів для драйверів, локальних для вузла

Використовуйте вузлово-орієнтовані дієслова для драйверів, локальних для вузла:

apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: dra-node-driver-status-updater
rules:
  - apiGroups: ["resource.k8s.io"]
    resources: ["resourceclaims/status"]
    verbs: ["get", "patch", "update"]
  - apiGroups: ["resource.k8s.io"]
    resources: ["resourceclaims/driver"]
    verbs: ["associated-node:patch", "associated-node:update"]
    resourceNames: ["dra.example.com"]

Надання дозволів для багатовузлового контролера лише за потреби

Використовуйте arbitrary-node:* лише для компонентів, які повинні оновлювати статус з будь-якого вузла:

apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: dra-multinode-status-updater
rules:
  - apiGroups: ["resource.k8s.io"]
    resources: ["resourceclaims/status"]
    verbs: ["get", "patch", "update"]
  - apiGroups: ["resource.k8s.io"]
    resources: ["resourceclaims/driver"]
    verbs: ["arbitrary-node:patch", "arbitrary-node:update"]
    resourceNames: ["dra.example.com"]

Привʼязка ролей до конкретних ідентичностей

Створіть обʼєкти ClusterRoleBinding для кожної ідентичності компонента та уникайте спільного використання широкої ролі між не повʼязаними між собою компонентами DRA.

Обмежте правила resourceclaims/driver за допомогою resourceNames, де це можливо, щоб ідентичність могла оновлювати статус лише для конкретного драйвера DRA, яким вона керує.

Перевірка та моніторинг

  1. Перевірте, що кожна ідентичність має лише необхідні дієслова та субресурси.
  2. Підтвердіть, що оновлення статусу DRA працюють після розгортання.
  3. Спостерігайте за подіями аудиту API-сервера щодо відхилених запитів resourceclaims/binding та resourceclaims/driver.

Що далі

2.7 - Використання CoreDNS для виявлення Service

Ця сторінка описує процес оновлення 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ʼи на вузлах, які мають доступ до виділених пристроїв.

Переконайтеся, що ви ознайомлені з принципом роботи DRA та термінологією DRA, такою як DeviceClasses, ResourceClaims і ResourceClaimTemplates. Детальніше дивіться Динамічне виділення ресурсів (DRA).

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

Вам треба мати кластер 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:

* `resource.k8s.io/v1beta1`
* `resource.k8s.io/v1beta2`

Альфа-функції з окремими типами API потребують:

  • resource.k8s.io/v1alpha3

Для отримання додаткової інформації дивіться Увімкнення або вимкнення груп API.

Перевірте, що DRA увімкнено

Щоб перевірити правильність налаштування кластера, спробуйте вивести список DeviceClasses:

kubectl get deviceclasses

Якщо конфігурація компонентів була правильною, ви побачите подібний результат:

No resources found

Якщо DRA налаштовано неправильно, результат виконання попередньої команди буде схожий на:

error: the server doesn't have a resource type "deviceclasses"

Наприклад, це може статися, коли група API resource.k8s.io була вимкнена. Аналогічна перевірка застосовується до типів верхнього рівня якості альфа або бета.

Спробуйте наступні кроки для усунення несправностей:

  1. Переконфігуруйте та перезапустіть компонент kube-apiserver.

  2. Якщо повне поле .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

Спробуйте наступні кроки для усунення несправностей:

  1. Перевірте стан драйвера DRA та шукайте повідомлення про помилки щодо публікації ResourceSlices у виводі його логів. Постачальник драйвера може надати додаткові інструкції щодо встановлення та усунення несправностей.

Створіть DeviceClasses

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

ResourceSlices, які публікує ваш драйвер, містять інформацію про пристрої, якими керує драйвер, такі як ємність, метадані та атрибути. Ви можете використовувати Common Expression Language для фільтрації властивостей у DeviceClasses, що спрощує пошук пристроїв для операторів навантажень.

  1. Щоб знайти властивості пристрою, які можна вибирати у DeviceClasses за допомогою виразів CEL, отримайте специфікацію ResourceSlice:

    kubectl get resourceslice <resourceslice-name> -o yaml
    

    Вивід буде схожий на:

    apiVersion: resource.k8s.io/v1
    kind: ResourceSlice
    # рядки пропущено для ясності
    spec:
      devices:
      - attributes:
          type:
            string: gpu
        capacity:
          memory:
            value: 64Gi
        name: gpu-0
      - attributes:
          type:
            string: gpu
        capacity:
          memory:
            value: 64Gi
        name: gpu-1
      driver: driver.example.com
      nodeName: cluster-1-node-1
    # рядки пропущено для ясності
    

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

  2. Ознайомтеся з прикладом маніфесту DeviceClass, який вибирає будь-який пристрій, керований драйвером пристроїв driver.example.com:

    apiVersion: resource.k8s.io/v1
    kind: DeviceClass
    metadata:
      name: example-device-class
    spec:
      selectors:
      - cel:
          expression: |-
            device.driver == "driver.example.com"
    
  3. Створіть DeviceClass у вашому кластері:

    kubectl apply -f https://k8s.io/examples/dra/deviceclass.yaml
    

Очищення

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

kubectl delete -f https://k8s.io/examples/dra/deviceclass.yaml

Що далі

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ʼа, який спричинив їх створення.

Щоб створити робоче навантаження, яке запитує ресурси, виберіть одну з наступних опцій:

Ознайомтеся з наступним прикладом маніфесту:

apiVersion: resource.k8s.io/v1
kind: ResourceClaimTemplate
metadata:
  name: example-resource-claim-template
spec:
  spec:
    devices:
      requests:
      - name: gpu-claim
        exactly:
          deviceClassName: example-device-class
          selectors:
            - cel:
                expression: |-
                  device.attributes["driver.example.com"].type == "gpu" &&
                  device.capacity["driver.example.com"].memory == quantity("64Gi")

Цей маніфест створює ResourceClaimTemplate, який запитує пристрої у DeviceClass example-device-class, що відповідають обом наступним параметрам:

  • Пристрої, які мають атрибут driver.example.com/type зі значенням gpu.
  • Пристрої, які мають ємність 64Gi.

Щоб створити ResourceClaimTemplate, виконайте наступну команду:

kubectl apply -f https://k8s.io/examples/dra/resourceclaimtemplate.yaml

Ознайомтеся з наступним прикладом маніфесту:

apiVersion: resource.k8s.io/v1
kind: ResourceClaim
metadata:
  name: example-resource-claim
spec:
  devices:
    requests:
    - name: single-gpu-claim
      exactly:
        deviceClassName: example-device-class
        allocationMode: All
        selectors:
        - cel:
            expression: |-
              device.attributes["driver.example.com"].type == "gpu" &&
              device.capacity["driver.example.com"].memory == quantity("64Gi")

Цей маніфест створює ResourceClaim, який запитує пристрої у DeviceClass example-device-class, що відповідають обом наступним параметрам:

  • Пристрої, які мають атрибут driver.example.com/type зі значенням gpu.
  • Пристрої, які мають ємність 64Gi.

Щоб створити ResourceClaim, виконайте наступну команду:

kubectl apply -f https://k8s.io/examples/dra/resourceclaim.yaml

Запит пристроїв у робочих навантаженнях за допомогою DRA

Щоб запросити виділення пристроїв, вкажіть ResourceClaim або ResourceClaimTemplate у полі resourceClaims специфікації Podʼа. Потім запросіть конкретну заявку за назвою у полі resources.claims контейнера цього Podʼа. Ви можете вказати декілька записів у полі resourceClaims та використовувати конкретні заявки у різних контейнерах.

  1. Ознайомтеся з наступним прикладом Job:

    apiVersion: batch/v1
    kind: Job
    metadata:
      name: example-dra-job
    spec:
      completions: 10
      parallelism: 2
      template:
        spec:
          restartPolicy: Never
          containers:
          - name: container0
            image: ubuntu:24.04
            command: ["sleep", "9999"]
            resources:
              claims:
              - name: separate-gpu-claim
          - name: container1
            image: ubuntu:24.04
            command: ["sleep", "9999"]
            resources:
              claims:
              - name: shared-gpu-claim
          - name: container2
            image: ubuntu:24.04
            command: ["sleep", "9999"]
            resources:
              claims:
              - name: shared-gpu-claim
          resourceClaims:
          - name: separate-gpu-claim
            resourceClaimTemplateName: example-resource-claim-template
          - name: shared-gpu-claim
            resourceClaimName: example-resource-claim
    

    Кожен Pod у цьому Job має наступні властивості:

    • Робить доступними для контейнерів ResourceClaimTemplate з назвою separate-gpu-claim та ResourceClaim з назвою shared-gpu-claim.
    • Запускає наступні контейнери:
      • container0 запитує пристрої з ResourceClaimTemplate separate-gpu-claim.
      • container1 та container2 мають спільний доступ до пристроїв з ResourceClaim shared-gpu-claim.
  2. Створіть Job:

    kubectl apply -f https://k8s.io/examples/dra/dra-example-job.yaml
    

Спробуйте наступні кроки для усунення неполадок:

  1. Коли робоче навантаження не запускається, як очікувалося, пройдіть ланцюжком від Job до Podʼів і до ResourceClaims та перевірте обʼєкти на кожному рівні за допомогою kubectl describe, щоб дізнатися, чи є якісь поля статусу або події, які можуть пояснити, чому робоче навантаження не запускається.
  2. Коли створення Podʼа не вдається з must specify one of: resourceClaimName, resourceClaimTemplateName, перевірте, що всі записи в pod.spec.resourceClaims мають точно одне з цих полів. Якщо так, то можливо, що в кластері встановлено модифікуючий вебхук Podʼа, який був створений для API Kubernetes < 1.32. Попросіть адміністратора кластера перевірити це.

Очищення

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

  1. Видаліть приклад Job:

    kubectl delete -f https://k8s.io/examples/dra/dra-example-job.yaml
    
  2. Щоб видалити свої заявки на ресурси, виконайте одну з наступних команд:

    • Видаліть ResourceClaimTemplate:

      kubectl delete -f https://k8s.io/examples/dra/resourceclaimtemplate.yaml
      
    • Видаліть ResourceClaim:

      kubectl delete -f https://k8s.io/examples/dra/resourceclaim.yaml
      

Що далі

3.1.3 - Доступ до метаданих пристроїв DRA

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

Ця сторінка показує, як отримати доступ до метаданих пристроїв з контейнерів, які використовують динамічне виділення ресурсів (DRA). Метадані пристроїв дозволяють робочим навантаженням дізнаватися інформацію про виділені пристрої, таку як атрибути пристроїв або деталі мережевого інтерфейсу, шляхом читання JSON-файлів за відомими шляхами всередині контейнера.

Перш ніж читати цю сторінку, ознайомтеся з динамічним виділенням ресурсів (DRA) та з тим, як виділяти пристрої для робочих навантажень.

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

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

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

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

  • Переконайтесь, що адміністратор вашого кластера налаштував DRA, підключив пристрої та встановив драйвери. Для отримання додаткової інформації дивіться Налаштування DRA в кластері.
  • Переконайтесь, що драйвер DRA, розгорнутий у вашому кластері, підтримує метадані пристроїв. Автори драйверів, які використовують втулок kubelet DRA, вмикають підтримку за допомогою EnableDeviceMetadata та повинні включити metadata.resource.k8s.io/v1beta1 у вибрані версії. Драйвер також може видавати v1alpha1 для сумісності зі старішими споживачами.

Доступ до метаданих пристроїв за допомогою ResourceClaim

Коли ви використовуєте безпосередньо вказаний ResourceClaim для виділення пристроїв, файли метаданих пристроїв зʼявляються всередині контейнера за шляхом:

/var/run/kubernetes.io/dra-device-attributes/resourceclaims/<claimName>/<requestName>/<driverName>-metadata.json
  1. Перегляньте наступний приклад маніфесту:

    apiVersion: resource.k8s.io/v1
    kind: ResourceClaim
    metadata:
      name: gpu-claim
    spec:
      devices:
        requests:
        - name: gpu
          exactly:
            deviceClassName: gpu.example.com
    ---
    apiVersion: v1
    kind: Pod
    metadata:
      name: gpu-metadata-reader
    spec:
      resourceClaims:
      - name: my-gpu
        resourceClaimName: gpu-claim
      containers:
      - name: workload
        image: ubuntu:24.04
        resources:
          claims:
          - name: my-gpu
            request: gpu
        command:
        - sh
        - -c
        - |
          echo "=== DRA device metadata ==="
          find /var/run/kubernetes.io/dra-device-attributes -name '*-metadata.json' -print -exec cat {} \;
          sleep 3600
      restartPolicy: Never
    

    Цей маніфест створює ResourceClaim з назвою gpu-claim, який запитує пристрій з DeviceClass gpu.example.com, та Pod, який читає метадані пристрою.

  2. Створіть ResourceClaim та Pod:

    kubectl apply -f https://k8s.io/examples/dra/dra-device-metadata-pod.yaml
    
  3. Коли Pod запрацює, перегляньте логи контейнера, щоб побачити метадані:

    kubectl logs gpu-metadata-reader
    

    Вивід буде схожий на:

    === DRA device metadata ===
    /var/run/kubernetes.io/dra-device-attributes/resourceclaims/gpu-claim/gpu/gpu.example.com-metadata.json
    {
      "kind": "DeviceMetadata",
      "apiVersion": "metadata.resource.k8s.io/v1beta1",
      ...
    }
    
  4. Щоб переглянути повний файл метаданих, виконайте команду всередині контейнера:

    kubectl exec gpu-metadata-reader -- \
      cat /var/run/kubernetes.io/dra-device-attributes/resourceclaims/gpu-claim/gpu/gpu.example.com-metadata.json
    

    Файл метаданих — це JSON-потік. Він містить один обʼєкт для кожної версії API, вибраної драйвером, у порядку, налаштованому драйвером. Драйвери повинні розміщувати найновішу версію першою. Обʼєкти містять еквівалентні метадані пристрою, тому команда може вивести більше ніж один JSON-обʼєкт.

    Вивід містить атрибути пристрою, такі як модель, версія драйвера та UUID пристрою. Ємності пристроїв не є частиною схеми метаданих. Дивіться схему метаданих для деталей структури JSON.

Доступ до метаданих пристроїв за допомогою ResourceClaimTemplate

Коли ви використовуєте ResourceClaimTemplate, Kubernetes генерує ResourceClaim для кожного Podʼа. Оскільки згенерована назва заявки непередбачувана, файли метаданих натомість зʼявляються за шляхом, який використовує імʼя посилання на заявку в Podʼі:

/var/run/kubernetes.io/dra-device-attributes/resourceclaimtemplates/<podClaimName>/<requestName>/<driverName>-metadata.json

<podClaimName> відповідає полю name у записі spec.resourceClaims[] Podʼа. JSON-метадані також включають поле podClaimName, яке фіксує це зіставлення.

  1. Перегляньте наступний приклад маніфесту:

    apiVersion: resource.k8s.io/v1
    kind: ResourceClaimTemplate
    metadata:
      name: gpu-claim-template
    spec:
      spec:
        devices:
          requests:
          - name: gpu
            exactly:
              deviceClassName: gpu.example.com
    ---
    apiVersion: v1
    kind: Pod
    metadata:
      name: gpu-metadata-template-reader
    spec:
      resourceClaims:
      - name: my-gpu
        resourceClaimTemplateName: gpu-claim-template
      containers:
      - name: workload
        image: ubuntu:24.04
        resources:
          claims:
          - name: my-gpu
            request: gpu
        command:
        - sh
        - -c
        - |
          echo "=== DRA device metadata (from template) ==="
          find /var/run/kubernetes.io/dra-device-attributes -name '*-metadata.json' -print -exec cat {} \;
          sleep 3600
      restartPolicy: Never
    

    Цей маніфест створює ResourceClaimTemplate та Pod. Кожен Pod отримує власний згенерований ResourceClaim. Шлях до метаданих використовує імʼя посилання на заявку в Podʼі — my-gpu.

  2. Створіть ResourceClaimTemplate та Pod:

    kubectl apply -f https://k8s.io/examples/dra/dra-device-metadata-template-pod.yaml
    
  3. Коли Pod запрацює, перегляньте метадані:

    kubectl exec gpu-metadata-template-reader -- \
      cat /var/run/kubernetes.io/dra-device-attributes/resourceclaimtemplates/my-gpu/gpu/gpu.example.com-metadata.json
    

Читання метаданих у вашому застосунку

Застосунки на Go

Пакунок k8s.io/dynamic-resource-allocation/devicemetadata надає готові функції для читання файлів метаданих. Ці функції автоматично обробляють узгодження версій, декодують потік метаданих і перетворюють його на внутрішні типи, щоб ваш код працював з різними версіями схеми без ручної перевірки версій. Вони пропускають обʼєкти з невідомими версіями API та повертають перший сумісний обʼєкт.

Для безпосередньо вказаного ResourceClaim:

import "k8s.io/dynamic-resource-allocation/devicemetadata"

dm, err := devicemetadata.ReadResourceClaimMetadata("gpu-claim", "gpu")

Для заявки, створеної з шаблону (з використанням імені посилання на заявку в Podʼі):

dm, err := devicemetadata.ReadResourceClaimTemplateMetadata("my-gpu", "gpu")

Якщо ви знаєте конкретне імʼя драйвера, ви можете прочитати файл метаданих одного драйвера:

dm, err := devicemetadata.ReadResourceClaimMetadataWithDriverName("gpu.example.com", "gpu-claim", "gpu")

Функції, які читають усі драйвери, повертають *metadata.DeviceMetadata з обʼєднаними запитами та атрибутами кожного пристрою. Функції, які приймають імʼя драйвера, повертають повний обʼєкт метаданих із файлу цього драйвера.

Допоміжні функції читання декодують метадані без перевірки. Щоб увімкнути перевірку, відкрийте файл і використайте DecodeMetadataFromStream:

import (
	"encoding/json"
	"os"

	"k8s.io/dynamic-resource-allocation/api/metadata"
	"k8s.io/dynamic-resource-allocation/devicemetadata"
)

func readMetadata(path string) (*metadata.DeviceMetadata, error) {
	file, err := os.Open(path)
	if err != nil {
		return nil, err
	}
	defer file.Close()

	var deviceMetadata metadata.DeviceMetadata
	var validationErr error
	err = devicemetadata.DecodeMetadataFromStream(
		json.NewDecoder(file),
		&deviceMetadata,
		devicemetadata.DecodeMetadataWithValidationResult(&validationErr),
	)
	if err != nil {
		return nil, err
	}
	if validationErr != nil {
		return nil, validationErr
	}
	return &deviceMetadata, nil
}

Декодування та перевірка мають окремі результати. Помилка перевірки не заважає декодеру заповнювати deviceMetadata. Перевірка корисна, коли метадані надходять від власного драйвера, оскільки втулок kubelet DRA не перевіряє обʼєкти перед їх записом.

Застосунки іншими мовами можуть декодувати JSON-потік по одному обʼєкту за раз, перевіряти кожен apiVersion, пропускати невідомі версії та використовувати першу версію, яку вони підтримують.

Очищення

Видаліть створені ресурси:

kubectl delete -f https://k8s.io/examples/dra/dra-device-metadata-pod.yaml
kubectl delete -f https://k8s.io/examples/dra/dra-device-metadata-template-pod.yaml

Що далі

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.

See Enable Or Disable Feature Gates for more information.

Ця сторінка показує, як встановити біти прав доступу Unix на теці тому emptyDir за допомогою поля mode.

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

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

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

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

Вам потрібно, щоб функціональна можливість EmptyDirVolumeMode була увімкнена на API-сервері та на kubelet.

Створення Podʼа, який використовує том emptyDir з власними правами доступу

Поле emptyDir.mode дозволяє встановити біти прав доступу Unix (від 0000 до 01777 у вісімковій системі) на теці тому. Якщо не вказано, тека створюється зі стандартними правами 0777.

Наприклад, щоб створити спільну теку /tmp зі встановленим sticky bit, щоб лише власники файлів могли видаляти свої файли:

apiVersion: v1
kind: Pod
metadata:
  name: emptydir-mode-demo
spec:
  containers:
  - image: registry.k8s.io/busybox
    name: test-container
    command: ["sleep", "3600"]
    volumeMounts:
    - mountPath: /tmp
      name: tmp-volume
  volumes:
  - name: tmp-volume
    emptyDir:
      mode: 01777
  1. Створіть Pod у вашому кластері:

    kubectl apply -f https://k8s.io/examples/pods/emptydir-volume-mode.yaml
    
  2. Перевірте, що Pod працює:

    kubectl get pod emptydir-mode-demo
    
  3. Перевірте права доступу на змонтованому томі:

    kubectl exec emptydir-mode-demo -- ls -ld /tmp
    

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

    drwxrwxrwt 2 root root 4096 Jul 28 00:00 /tmp
    

    t наприкінці підтверджує, що sticky bit встановлено.

  4. Видаліть Pod, який ви створили для цієї вправи:

    kubectl delete pod emptydir-mode-demo
    

Що далі

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/v1
kind: AdmissionConfiguration
plugins:
- name: PodSecurity
  configuration:
    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.

Також існують багато каналів, специфічних для країн / мов. Запрошуємо приєднатися до цих каналів для локалізованої підтримки та інформації:

Канали Slack для окремих країн і мов
КраїнаКанали
Китай#cn-users, #cn-events
Фінляндія#fi-users
Франція#fr-users, #fr-events
Німеччина#de-users, #de-events
Індія#in-users, #in-events
Італія#it-users, #it-events
Японія#jp-users, #jp-events
Корея#kr-users
Нідерланди#nl-users
Норвегія#norw-users
Польща#pl-users
Росія#ru-users
Іспанія#es-users
Швеція#se-users
Туреччина#tr-users, #tr-events

Форум

Вас раді бачити на офіційному форумі Kubernetes: discuss.kubernetes.io.

Помилки та запити на нові можливості

Якщо ви натрапили на щось схоже на помилку або хочете запросити нову можливість, скористайтеся системою відстеження issue на GitHub.

Перш ніж створювати issue, пошукайте серед наявних issue, чи вашу проблему вже описано.

Якщо ви повідомляєте про помилку, додайте докладну інформацію про те, як відтворити проблему, наприклад:

  • Версія Kubernetes: kubectl version
  • Хмарний провайдер, дистрибутив ОС, конфігурація мережі та версія середовища виконання контейнерів
  • Кроки для відтворення проблеми

4.1 - Логи в Kubernetes

Архітектура логування та системні логи.

На цій сторінці наведено ресурси про логування в Kubernetes. Ви можете дізнатися, як збирати, переглядати й аналізувати логи за допомогою вбудованих інструментів і популярних стеків логування:

4.2 - Моніторинг в Kubernetes

Моніторинг системних компонентів Kubernetes.

На цій сторінці наведено ресурси про моніторинг у Kubernetes. Ви можете дізнатися, як збирати системні метрики й трасування для системних компонентів Kubernetes:

4.3 - Усунення несправностей застосунків

Налагодження поширених проблем контейнеризованих застосунків.

Цей розділ містить набір ресурсів для виправлення проблем із контейнеризованими застосунками. Він охоплює поширені проблеми з ресурсами Kubernetes (як-от Pods, Services або StatefulSets), поради щодо розуміння повідомлень про завершення контейнерів і способи налагодження запущених контейнерів.

4.3.1 - Налагодження Podʼів

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

Діагностика проблеми

Перший крок в усуненні несправностей — первинна оцінка. У чому проблема? У ваших Podʼах, ReplicationController чи Service?

Налагодження Podʼів

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

Якщо ваш 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: nginx
    type: frontend

Можна використати:

kubectl get pods --selector=name=nginx,type=frontend

щоб вивести перелік Podʼів, які відповідають цьому селектору. Перевірте, чи список збігається з Podʼами, які мають обслуговувати ваш Service. Перевірте, чи containerPort Podʼа збігається з targetPort Service.

Мережевий трафік не пересилається

Докладніше дивіться налагодження Service.

Що далі

Якщо жоден із наведених вище кроків не розвʼязав вашої проблеми, виконайте інструкції з документа про налагодження Service, щоб переконатися, що ваш Service працює, має Endpoints, а ваші Podʼи справді обслуговують запити; що DNS працює, правила iptables встановлено, а kube-proxy поводиться правильно.

Докладніше також дивіться документ про усунення несправностей.

4.3.2 - Налагодження StatefulSet

Це завдання показує, як налагоджувати 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ʼів.

Що далі

Дізнайтеся більше про налагодження init-контейнера.

4.3.3 - Налагодження запущених Podʼів

Ця сторінка пояснює, як налагоджувати Podʼи, що працюють (або аварійно завершуються) на вузлі.

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

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

Використання kubectl describe pod для отримання деталей про Podʼи

У цьому прикладі ми використаємо Deployment для створення двох Podʼів, подібно до попереднього прикладу.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  selector:
    matchLabels:
      app: nginx
  replicas: 2
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx
        resources:
          limits:
            memory: "128Mi"
            cpu: "500m"
        ports:
        - containerPort: 80

Створіть Deployment такою командою:

kubectl apply -f https://k8s.io/examples/application/nginx-with-request.yaml
deployment.apps/nginx-deployment created

Перевірте статус Podʼів такою командою:

kubectl get pods
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
apiVersion: v1
kind: Pod
metadata:
  creationTimestamp: "2022-02-17T21:51:01Z"
  generateName: nginx-deployment-67d4bdd6f5-
  labels:
    app: nginx
    pod-template-hash: 67d4bdd6f5
  name: nginx-deployment-67d4bdd6f5-w6kd7
  namespace: default
  ownerReferences:
  - apiVersion: apps/v1
    blockOwnerDeletion: true
    controller: true
    kind: ReplicaSet
    name: nginx-deployment-67d4bdd6f5
    uid: 7d41dfd4-84c0-4be4-88ab-cedbe626ad82
  resourceVersion: "1364"
  uid: a6501da1-0447-4262-98eb-c03d4002222e
spec:
  containers:
  - image: nginx
    imagePullPolicy: Always
    name: nginx
    ports:
    - containerPort: 80
      protocol: TCP
    resources:
      limits:
        cpu: 500m
        memory: 128Mi
      requests:
        cpu: 500m
        memory: 128Mi
    terminationMessagePath: /dev/termination-log
    terminationMessagePolicy: File
    volumeMounts:
    - mountPath: /var/run/secrets/kubernetes.io/serviceaccount
      name: kube-api-access-bgsgp
      readOnly: true
  dnsPolicy: ClusterFirst
  enableServiceLinks: true
  nodeName: kube-worker-1
  preemptionPolicy: PreemptLowerPriority
  priority: 0
  restartPolicy: Always
  schedulerName: default-scheduler
  securityContext: {}
  serviceAccount: default
  serviceAccountName: default
  terminationGracePeriodSeconds: 30
  tolerations:
  - effect: NoExecute
    key: node.kubernetes.io/not-ready
    operator: Exists
    tolerationSeconds: 300
  - effect: NoExecute
    key: node.kubernetes.io/unreachable
    operator: Exists
    tolerationSeconds: 300
  volumes:
  - name: kube-api-access-bgsgp
    projected:
      defaultMode: 420
      sources:
      - serviceAccountToken:
          expirationSeconds: 3607
          path: token
      - configMap:
          items:
          - key: ca.crt
            path: ca.crt
          name: kube-root-ca.crt
      - downwardAPI:
          items:
          - fieldRef:
              apiVersion: v1
              fieldPath: metadata.namespace
            path: namespace
status:
  conditions:
  - lastProbeTime: null
    lastTransitionTime: "2022-02-17T21:51:01Z"
    status: "True"
    type: Initialized
  - lastProbeTime: null
    lastTransitionTime: "2022-02-17T21:51:06Z"
    status: "True"
    type: Ready
  - lastProbeTime: null
    lastTransitionTime: "2022-02-17T21:51:06Z"
    status: "True"
    type: ContainersReady
  - lastProbeTime: null
    lastTransitionTime: "2022-02-17T21:51:01Z"
    status: "True"
    type: PodScheduled
  containerStatuses:
  - containerID: containerd://5403af59a2b46ee5a23fb0ae4b1e077f7ca5c5fb7af16e1ab21c00e0e616462a
    image: docker.io/library/nginx:latest
    imageID: docker.io/library/nginx@sha256:2834dc507516af02784808c5f48b7cbe38b8ed5d0f4837f16e78d00deb7e7767
    lastState: {}
    name: nginx
    ready: true
    restartCount: 0
    started: true
    state:
      running:
        startedAt: "2022-02-17T21:51:05Z"
  hostIP: 192.168.0.113
  phase: Running
  podIP: 10.88.0.3
  podIPs:
  - ip: 10.88.0.3
  - ip: 2001:db8::1
  qosClass: Guaranteed
  startTime: "2022-02-17T21:51:01Z"

Перегляд логів Podʼа

Спочатку перегляньте логи ураженого контейнера:

kubectl logs ${POD_NAME} -c ${CONTAINER_NAME}

Якщо ваш контейнер раніше аварійно завершився, лог аварійного завершення попереднього контейнера можна переглянути так:

kubectl logs ${POD_NAME} -c ${CONTAINER_NAME} --previous

Налагодження за допомогою виконання команд у контейнері

Якщо образ контейнера містить утиліти для налагодження, як-от образи, зібрані на основі базових образів ОС Linux і Windows, можна виконувати команди в конкретному контейнері за допомогою kubectl exec:

kubectl exec ${POD_NAME} -c ${CONTAINER_NAME} -- ${CMD} ${ARG1} ${ARG2} ... ${ARGN}

Примітка:

-c ${CONTAINER_NAME} є необовʼязковим. Ви можете опустити його для Podʼів, які містять лише один контейнер.

Наприклад, щоб переглянути логи запущеного Podʼа Cassandra, можна виконати

kubectl exec cassandra -- cat /var/log/cassandra/system.log

Можна запустити оболонку, підʼєднану до вашого термінала, за допомогою аргументів -i і -t команди kubectl exec, наприклад:

kubectl exec -it cassandra -- sh

Докладніше дивіться Отримання доступу до оболонки запущеного контейнера.

Налагодження за допомогою ефемерного контейнера налагодження

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

Ефемерні контейнери корисні для інтерактивного усунення несправностей, коли kubectl exec недостатньо, тому що контейнер аварійно завершився або образ контейнера не містить утиліт налагодження, як, наприклад, образи distroless.

Дозволи для ефемерних контейнерів

З міркувань безпеки для додавання ефемерного контейнера до запущеного Podʼа використовується підресурс ephemeralcontainers цього Podʼа. На рівні API це запит update до pods/ephemeralcontainers. Самого лише дозволу на patch Podʼа недостатньо, щоб користувачі могли додавати до нього ефемерні контейнери.

Підресурс pods/ephemeralcontainers навмисно не входить до стандартних ClusterRole для користувачів admin і edit. Чому так, дивіться в розділі Ефемерні контейнери: контроль доступу.

Якщо запустити 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:

apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: aggregate-ephemeralcontainers-edit
  labels:
    rbac.authorization.k8s.io/aggregate-to-edit: "true"
rules:
- apiGroups: [""]
  resources: ["pods/ephemeralcontainers"]
  verbs: ["patch", "update"]

Щоб надати дозвіл лише певним користувачам або групам (наприклад, окремій групі для налагодження або SRE), створіть вужчу ClusterRole і привʼяжіть її безпосередньо:

apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: debug-ephemeralcontainers
rules:
- apiGroups: [""]
  resources: ["pods/ephemeralcontainers"]
  verbs: ["patch", "update"]

Примітка:

Ефемерні контейнери перевіряються механізмом 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 автоматично підʼєднається до консолі ефемерного контейнера.

kubectl debug -it ephemeral-demo --image=busybox:1.28 --target=ephemeral-demo
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:

kubectl describe pod ephemeral-demo
...
Ephemeral Containers:
  debugger-8xzrl:
    Container ID:   docker://b888f9adfd15bd5739fefaa39e1df4dd3c617b9902082b1cfdc29c4028ffb2eb
    Image:          busybox
    Image ID:       docker-pullable://busybox@sha256:1828edd60c5efd34b2bf5dd3282ec0cc04d47b2ff9caa0b6d4f07a21d1c08084
    Port:           <none>
    Host Port:      <none>
    State:          Running
      Started:      Wed, 12 Feb 2020 14:25:42 +0100
    Ready:          False
    Restart Count:  0
    Environment:    <none>
    Mounts:         <none>
...

Коли закінчите, видаліть 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 для налагодження:

kubectl debug myapp -it --image=ubuntu --share-processes --copy-to=myapp-debug
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.
  • --share-processes дозволяє контейнерам у цьому Podʼі бачити процеси інших контейнерів Podʼа. Докладніше про те, як це працює, дивіться Спільний простір імен процесів для контейнерів у Podʼі.

Не забудьте прибрати Pod для налагодження, коли ви закінчите:

kubectl delete pod myapp myapp-debug

Копіювання Podʼа зі зміною його команди

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

Щоб симулювати аварійне завершення застосунку, використайте kubectl run, щоб створити контейнер, який негайно завершується:

kubectl run --image=busybox:1.28 myapp -- false

Ви можете побачити за допомогою kubectl describe pod myapp, що цей контейнер аварійно завершується:

Containers:
  myapp:
    Image:         busybox
    ...
    Args:
      false
    State:          Waiting
      Reason:       CrashLoopBackOff
    Last State:     Terminated
      Reason:       Error
      Exit Code:    1

Можна за допомогою 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:

kubectl debug myapp --copy-to=myapp-debug --set-image=*=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:

kubectl debug --profile=sysadmin node/${NODE_NAME} -it --image=ubuntu:latest

Після входу в контейнер налагодження встановіть tcpdump і захопіть трафік на мережевих інтерфейсах вузла:

apt-get update && apt-get install -y tcpdump
tcpdump -i any -n

Примітка:

Не забудьте прибрати Pod для налагодження, коли ви закінчите з ним:

kubectl delete pod node-debugger-mynode-pdx84

Ви також можете захоплювати трафік з конкретного Podʼа:

kubectl debug --profile=sysadmin pod/${POD_NAME} -n ${NAMESPACE} -it --image=ubuntu:latest

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

Налагодження Podʼа або вузла із застосуванням профілю

Коли ви використовуєте kubectl debug для налагодження вузла через Pod налагодження, Podʼа через ефемерний контейнер або скопійованого Podʼа, до них можна застосувати профіль. Застосування профілю встановлює певні властивості, такі як securityContext, що дає змогу пристосуватися до різних сценаріїв. Є два типи профілів: static і custom.

Застосування профілю static

Профіль static — це набір наперед визначених властивостей, які можна застосувати за допомогою прапорця --profile. Доступні такі профілі:

ПрофільОпис
legacyНабір властивостей для зворотної сумісності з поведінкою 1.22
generalОбґрунтований набір загальних властивостей для будь-якого налагодження
baselineНабір властивостей, сумісних з політикою baseline PodSecurityStandard
restrictedНабір властивостей, сумісних з політикою restricted PodSecurityStandard
netadminНабір властивостей, включаючи привілеї адміністратора мережі
sysadminНабір властивостей, включаючи привілеї системного адміністратора (root)

Примітка:

Якщо ви не вкажете --profile, стандартно використовується профіль legacy, але його планується найближчим часом визнати застарілим. Тому рекомендується використовувати інші профілі, такі як general.

Припустимо, що ви створюєте Pod і налагоджуєте його. Спочатку створіть Pod з назвою myapp, наприклад:

kubectl run myapp --image=busybox:1.28 --restart=Never -- sleep 1d

Потім налагодьте Pod за допомогою ефемерного контейнера. Якщо ефемерному контейнеру потрібні привілеї, можна використати профіль sysadmin:

kubectl debug -it myapp --image=busybox:1.28 --target=myapp --profile=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.
/ #

Перевірте можливості процесу ефемерного контейнера, виконавши таку команду в контейнері:

/ # grep Cap /proc/$$/status
...
CapPrm:	000001ffffffffff
CapEff:	000001ffffffffff
...

Це означає, що завдяки профілю 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:

env:
- name: ENV_VAR_1
  value: value_1
- name: ENV_VAR_2
  value: value_2
securityContext:
  capabilities:
    add:
    - NET_ADMIN
    - SYS_TIME

Виконайте цю команду, щоб налагодити Pod за допомогою ефемерного контейнера з профілем custom:

kubectl debug -it myapp --image=busybox:1.28 --target=myapp --profile=general --custom=custom-profile.yaml

Можна перевірити, що ефемерний контейнер додано до цільового Podʼа із застосованим профілем custom:

kubectl get pod myapp -o jsonpath='{.spec.ephemeralContainers[0].env}'
[{"name":"ENV_VAR_1","value":"value_1"},{"name":"ENV_VAR_2","value":"value_2"}]
kubectl get pod myapp -o jsonpath='{.spec.ephemeralContainers[0].securityContext}'
{"capabilities":{"add":["NET_ADMIN","SYS_TIME"]}}

Закінчивши роботу, приберіть Pod:

kubectl delete pod myapp

4.4 - Усунення несправностей кластерів

Налагодження поширених проблем кластера.

Цей документ присвячено усуненню несправностей кластера; ми припускаємо, що ви вже виключили свій застосунок як першопричину проблеми, з якою стикаєтеся. Поради щодо налагодження застосунків дивіться в посібнику з усунення несправностей застосунків. Докладніше також дивіться загальний документ з усунення несправностей.

Про усунення несправностей kubectl дивіться Усунення несправностей kubectl.

Виведення інформації про кластер

Перше, що слід перевірити під час налагодження кластера, — чи всі ваші вузли зареєстровано правильно.

Виконайте таку команду:

kubectl get nodes

І переконайтеся, що всі очікувані вузли присутні й перебувають у стані Ready.

Щоб отримати детальну інформацію про загальний стан вашого кластера, ви можете виконати:

kubectl cluster-info dump

Приклад: налагодження вимкненого/недоступного вузла

Іноді під час налагодження корисно переглянути стан вузла — наприклад, тому що ви помітили дивну поведінку 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: v1
kind: Node
metadata:
  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: amd64
    beta.kubernetes.io/os: linux
    kubernetes.io/arch: amd64
    kubernetes.io/hostname: kube-worker-1
    kubernetes.io/os: linux
  name: kube-worker-1
  resourceVersion: "4026"
  uid: 98efe7cb-2978-4a0b-842a-1a7bf12c05f8
spec: {}
status:
  addresses:
  - address: 192.168.0.113
    type: InternalIP
  - address: kube-worker-1
    type: Hostname
  allocatable:
    cpu: "2"
    ephemeral-storage: "14167048988"
    hugepages-2Mi: "0"
    memory: 1922788Ki
    pods: "110"
  capacity:
    cpu: "2"
    ephemeral-storage: 15372232Ki
    hugepages-2Mi: "0"
    memory: 2025188Ki
    pods: "110"
  conditions:
  - lastHeartbeatTime: "2022-02-17T22:20:32Z"
    lastTransitionTime: "2022-02-17T22:20:32Z"
    message: Weave pod has set this
    reason: WeaveIsUp
    status: "False"
    type: NetworkUnavailable
  - lastHeartbeatTime: "2022-02-17T22:20:15Z"
    lastTransitionTime: "2022-02-17T22:13:25Z"
    message: kubelet has sufficient memory available
    reason: KubeletHasSufficientMemory
    status: "False"
    type: MemoryPressure
  - lastHeartbeatTime: "2022-02-17T22:20:15Z"
    lastTransitionTime: "2022-02-17T22:13:25Z"
    message: kubelet has no disk pressure
    reason: KubeletHasNoDiskPressure
    status: "False"
    type: DiskPressure
  - lastHeartbeatTime: "2022-02-17T22:20:15Z"
    lastTransitionTime: "2022-02-17T22:13:25Z"
    message: kubelet has sufficient PID available
    reason: KubeletHasSufficientPID
    status: "False"
    type: PIDPressure
  - lastHeartbeatTime: "2022-02-17T22:20:15Z"
    lastTransitionTime: "2022-02-17T22:15:15Z"
    message: kubelet is posting ready status
    reason: KubeletReady
    status: "True"
    type: Ready
  daemonEndpoints:
    kubeletEndpoint:
      Port: 10250
  nodeInfo:
    architecture: amd64
    bootID: 22333234-7a6b-44d4-9ce1-67e31dc7e369
    containerRuntimeVersion: containerd://1.5.9
    kernelVersion: 5.13.0-28-generic
    kubeProxyVersion: v1.23.3
    kubeletVersion: v1.23.3
    machineID: 9384e2927f544209b5d7b67474bbf92b
    operatingSystem: linux
    osImage: Ubuntu 21.10
    systemUUID: 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
  • Дія: використовуйте конфігурацію з високою доступністю

    • Помʼякшує: вимкнення вузла панелі управління або збої компонентів панелі управління (планувальник, API-сервер, controller-manager)
      • Витримує одну або кілька одночасних відмов вузлів чи компонентів
    • Помʼякшує: втрату сховища, що лежить в основі API-сервера (тобто теки даних etcd)
      • Передбачає конфігурацію etcd з високою доступністю (HA)
  • Дія: регулярно створюйте знімки томів PD/EBS apiserver

    • Помʼякшує: втрату сховища, що лежить в основі apiserver
    • Помʼякшує: деякі випадки помилок оператора
    • Помʼякшує: деякі випадки збоїв програмного забезпечення Kubernetes
  • Дія: використовуйте ReplicationController і Service перед Podʼами

    • Помʼякшує: вимкнення вузла
    • Помʼякшує: збій програмного забезпечення kubelet
  • Дія: застосунки (контейнери), спроєктовані так, щоб витримувати неочікувані перезапуски

    • Помʼякшує: вимкнення вузла
    • Помʼякшує: збій програмного забезпечення kubelet

Що далі

4.4.1 - Конвеєр метрик ресурсів

Для 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.

Схема 1 ілюструє архітектуру конвеєра метрик ресурсів.

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 '.'

Той самий виклик API за допомогою curl:

curl http://localhost:8080/apis/metrics.k8s.io/v1/nodes/minikube

Приклад відповіді:

{
  "kind": "NodeMetrics",
  "apiVersion": "metrics.k8s.io/v1",
  "metadata": {
    "name": "minikube",
    "selfLink": "/apis/metrics.k8s.io/v1/nodes/minikube",
    "creationTimestamp": "2022-01-27T18:48:43Z"
  },
  "timestamp": "2022-01-27T18:48:33Z",
  "window": "30s",
  "usage": {
    "cpu": "487558164n",
    "memory": "732212Ki"
  }
}

Ось приклад запиту до Metrics API для Podʼа kube-scheduler-minikube у просторі імен kube-system, обробленого через jq для зручного перегляду:

kubectl get --raw "/apis/metrics.k8s.io/v1/namespaces/kube-system/pods/kube-scheduler-minikube" | jq '.'

Той самий виклик API за допомогою curl:

curl http://localhost:8080/apis/metrics.k8s.io/v1/namespaces/kube-system/pods/kube-scheduler-minikube

Приклад відповіді:

{
  "kind": "PodMetrics",
  "apiVersion": "metrics.k8s.io/v1",
  "metadata": {
    "name": "kube-scheduler-minikube",
    "namespace": "kube-system",
    "selfLink": "/apis/metrics.k8s.io/v1/namespaces/kube-system/pods/kube-scheduler-minikube",
    "creationTimestamp": "2022-01-27T19:25:00Z"
  },
  "timestamp": "2022-01-27T19:24:31Z",
  "window": "30s",
  "containers": [
    {
      "name": "kube-scheduler",
      "usage": {
        "cpu": "9559630n",
        "memory": "22244Ki"
      }
    }
  ]
}

Metrics API визначено в репозиторії k8s.io/metrics. Вам потрібно увімкнути шар агрегації API та зареєструвати APIService для API metrics.k8s.io.

Щоб дізнатися більше про Metrics API, дивіться дизайн API метрик ресурсів, репозиторій metrics-server і API метрик ресурсів.

Примітка:

Щоб отримати доступ до 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 у старіших версіях

Що далі

Щоб дізнатися більше про metrics-server, перегляньте репозиторій metrics-server.

Також можна переглянути таке:

Щоб дізнатися про те, як kubelet надає метрики вузла, і як ви можете отримати до них доступ через API Kubernetes, прочитайте Дані метрик вузлів.

4.4.2 - Відстеження стану вузлів

Node Problem Detector — це демон для моніторингу стану вузла та звітування про нього. Node Problem Detector можна запустити як DaemonSet або як окремий демон. Node Problem Detector збирає інформацію про проблеми вузла з різних демонів і повідомляє про ці стани API-серверу як стани вузла або як події.

Щоб дізнатися, як встановити й використовувати Node Problem Detector, дивіться документацію проєкту Node Problem Detector.

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

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

Обмеження

Увімкнення Node Problem Detector

Деякі хмарні постачальники вмикають Node Problem Detector як надбудову. Ви також можете увімкнути Node Problem Detector за допомогою kubectl або створивши DaemonSet надбудови.

Використання kubectl для увімкнення Node Problem Detector

kubectl дає найгнучкіше керування Node Problem Detector. Ви можете перезаписати стандартну конфігурацію, щоб пристосувати її до свого середовища або виявляти власні проблеми вузла. Наприклад:

  1. Створіть конфігурацію Node Problem Detector, аналогічну node-problem-detector.yaml:

    apiVersion: apps/v1
    kind: DaemonSet
    metadata:
      name: node-problem-detector-v0.1
      namespace: kube-system
      labels:
        k8s-app: node-problem-detector
        version: v0.1
        kubernetes.io/cluster-service: "true"
    spec:
      selector:
        matchLabels:
          k8s-app: node-problem-detector  
          version: v0.1
          kubernetes.io/cluster-service: "true"
      template:
        metadata:
          labels:
            k8s-app: node-problem-detector
            version: v0.1
            kubernetes.io/cluster-service: "true"
        spec:
          hostNetwork: true
          containers:
          - name: node-problem-detector
            image: registry.k8s.io/node-problem-detector:v0.1
            securityContext:
              privileged: true
            resources:
              limits:
                cpu: "200m"
                memory: "100Mi"
              requests:
                cpu: "20m"
                memory: "20Mi"
            volumeMounts:
            - name: log
              mountPath: /log
              readOnly: true
          volumes:
          - name: log
            hostPath:
              path: /var/log/

    Примітка:

    Перевірте, чи тека системного логу правильна для дистрибутиву вашої операційної системи.
  2. Запустіть Node Problem Detector за допомогою kubectl:

    kubectl apply -f https://k8s.io/examples/debug/node-problem-detector.yaml
    

Використання Podʼа надбудови для увімкнення Node Problem Detector

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

Створіть node-problem-detector.yaml та збережіть конфігурацію в теці Podʼа надбудови /etc/kubernetes/addons/node-problem-detector на вузлі панелі управління.

Перезапис конфігурації

Стандартна конфігурація вбудовується під час збирання Docker-образу Node Problem Detector.

Однак ви можете використовувати ConfigMap для перезапису конфігурації:

  1. Змініть файли конфігурації в config/.

  2. Створіть ConfigMap node-problem-detector-config:

    kubectl create configmap node-problem-detector-config --from-file=config/
    
  3. Змініть node-problem-detector.yaml, щоб використовувати ConfigMap:

    apiVersion: apps/v1
    kind: DaemonSet
    metadata:
      name: node-problem-detector-v0.1
      namespace: kube-system
      labels:
        k8s-app: node-problem-detector
        version: v0.1
        kubernetes.io/cluster-service: "true"
    spec:
      selector:
        matchLabels:
          k8s-app: node-problem-detector  
          version: v0.1
          kubernetes.io/cluster-service: "true"
      template:
        metadata:
          labels:
            k8s-app: node-problem-detector
            version: v0.1
            kubernetes.io/cluster-service: "true"
        spec:
          hostNetwork: true
          containers:
          - name: node-problem-detector
            image: registry.k8s.io/node-problem-detector:v0.1
            securityContext:
              privileged: true
            resources:
              limits:
                cpu: "200m"
                memory: "100Mi"
              requests:
                cpu: "20m"
                memory: "20Mi"
            volumeMounts:
            - name: log
              mountPath: /log
              readOnly: true
            - name: config # Overwrite the config/ directory with ConfigMap volume
              mountPath: /config
              readOnly: true
          volumes:
          - name: log
            hostPath:
              path: /var/log/
          - name: config # Define ConfigMap volume
            configMap:
              name: node-problem-detector-config
  4. Перестворіть 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 конфігурація буде схожа на таку:

runtime-endpoint: unix:///var/run/containerd/containerd.sock
image-endpoint: unix:///var/run/containerd/containerd.sock
timeout: 10
debug: true

Щоб дізнатися більше про crictl, зверніться до документації crictl.

Приклади команд crictl

Наведені нижче приклади показують деякі команди 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

Отримання переліку образів

Вивести всі образи:

crictl images

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

IMAGE                                     TAG                 IMAGE ID            SIZE
busybox                                   latest              8c811b4aec35f       1.15MB
k8s-gcrio.azureedge.net/hyperkube-amd64   v1.10.3             e179bbfe5d238       665MB
k8s-gcrio.azureedge.net/pause-amd64       3.1                 da86e6ba6ca19       742kB
nginx                                     latest              cd5239a0906a6       109MB

Вивести образи за репозиторієм:

crictl images nginx

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

IMAGE               TAG                 IMAGE ID            SIZE
nginx               latest              cd5239a0906a6       109MB

Вивести лише ідентифікатори образів:

crictl images -q

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

sha256:8c811b4aec35f259572d0f79207bc0678df4c736eeec50bc9fec37ed936a472a
sha256:e179bbfe5d238de6069f3b03fccbecc3fb4f2019af741bfff1233c4d7b2970c5
sha256:da86e6ba6ca197bf6bc5e9d900febd906b133eaa4750e6bed647b0fbe50ed43e
sha256:cd5239a0906a6ccf0562354852fae04bc5b52d72a2aff9a871ddb6bd57553569

Отримання переліку контейнерів

Вивести всі контейнери:

crictl ps -a

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

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

Виконання команди в запущеному контейнері

crictl exec -i -t 1f73f2d81bf98 ls

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

bin   dev   etc   home  proc  root  sys   tmp   usr   var

Отримання логів контейнера

Отримати всі логи контейнера:

crictl logs 87d3992f84f74

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

10.240.0.96 - - [06/Jun/2018:02:45:49 +0000] "GET / HTTP/1.1" 200 612 "-" "curl/7.47.0" "-"
10.240.0.96 - - [06/Jun/2018:02:45:50 +0000] "GET / HTTP/1.1" 200 612 "-" "curl/7.47.0" "-"
10.240.0.96 - - [06/Jun/2018:02:45:51 +0000] "GET / HTTP/1.1" 200 612 "-" "curl/7.47.0" "-"

Отримати лише останні N рядків логів:

crictl logs --tail=1 87d3992f84f74

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

10.240.0.96 - - [06/Jun/2018:02:45:51 +0000] "GET / HTTP/1.1" 200 612 "-" "curl/7.47.0" "-"

Що далі

4.4.4 - Аудит

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

Аудит дає змогу адміністраторам кластера відповісти на такі запитання:

  • що сталося?
  • коли це сталося?
  • хто це ініціював?
  • з чим це сталося?
  • де це було помічено?
  • звідки це було ініційовано?
  • куди це прямувало?

Записи аудиту починають свій життєвий цикл у компоненті kube-apiserver. Кожен запит на кожному етапі виконання генерує подію аудиту, яку потім попередньо обробляють відповідно до певної політики й записують у бекенд. Політика визначає, що записується, а бекенди зберігають записи. Поточні реалізації бекендів — файли логів і вебхуки.

Кожен запит можна записати з відповідним етапом (stage). Визначено такі етапи:

  • RequestReceived — етап для подій, що генеруються, щойно обробник аудиту отримує запит, і до того, як запит передано далі ланцюжком обробників.
  • ResponseStarted — після надсилання заголовків відповіді, але до надсилання тіла відповіді. Цей етап генерується лише для тривалих запитів (наприклад, watch).
  • ResponseComplete — тіло відповіді завершено, і більше жодних байтів не буде надіслано.
  • Panic — події, що генеруються, коли сталася паніка.

Примітка:

Конфігурація події аудиту відрізняється від обʼєкта API Event.

Можливість логування аудиту збільшує споживання памʼяті 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: RequestResponse
    resources:
    - group: ""
      # Ресурс "pods" не охоплює запити до будь-якого субресурсу Podʼів,
      # що узгоджується з політикою RBAC.
      resources: ["pods"]
  # Логувати "pods/log", "pods/status" на рівні Metadata
  - level: Metadata
    resources:
    - group: ""
      resources: ["pods/log", "pods/status"]

  # Не логувати запити до ConfigMap з назвою "controller-leader"
  - level: None
    resources:
    - group: ""
      resources: ["configmaps"]
      resourceNames: ["controller-leader"]

  # Не логувати watch-запити від "system:kube-proxy" до endpoints або services
  - level: None
    users: ["system:kube-proxy"]
    verbs: ["watch"]
    resources:
    - group: "" # основна група API
      resources: ["endpoints", "services"]

  # Не логувати автентифіковані запити до певних URL-шляхів, що не є ресурсами.
  - level: None
    userGroups: ["system:authenticated"]
    nonResourceURLs:
    - "/api*" # Зіставлення за шаблоном.
    - "/version"

  # Логувати тіло запитів на зміну ConfigMap у kube-system.
  - level: Request
    resources:
    - group: "" # основна група API
      resources: ["configmaps"]
    # Це правило застосовується тільки до ресурсів в просторі імен "kube-system".
    # Порожній рядок "" можна використовувати для вибору ресурсів без простору імен.
    namespaces: ["kube-system"]

  # Логувати зміни ConfigMap і Secret у всіх інших просторах імен на рівні Metadata.
  - level: Metadata
    resources:
    - group: "" # основна група API
      resources: ["secrets", "configmaps"]

  # Логувати всі інші ресурси в групах core та extensions на рівні Request.
  - level: Request
    resources:
    - group: "" # основна група API
    - group: "extensions" # Версію групи НЕ слід вказувати.

  # Загальне правило для логування всіх інших запитів на рівні Metadata.
  - level: Metadata
    # Тривалі запити, як-от watch, що підпадають під це правило,
    # не генерують подію аудиту на етапі RequestReceived.
    omitStages:
      - "RequestReceived"

Можна використати мінімальний файл політики аудиту, щоб записувати всі запити на рівні Metadata:

# Записувати всі запити на рівні Metadata.
apiVersion: audit.k8s.io/v1
kind: Policy
rules:
- level: Metadata

Якщо ви створюєте власний профіль аудиту, за відправну точку можна взяти профіль аудиту для Google Container-Optimized OS. Перегляньте скрипт configure-helper.sh, який генерує файл політики аудиту. Більшу частину файлу політики аудиту можна побачити безпосередньо в скрипті.

Докладніше про визначені поля дивіться в довіднику конфігурації Policy.

Бекенди аудиту

Бекенди аудиту зберігають події аудиту в зовнішньому сховищі. Без додаткових налаштувань 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:

[
  {
    "op": "replace",
    "path": "/spec/parallelism",
    "value": 0
  },
  {
    "op": "remove",
    "path": "/spec/template/spec/containers/0/terminationMessagePolicy"
  }
]

Бекенд логів

Бекенд логів записує події аудиту у файл у форматі JSONlines. Бекенд аудиту логів можна налаштувати за допомогою таких прапорців kube-apiserver:

  • --audit-log-path вказує шлях до файлу логу, який бекенд логів використовує для запису подій аудиту. Якщо цей прапорець не вказано, бекенд логів вимкнено. - означає стандартний вивід
  • --audit-log-maxage визначає максимальну кількість днів для зберігання старих файлів логів аудиту
  • --audit-log-maxbackup визначає максимальну кількість файлів логів аудиту для зберігання
  • --audit-log-maxsize визначає максимальний розмір файлу логу аудиту в мегабайтах, після якого виконується його ротація

Якщо панель управління вашого кластера запускає kube-apiserver як Pod, не забудьте змонтувати hostPath у розташування файлу політики й файлу логів, щоб записи аудиту зберігалися. Наприклад:

  - --audit-policy-file=/etc/kubernetes/audit-policy.yaml
  - --audit-log-path=/var/log/kubernetes/audit/audit.log

потім змонтуйте томи:

...
volumeMounts:
  - mountPath: /etc/kubernetes/audit-policy.yaml
    name: audit
    readOnly: true
  - mountPath: /var/log/kubernetes/audit/
    name: audit-log
    readOnly: false

і нарешті налаштуйте hostPath:

...
volumes:
- name: audit
  hostPath:
    path: /etc/kubernetes/audit-policy.yaml
    type: File

- name: audit-log
  hostPath:
    path: /var/log/kubernetes/audit/
    type: DirectoryOrCreate

Бекенд Webhook

Бекенд аудиту 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.

Що далі

4.4.5 - Розробка та налагодження сервісів локально за допомогою telepresence

Примітка: Цей розділ містить посилання на проєкти сторонніх розробників, які надають функціонал, необхідний для Kubernetes. Автори проєкту Kubernetes не несуть відповідальності за ці проєкти. Проєкти вказано в алфавітному порядку. Щоб додати проєкт до цього списку, ознайомтеся з посібником з контенту перед надсиланням змін. Докладніше.

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

telepresence — це інструмент, що спрощує локальну розробку й налагодження сервісів, проксіюючи сервіс до віддаленого кластера Kubernetes. telepresence дає змогу використовувати для локального сервісу власні інструменти, як-от налагоджувач та IDE, і надає сервісу повний доступ до ConfigMap, Secrets і сервісів, що працюють у віддаленому кластері.

У цьому документі описано, як використовувати telepresence для локальної розробки й налагодження сервісів, що працюють у віддаленому кластері.

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

  • Кластер Kubernetes встановлено
  • kubectl налаштовано для звʼязку з кластером
  • 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.

Докладніше дивіться на вебсайті Telepresence.

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 з такою специфікацією:

apiVersion: v1
kind: Pod
metadata:
  name: guaranteed
spec:
  containers:
  - name: guaranteed
    image: consumer
    imagePullPolicy: Never
    resources:
      limits:
        cpu: "2"
        memory: 150Gi
      requests:
        cpu: "2"
        memory: 150Gi
    command: ["sleep","infinity"]

Далі увійдіть на вузол, де його розгорнуто, і перегляньте файл стану в /var/lib/kubelet/memory_manager_state:

{
   "policyName":"Static",
   "machineState":{
      "0":{
         "numberOfAssignments":1,
         "memoryMap":{
            "hugepages-1Gi":{
               "total":0,
               "systemReserved":0,
               "allocatable":0,
               "reserved":0,
               "free":0
            },
            "memory":{
               "total":134987354112,
               "systemReserved":3221225472,
               "allocatable":131766128640,
               "reserved":131766128640,
               "free":0
            }
         },
         "nodes":[
            0,
            1
         ]
      },
      "1":{
         "numberOfAssignments":1,
         "memoryMap":{
            "hugepages-1Gi":{
               "total":0,
               "systemReserved":0,
               "allocatable":0,
               "reserved":0,
               "free":0
            },
            "memory":{
               "total":135286722560,
               "systemReserved":2252341248,
               "allocatable":133034381312,
               "reserved":29295144960,
               "free":103739236352
            }
         },
         "nodes":[
            0,
            1
         ]
      }
   },
   "entries":{
      "fa9bdd38-6df9-4cf9-aa67-8c4814da37a8":{
         "guaranteed":[
            {
               "numaAffinity":[
                  0,
                  1
               ],
               "type":"memory",
               "size":161061273600
            }
         ]
      }
   },
   "checksum":4142013182
}

З файлу стану можна зробити висновок, що 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

Усунення несправностей на рівні вузла

  1. Мої Podʼи застрягли в стані "Container Creating" або постійно перезапускаються

    Переконайтеся, що ваш образ pause сумісний з версією вашої ОС Windows. Дивіться Контейнер pause, щоб дізнатися про найновіший / рекомендований образ pause та/або отримати більше інформації.

    Примітка:

    Якщо ви використовуєте containerd як середовище виконання контейнерів, образ pause вказується в полі plugins.plugins.cri.sandbox_image файлу конфігурації config.toml.
  2. Мої Podʼи показують статус ErrImgPull або ImagePullBackOff

    Переконайтеся, що ваш Pod планується на сумісний вузол Windows.

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

Усунення несправностей мережі

  1. Мої Podʼи Windows не мають мережевого зʼєднання

    Якщо ви використовуєте віртуальні машини, переконайтеся, що MAC spoofing увімкнено на всіх мережевих адаптерах віртуальних машин.

  2. Мої 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" # Підмережа керування (хоста)
                ]
    
  3. Мій вузол Windows не може отримати доступ до Service типу NodePort

    Локальний доступ до NodePort із самого вузла не працює. Це відоме обмеження. Доступ до NodePort працює з інших вузлів або із зовнішніх клієнтів.

  4. vNIC і точки доступу HNS контейнерів видаляються

    Ця проблема може виникати, коли параметр hostname-override не передається до kube-proxy. Щоб її розвʼязати, користувачам потрібно передати kube-proxy імʼя хоста так:

    C:\k\kube-proxy.exe --hostname-override=$(hostname)
    
  5. Мій вузол Windows не може отримати доступ до моїх Service за IP-адресою Service

    Це відоме обмеження мережевого стека Windows. Однак Podʼи Windows можуть звертатися до IP-адреси Service.

  6. Під час запуску kubelet не знайдено мережевого адаптера

    Мережевому стеку Windows потрібен віртуальний адаптер, щоб мережа Kubernetes працювала. Якщо наведені нижче команди не повертають результатів (в оболонці адміністратора), то створення віртуальної мережі — необхідної передумови для роботи kubelet — не вдалося:

    Get-HnsNetwork | ? Name -ieq "cbr0"
    Get-NetAdapter | ? Name -Like "vEthernet (Ethernet*"
    

    Часто варто змінити параметр InterfaceName скрипту start.ps1, якщо мережевий адаптер хоста називається не "Ethernet". Інакше перегляньте вивід скрипту start-kubelet.ps1, щоб зʼясувати, чи були помилки під час створення віртуальної мережі.

  7. DNS-перетворення не працює належним чином

    Перевірте обмеження DNS для Windows у цьому розділі.

  8. 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.

  9. Встановлення Kubernetes завершується невдачею, бо мій вузол Windows Server розташований за проксі

    Якщо ви перебуваєте за проксі, потрібно визначити такі змінні середовища PowerShell:

    [Environment]::SetEnvironmentVariable("HTTP_PROXY", "http://proxy.example.com:80/", [EnvironmentVariableTarget]::Machine)
    [Environment]::SetEnvironmentVariable("HTTPS_PROXY", "http://proxy.example.com:443/", [EnvironmentVariableTarget]::Machine)
    

Усунення несправностей Flannel

  1. З Flannel мої вузли мають проблеми після повторного приєднання до кластера

    Щоразу, коли раніше видалений вузол знову приєднується до кластера, flannelD намагається призначити вузлу нову підмережу Podʼів. Користувачам слід видалити старі файли конфігурації підмережі Podʼів за такими шляхами:

    Remove-Item C:\k\SourceVip.json
    Remove-Item C:\k\SourceVipRequest.json
    
  2. Flanneld зависає на "Waiting for the Network to be created"

    Є чимало повідомлень про цю проблему; найімовірніше, це проблема синхронізації в момент, коли встановлюється IP-адреса керування мережі flannel. Як обхідний шлях, перезапустіть start.ps1 або запустіть його вручну так:

    [Environment]::SetEnvironmentVariable("NODE_NAME", "<Windows_Worker_Hostname>")
    C:\flannel\flanneld.exe --kubeconfig-file=c:\k\config --iface=<Windows_Worker_Node_IP> --ip-masq=1 --kube-subnet-mgr=1
    
  3. Мої 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:

    FLANNEL_NETWORK=10.244.0.0/16
    FLANNEL_SUBNET=10.244.4.1/24
    FLANNEL_MTU=1500
    FLANNEL_IPMASQ=true
    

Подальше дослідження

Якщо ці кроки не розвʼязали вашої проблеми, допомогу із запуском контейнерів Windows на вузлах Windows у Kubernetes можна отримати тут:

5 - Керування обʼєктами Kubernetes

Декларативні та імперативні парадигми взаємодії з API Kubernetes.

5.1 - Декларативне керування обʼєктами Kubernetes за допомогою файлів конфігурації

Обʼєкти Kubernetes можна створювати, оновлювати й видаляти, зберігаючи кілька файлів конфігурації обʼєктів у теці та використовуючи kubectl apply для рекурсивного створення й оновлення цих обʼєктів за потреби. Цей метод зберігає записи, зроблені в живих обʼєктах, без внесення змін назад до файлів конфігурації обʼєктів. kubectl diff також дає змогу попередньо переглянути зміни, які внесе apply.

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

Встановіть kubectl.

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

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

Компроміси

Інструмент kubectl підтримує три види керування обʼєктами:

  • Імперативні команди
  • Імперативне конфігурування обʼєктів
  • Декларативна конфігурація обʼєктів

Переваги й недоліки кожного виду керування обʼєктами розглянуто в розділі Управління обʼєктами Kubernetes.

Огляд

Декларативна конфігурація обʼєктів потребує чіткого розуміння визначень і конфігурації обʼєктів Kubernetes. Прочитайте й виконайте наведені нижче документи, якщо ви ще цього не зробили:

Нижче подано визначення термінів, використаних у цьому документі:

  • файл конфігурації обʼєкта / файл конфігурації: файл, який визначає конфігурацію обʼєкта Kubernetes. У цій темі показано, як передавати файли конфігурації до kubectl apply. Файли конфігурації зазвичай зберігаються в системі контролю версій, як-от Git.
  • жива конфігурація обʼєкта / жива конфігурація: живі значення конфігурації обʼєкта, які спостерігає кластер Kubernetes. Вони зберігаються у сховищі кластера Kubernetes, зазвичай etcd.
  • декларативний записувач конфігурації / декларативний записувач: особа або програмний компонент, що вносить оновлення до живого обʼєкта. Живі записувачі, про яких ідеться в цій темі, змінюють файли конфігурації обʼєктів і запускають kubectl apply, щоб записати зміни.

Як створити обʼєкти

Використовуйте kubectl apply, щоб створити всі обʼєкти, визначені файлами конфігурації у вказаній теці, за винятком тих, що вже існують:

kubectl apply -f <directory>

Це встановлює анотацію kubectl.kubernetes.io/last-applied-configuration: '{...}' для кожного обʼєкта. Анотація містить вміст файлу конфігурації обʼєкта, який був використаний для створення обʼєкта.

Примітка:

Додайте прапорець -R, щоб рекурсивно обробляти теки.

Ось приклад файлу конфігурації обʼєкта:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  selector:
    matchLabels:
      app: nginx
  minReadySeconds: 5
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.14.2
        ports:
        - containerPort: 80

Виконайте kubectl diff, щоб вивести обʼєкт, який буде створено:

kubectl diff -f https://k8s.io/examples/application/simple_deployment.yaml

Примітка:

diff використовує запуск без внесення змін на сервері (dry-run), таку можливість потрібно ввімкнути на kube-apiserver.

Оскільки diff виконує запит застосування на стороні сервера в режимі dry-run, для нього потрібно надати дозволи PATCH, CREATE і UPDATE. Докладніше дивіться в розділі Авторизація запуску dry-run.

Створіть обʼєкт за допомогою kubectl apply:

kubectl apply -f https://k8s.io/examples/application/simple_deployment.yaml

Виведіть живу конфігурацію за допомогою kubectl get:

kubectl get -f https://k8s.io/examples/application/simple_deployment.yaml -o yaml

Вивід показує, що анотація kubectl.kubernetes.io/last-applied-configuration була записана до живої конфігурації та відповідає файлу конфігурації:

kind: Deployment
metadata:
  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: 5
  selector:
    matchLabels:
      # ...
      app: nginx
  template:
    metadata:
      # ...
      labels:
        app: nginx
    spec:
      containers:
      - image: nginx:1.14.2
        # ...
        name: nginx
        ports:
        - containerPort: 80
        # ...
      # ...
    # ...
  # ...

Як оновити обʼєкти

Ви також можете використовувати kubectl apply, щоб оновити всі обʼєкти, визначені в теці, навіть якщо ці обʼєкти вже існують. Цей підхід робить таке:

  1. Встановлює в живій конфігурації поля, що є у файлі конфігурації.
  2. Очищає в живій конфігурації поля, вилучені з файлу конфігурації.
kubectl diff -f <directory>
kubectl apply -f <directory>

Примітка:

Додайте прапорець -R, щоб рекурсивно обробляти теки.

Ось приклад файлу конфігурації:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  selector:
    matchLabels:
      app: nginx
  minReadySeconds: 5
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.14.2
        ports:
        - containerPort: 80

Створіть обʼєкт за допомогою kubectl apply:

kubectl apply -f https://k8s.io/examples/application/simple_deployment.yaml

Примітка:

Для наочності наведена вище команда посилається на один файл конфігурації, а не на теку.

Виведіть живу конфігурацію за допомогою kubectl get:

kubectl get -f https://k8s.io/examples/application/simple_deployment.yaml -o yaml

Вивід показує, що анотація kubectl.kubernetes.io/last-applied-configuration була записана до живої конфігурації та відповідає файлу конфігурації:

kind: Deployment
metadata:
  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: 5
  selector:
    matchLabels:
      # ...
      app: nginx
  template:
    metadata:
      # ...
      labels:
        app: nginx
    spec:
      containers:
      - image: nginx:1.14.2
        # ...
        name: nginx
        ports:
        - containerPort: 80
        # ...
      # ...
    # ...
  # ...

Оновіть поле replicas безпосередньо в живій конфігурації за допомогою kubectl scale. Тут kubectl apply не використовується:

kubectl scale deployment/nginx-deployment --replicas=2

Виведіть живу конфігурацію за допомогою kubectl get:

kubectl get deployment nginx-deployment -o yaml

Вивід показує, що поле replicas встановлено на 2, і анотація last-applied-configuration не містить поле replicas:

apiVersion: apps/v1
kind: Deployment
metadata:
  annotations:
    # ...
    # зверніть увагу, що анотація не містить replicas
    # оскільки це поле не оновлювалося через 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:
  replicas: 2 # записано командою scale
  # ...
  minReadySeconds: 5
  selector:
    matchLabels:
      # ...
      app: nginx
  template:
    metadata:
      # ...
      labels:
        app: nginx
    spec:
      containers:
      - image: nginx:1.14.2
        # ...
        name: nginx
        ports:
        - containerPort: 80
      # ...

Оновіть файл конфігурації simple_deployment.yaml, щоб змінити образ з nginx:1.14.2 на nginx:1.16.1 та видалити поле minReadySeconds:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.16.1 # update the image
        ports:
        - containerPort: 80

Застосуйте зміни, внесені до файлу конфігурації:

kubectl diff -f https://k8s.io/examples/application/update_deployment.yaml
kubectl apply -f https://k8s.io/examples/application/update_deployment.yaml

Виведіть живу конфігурацію за допомогою 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/v1
kind: Deployment
metadata:
  annotations:
    # ...
    # Анотація містить оновлений образ nginx 1.16.1,
    # але не містить оновлення replicas до 2
    kubectl.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: nginx
  template:
    metadata:
      # ...
      labels:
        app: nginx
    spec:
      containers:
      - image: nginx:1.16.1 # Встановлено за допомогою `kubectl apply`
        # ...
        name: nginx
        ports:
        - containerPort: 80
        # ...
      # ...
    # ...
  # ...

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

Поєднання kubectl apply з командами імперативної конфігурації обʼєктів create і replace не підтримується. Це тому, що create і replace не зберігають kubectl.kubernetes.io/last-applied-configuration, який kubectl apply використовує для обчислення оновлень.

Як видалити обʼєкти

Існують два підходи до видалення обʼєктів, керованих за допомогою kubectl apply.

Рекомендований підхід — видаляти обʼєкти вручну за допомогою імперативної команди, оскільки так явніше видно, що саме видаляється, і менша ймовірність, що користувач випадково щось видалить:

kubectl delete -f <filename>

Альтернатива: kubectl apply -f <directory> --prune

Як альтернативу 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, його буде видалено.

kubectl apply -f <directory> --prune -l <labels> --prune-allowlist=<gvk-list>

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

Apply із prune слід виконувати лише для кореневої теки, що містить маніфести обʼєктів. Виконання для підтек може призвести до ненавмисного видалення обʼєктів, які раніше були застосовані, мають задані мітки (якщо є) і не зʼявляються в підтеці.
СТАН ФУНКЦІОНАЛУ: Alpha since Kubernetes v1.27

Увага:

kubectl apply --prune --applyset перебуває на етапі альфа, і в наступних випусках можуть зʼявитися несумісні зміни.

Щоб використовувати очищення на основі ApplySet, встановіть змінну середовища KUBECTL_APPLYSET=true і додайте такі прапорці до виклику kubectl apply:

  • --prune: видалити раніше застосовані обʼєкти, яких немає в наборі, переданому поточному виклику.
  • --applyset: назва обʼєкта, який kubectl може використовувати для точного й ефективного відстеження членства в наборі під час операцій apply.
KUBECTL_APPLYSET=true kubectl apply -f <directory> --prune --applyset=<name>

Стандартно тип батьківського обʼєкта 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. Вона використовується для визначення полів, які було вилучено з файлу конфігурації й потрібно очистити з живої конфігурації. Ось кроки для обчислення того, які поля слід видалити або встановити:

  1. Обчислити поля для видалення. Це поля, які присутні в last-applied-configuration та відсутні у файлі конфігурації.
  2. Обчислити поля для додавання або встановлення. Це поля, які присутні у файлі конфігурації, значення яких не відповідають живій конфігурації.

Ось приклад. Припустимо, що це файл конфігурації для обʼєкта Deployment:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.16.1 # update the image
        ports:
        - containerPort: 80

Також, припустимо, що це жива конфігурація для того самого обʼєкта Deployment:

apiVersion: apps/v1
kind: Deployment
metadata:
  annotations:
    # ...
    # зверніть увагу, що анотація не містить replicas
    # оскільки це поле не оновлювалося через 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:
  replicas: 2 # записано командою scale
  # ...
  minReadySeconds: 5
  selector:
    matchLabels:
      # ...
      app: nginx
  template:
    metadata:
      # ...
      labels:
        app: nginx
    spec:
      containers:
      - image: nginx:1.14.2
        # ...
        name: nginx
        ports:
        - containerPort: 80
      # ...

Ось обчислення злиття, які виконає kubectl apply:

  1. Обчислити поля для видалення, прочитавши значення з last-applied-configuration і порівнявши їх зі значеннями у файлі конфігурації. Очистити поля, явно встановлені в null у локальному файлі конфігурації обʼєкта, незалежно від того, чи є вони в last-applied-configuration. У цьому прикладі minReadySeconds є в анотації last-applied-configuration, але немає у файлі конфігурації. Дія: очистити minReadySeconds у живій конфігурації.
  2. Обчислити поля для встановлення, прочитавши значення з файлу конфігурації й порівнявши їх зі значеннями в живій конфігурації. У цьому прикладі значення image у файлі конфігурації не збігається зі значенням у живій конфігурації. Дія: встановити значення image у живій конфігурації.
  3. Встановити анотацію last-applied-configuration, щоб вона відповідала значенню файлу конфігурації.
  4. Обʼєднати результати з 1, 2, 3 у єдиний запит на патч до API-сервера.

Ось жива конфігурація, яка є результатом злиття:

apiVersion: apps/v1
kind: Deployment
metadata:
  annotations:
    # ...
    # Анотація містить оновлений образ nginx 1.16.1,
    # але не містить оновлення replicas до 2
    kubectl.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: nginx
  replicas: 2 # Встановлено за допомогою `kubectl scale`. Ігнорується `kubectl apply`.
  # minReadySeconds очищено за допомогою `kubectl apply`
  # ...
  template:
    metadata:
      # ...
      labels:
        app: nginx
    spec:
      containers:
      - image: nginx:1.16.1 # Встановлено за допомогою `kubectl apply`
        # ...
        name: nginx
        ports:
        - 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-configuration
    args: ["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-configuration
    containers:
    - name: nginx
      image: 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: nginx
      image: nginx:1.16
    - name: nginx-helper-b
      image: helper:1.3
    - name: nginx-helper-c # ключ: nginx-helper-c; буде додано в результаті
      image: helper:1.3

# Жива конфігурація
    containers:
    - name: nginx
      image: nginx:1.16
    - name: nginx-helper-a
      image: helper:1.3
    - name: nginx-helper-b
      image: helper:1.3
      args: ["run"] # Поле буде збережено
    - name: nginx-helper-d # ключ: nginx-helper-d; буде збережено
      image: helper:1.3

# Результат після злиття
    containers:
    - name: nginx
      image: nginx:1.16
      # Елемент nginx-helper-a видалено
    - name: nginx-helper-b
      image: helper:1.3
      args: ["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:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  selector:
    matchLabels:
      app: nginx
  minReadySeconds: 5
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.14.2
        ports:
        - containerPort: 80

Створіть обʼєкт, використовуючи kubectl apply:

kubectl apply -f https://k8s.io/examples/application/simple_deployment.yaml

Виведіть живу конфігурацію, використовуючи kubectl get:

kubectl get -f https://k8s.io/examples/application/simple_deployment.yaml -o yaml

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

apiVersion: apps/v1
kind: Deployment
# ...
spec:
  selector:
    matchLabels:
      app: nginx
  minReadySeconds: 5
  replicas: 1 # стандартне значення від apiserver
  strategy:
    rollingUpdate: # стандартне значення від apiserver, виведене з strategy.type
      maxSurge: 1
      maxUnavailable: 1
    type: RollingUpdate # стандартне значення від apiserver
  template:
    metadata:
      creationTimestamp: null
      labels:
        app: nginx
    spec:
      containers:
      - image: nginx:1.14.2
        imagePullPolicy: IfNotPresent # стандартне значення від apiserver
        name: nginx
        ports:
        - containerPort: 80
          protocol: TCP # стандартне значення від apiserver
        resources: {} # стандартне значення від apiserver
        terminationMessagePath: /dev/termination-log # стандартне значення від apiserver
      dnsPolicy: ClusterFirst # стандартне значення від apiserver
      restartPolicy: Always # стандартне значення від apiserver
      securityContext: {} # стандартне значення від apiserver
      terminationGracePeriodSeconds: 30 # стандартне значення від apiserver
# ...

У запиті на патч поля зі стандартними значеннями не отримують стандартні значення повторно, якщо їх явно не очищено в цьому запиті. Це може спричинити неочікувану поведінку полів, стандартні значення яких залежать від інших полів. Коли ці інші поля згодом змінюються, виведені з них значення не оновлюються, якщо їх явно не очистити.

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

Приклад:

# last-applied-configuration
spec:
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.14.2
        ports:
        - containerPort: 80

# Файл конфігурації
spec:
  strategy:
    type: Recreate # оновлене значення
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.14.2
        ports:
        - containerPort: 80

# Жива конфігурація
spec:
  strategy:
    type: RollingUpdate # стандартне значення
    rollingUpdate: # стандартне значення, виведене з type
      maxSurge : 1
      maxUnavailable: 1
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.14.2
        ports:
        - containerPort: 80

# Результат після злиття — ПОМИЛКА!
spec:
  strategy:
    type: Recreate # оновлене значення: несумісне з rollingUpdate
    rollingUpdate: # стандартне значення: несумісне з "type: Recreate"
      maxSurge : 1
      maxUnavailable: 1
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.14.2
        ports:
        - containerPort: 80

Пояснення:

  1. Користувач створює Deployment без визначення strategy.type.
  2. Сервер встановлює для strategy.type стандартне значення RollingUpdate і стандартні значення для strategy.rollingUpdate.
  3. Користувач змінює strategy.type на Recreate. Значення strategy.rollingUpdate лишаються стандартними, хоча сервер очікує, що їх буде очищено. Якби значення strategy.rollingUpdate було спочатку визначено у файлі конфігурації, було б зрозуміліше, що їх потрібно видалити.
  4. 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 слід керувати лише одним методом одночасно. Перехід з одного методу на інший можливий, але виконується вручну.

Примітка:

Можна використовувати імперативне видалення разом із декларативним керуванням.

Міграція з керування імперативними командами на декларативну конфігурацію обʼєктів

Міграція з керування імперативними командами на декларативну конфігурацію обʼєктів складається з кількох ручних кроків:

  1. Експортуйте живий обʼєкт у локальний файл конфігурації:

    kubectl get <kind>/<name> -o yaml > <kind>_<name>.yaml
    
  2. Видаліть вручну поле status з файлу конфігурації.

    Примітка:

    Цей крок є необовʼязковим, оскільки kubectl apply не оновлює поле статусу, навіть якщо воно присутнє у файлі конфігурації.
  3. Встановіть анотацію kubectl.kubernetes.io/last-applied-configuration на обʼєкті:

    kubectl replace --save-config -f <kind>_<name>.yaml
    
  4. Змініть процеси так, щоб для керування обʼєктом використовувався виключно kubectl apply.

Міграція з імперативного конфігурування обʼєктів на декларативну конфігурацію обʼєктів

  1. Встановіть анотацію kubectl.kubernetes.io/last-applied-configuration на обʼєкті:

    kubectl replace --save-config -f <kind>_<name>.yaml
    
  2. Змініть процеси так, щоб для керування обʼєктом використовувався виключно kubectl apply.

Визначення селекторів контролера та міток PodTemplate

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

Оновлювати селектори контролерів категорично не рекомендовано.

Рекомендований підхід — визначити одну незмінну мітку PodTemplate, яка використовується тільки селектором контролера й не має іншого семантичного значення.

Приклад:

selector:
  matchLabels:
      controller-selector: "apps/v1/deployment/nginx"
template:
  metadata:
    labels:
      controller-selector: "apps/v1/deployment/nginx"

Що далі

5.2 - Декларативне керування обʼєктами Kubernetes за допомогою Kustomize

Kustomize — це окремий інструмент для налаштування обʼєктів Kubernetes за допомогою файлу kustomization.

Починаючи з версії 1.14, kubectl також підтримує керування обʼєктами Kubernetes за допомогою файлу kustomization. Щоб переглянути ресурси, знайдені в теці з файлом kustomization, виконайте таку команду:

kubectl kustomize <kustomization_directory>

Щоб застосувати ці ресурси, виконайте kubectl apply із прапорцем --kustomize або -k:

kubectl apply -k <kustomization_directory>

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

Встановіть kubectl.

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

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

Огляд Kustomize

Kustomize — це інструмент для налаштування конфігурацій Kubernetes. Він має такі можливості для керування файлами конфігурації застосунків:

  • генерування ресурсів з інших джерел
  • встановлення наскрізних полів для ресурсів
  • компонування та налаштування колекцій ресурсів

Генерування ресурсів

ConfigMaps і Secrets зберігають конфігураційні або конфіденційні дані, які використовуються іншими обʼєктами Kubernetes, наприклад Podʼами. Джерело істини для ConfigMaps або Secrets зазвичай розташоване поза кластером, наприклад це файл .properties або файл ключа SSH. Kustomize має secretGenerator і configMapGenerator, які генерують Secret і ConfigMap із файлів або літералів.

configMapGenerator

Щоб згенерувати ConfigMap з файлу, додайте запис до списку files у configMapGenerator. Ось приклад генерування ConfigMap з елементом даних із файлу .properties:

# Створіть файл application.properties
cat <<EOF >application.properties
FOO=Bar
EOF

cat <<EOF >./kustomization.yaml
configMapGenerator:
- name: example-configmap-1
  files:
  - application.properties
EOF

Згенерований ConfigMap можна переглянути за допомогою такої команди:

kubectl kustomize ./

Згенерований ConfigMap виглядає так:

apiVersion: v1
data:
  application.properties: |
    FOO=Bar
kind: ConfigMap
metadata:
  name: example-configmap-1-8mbdf7882g

Щоб згенерувати ConfigMap з файлу env, додайте запис до списку envs у configMapGenerator. Ось приклад генерування ConfigMap з елементом даних із файлу .env:

# Створіть файл .env
cat <<EOF >.env
FOO=Bar
EOF

cat <<EOF >./kustomization.yaml
configMapGenerator:
- name: example-configmap-1
  envs:
  - .env
EOF

Згенерований ConfigMap можна переглянути за допомогою такої команди:

kubectl kustomize ./

Згенерований ConfigMap виглядає так:

apiVersion: v1
data:
  FOO: Bar
kind: ConfigMap
metadata:
  name: example-configmap-1-42cfbf598f

Примітка:

Кожна змінна у файлі .env стає окремим ключем у згенерованому ConfigMap. Це відрізняється від попереднього прикладу, де файл з назвою application.properties (з усіма його записами) вбудовується як значення одного ключа.

ConfigMaps також можна генерувати з літеральних пар ключ-значення. Щоб згенерувати ConfigMap з літеральної пари ключ-значення, додайте запис до списку literals у configMapGenerator. Ось приклад генерування ConfigMap з елементом даних із пари ключ-значення:

cat <<EOF >./kustomization.yaml
configMapGenerator:
- name: example-configmap-2
  literals:
  - FOO=Bar
EOF

Згенерований ConfigMap можна перевірити за допомогою такої команди:

kubectl kustomize ./

Згенерований ConfigMap виглядає так:

apiVersion: v1
data:
  FOO: Bar
kind: ConfigMap
metadata:
  name: example-configmap-2-g2hdhfc6tk

Щоб використати згенерований ConfigMap у Deployment, посилайтеся на нього за назвою configMapGenerator. Kustomize автоматично замінить цю назву згенерованою.

Ось приклад Deployment, що використовує згенерований ConfigMap:

# Створіть файл application.properties
cat <<EOF >application.properties
FOO=Bar
EOF

cat <<EOF >deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
  labels:
    app: my-app
spec:
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
      - name: app
        image: my-app
        volumeMounts:
        - name: config
          mountPath: /config
      volumes:
      - name: config
        configMap:
          name: example-configmap-1
EOF

cat <<EOF >./kustomization.yaml
resources:
- deployment.yaml
configMapGenerator:
- name: example-configmap-1
  files:
  - application.properties
EOF

Згенеруйте ConfigMap та Deployment:

kubectl kustomize ./

Згенерований Deployment посилатиметься на згенерований ConfigMap за назвою:

apiVersion: v1
data:
  application.properties: |
    FOO=Bar
kind: ConfigMap
metadata:
  name: example-configmap-1-g4hk9g2ff8
---
apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app: my-app
  name: my-app
spec:
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
      - image: my-app
        name: app
        volumeMounts:
        - mountPath: /config
          name: config
      volumes:
      - configMap:
          name: example-configmap-1-g4hk9g2ff8
        name: config

secretGenerator

Ви можете генерувати Secrets із файлів або літеральних пар ключ-значення. Щоб згенерувати Secret з файлу, додайте запис до списку files у secretGenerator. Ось приклад генерування Secret з елементом даних із файлу:

# Створіть файл password.txt
cat <<EOF >./password.txt
username=admin
password=secret
EOF

cat <<EOF >./kustomization.yaml
secretGenerator:
- name: example-secret-1
  files:
  - password.txt
EOF

Згенерований Secret має такий вигляд:

apiVersion: v1
data:
  password.txt: dXNlcm5hbWU9YWRtaW4KcGFzc3dvcmQ9c2VjcmV0Cg==
kind: Secret
metadata:
  name: example-secret-1-t2kt65hgtb
type: Opaque

Щоб згенерувати Secret з літеральної пари ключ-значення, додайте запис до списку literals у secretGenerator. Ось приклад генерування Secret з елементом даних із пари ключ-значення:

cat <<EOF >./kustomization.yaml
secretGenerator:
- name: example-secret-2
  literals:
  - username=admin
  - password=secret
EOF

Згенерований Secret має такий вигляд:

apiVersion: v1
data:
  password: c2VjcmV0
  username: YWRtaW4=
kind: Secret
metadata:
  name: example-secret-2-t52t6g96d8
type: Opaque

Подібно до ConfigMaps, згенеровані Secrets можна використовувати в Deployments, посилаючись на назву secretGenerator:

# Створіть файл password.txt
cat <<EOF >./password.txt
username=admin
password=secret
EOF

cat <<EOF >deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
  labels:
    app: my-app
spec:
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
      - name: app
        image: my-app
        volumeMounts:
        - name: password
          mountPath: /secrets
      volumes:
      - name: password
        secret:
          secretName: example-secret-1
EOF

cat <<EOF >./kustomization.yaml
resources:
- deployment.yaml
secretGenerator:
- name: example-secret-1
  files:
  - password.txt
EOF

generatorOptions

До згенерованих ConfigMaps і Secrets додається суфікс із хешем вмісту. Це гарантує, що під час зміни вмісту генерується новий ConfigMap або Secret. Щоб вимкнути додавання суфікса, можна використати generatorOptions. Крім того, можна вказати наскрізні параметри для згенерованих ConfigMaps і Secrets.

cat <<EOF >./kustomization.yaml
configMapGenerator:
- name: example-configmap-3
  literals:
  - FOO=Bar
generatorOptions:
  disableNameSuffixHash: true
  labels:
    type: generated
  annotations:
    note: generated
EOF

Виконайте kubectl kustomize ./, щоб переглянути згенерований ConfigMap:

apiVersion: v1
data:
  FOO: Bar
kind: ConfigMap
metadata:
  annotations:
    note: generated
  labels:
    type: generated
  name: example-configmap-3

Встановлення наскрізних полів

Досить поширена практика — встановлювати наскрізні поля для всіх ресурсів Kubernetes у проєкті. Деякі випадки використання наскрізних полів:

  • встановлення того самого простору імен для всіх ресурсів
  • додавання того самого префікса або суфікса назви
  • додавання того самого набору міток
  • додавання того самого набору анотацій

Ось приклад:

# Створіть deployment.yaml
cat <<EOF >./deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
  labels:
    app: nginx
spec:
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx
EOF

cat <<EOF >./kustomization.yaml
namespace: my-namespace
namePrefix: dev-
nameSuffix: "-001"
labels:
  - pairs:
      app: bingo
    includeSelectors: true
commonAnnotations:
  oncallPager: 800-555-1212
resources:
- deployment.yaml
EOF

Виконайте kubectl kustomize ./, щоб побачити, що всі ці поля встановлено в ресурсі Deployment:

apiVersion: apps/v1
kind: Deployment
metadata:
  annotations:
    oncallPager: 800-555-1212
  labels:
    app: bingo
  name: dev-nginx-deployment-001
  namespace: my-namespace
spec:
  selector:
    matchLabels:
      app: bingo
  template:
    metadata:
      annotations:
        oncallPager: 800-555-1212
      labels:
        app: bingo
    spec:
      containers:
      - image: nginx
        name: nginx

Компонування та налаштування ресурсів

Часто в проєкті компонують набір ресурсів і керують ними в одному файлі чи теці. Kustomize дає змогу компонувати ресурси з різних файлів і застосовувати до них патчі або інші налаштування.

Компонування

Kustomize підтримує компонування різних ресурсів. Поле resources у файлі kustomization.yaml визначає список ресурсів, які слід включити в конфігурацію. Вкажіть шлях до файлу конфігурації ресурсу у списку resources. Ось приклад застосунку NGINX, що складається з Deployment і Service:

# Створіть файл deployment.yaml
cat <<EOF > deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-nginx
spec:
  selector:
    matchLabels:
      run: my-nginx
  replicas: 2
  template:
    metadata:
      labels:
        run: my-nginx
    spec:
      containers:
      - name: my-nginx
        image: nginx
        ports:
        - containerPort: 80
EOF

# Створіть файл service.yaml
cat <<EOF > service.yaml
apiVersion: v1
kind: Service
metadata:
  name: my-nginx
  labels:
    run: my-nginx
spec:
  ports:
  - port: 80
    protocol: TCP
  selector:
    run: my-nginx
EOF

# Створіть файл kustomization.yaml та скомпонуйте їх
cat <<EOF >./kustomization.yaml
resources:
- deployment.yaml
- service.yaml
EOF

Ресурси з kubectl kustomize ./ містять обидва обʼєкти: Deployment і Service.

Налаштування

Патчі можна використовувати для застосування різних налаштувань до ресурсів. Kustomize підтримує різні механізми патчів через StrategicMerge і Json6902 за допомогою поля patches. patches може бути файлом або вбудованим рядком, спрямованим на один або кілька ресурсів.

Поле patches містить список патчів, які застосовуються в порядку їх зазначення. Ціль патча вибирає ресурси за group, version, kind, name, namespace, labelSelector і annotationSelector.

Рекомендовано створювати невеликі патчі, які роблять щось одне. Наприклад, створіть один патч для збільшення кількості реплік Deployment, а інший — для встановлення обмеження памʼяті. Цільовий ресурс визначається за полями group, version, kind і name з файлу патча.

# Створіть файл deployment.yaml
cat <<EOF > deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-nginx
spec:
  selector:
    matchLabels:
      run: my-nginx
  replicas: 2
  template:
    metadata:
      labels:
        run: my-nginx
    spec:
      containers:
      - name: my-nginx
        image: nginx
        ports:
        - containerPort: 80
EOF

# Створіть патч increase_replicas.yaml
cat <<EOF > increase_replicas.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-nginx
spec:
  replicas: 3
EOF

# Створіть інший патч set_memory.yaml
cat <<EOF > set_memory.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-nginx
spec:
  template:
    spec:
      containers:
      - name: my-nginx
        resources:
          limits:
            memory: 512Mi
EOF

cat <<EOF >./kustomization.yaml
resources:
- deployment.yaml
patches:
  - path: increase_replicas.yaml
  - path: set_memory.yaml
EOF

Виконайте kubectl kustomize ./, щоб переглянути Deployment:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      run: my-nginx
  template:
    metadata:
      labels:
        run: my-nginx
    spec:
      containers:
      - image: nginx
        name: my-nginx
        ports:
        - containerPort: 80
        resources:
          limits:
            memory: 512Mi

Не всі ресурси чи поля підтримують патчі strategicMerge. Для зміни довільних полів у довільних ресурсах Kustomize пропонує застосування JSON patch через Json6902. Щоб знайти правильний ресурс для патча Json6902, обовʼязково потрібно вказати поле target у файлі kustomization.yaml.

Наприклад, збільшити кількість реплік обʼєкта Deployment можна також за допомогою патча Json6902. Цільовий ресурс визначається за group, version, kind і name з поля target.

# Створіть файл deployment.yaml
cat <<EOF > deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-nginx
spec:
  selector:
    matchLabels:
      run: my-nginx
  replicas: 2
  template:
    metadata:
      labels:
        run: my-nginx
    spec:
      containers:
      - name: my-nginx
        image: nginx
        ports:
        - containerPort: 80
EOF

# Створіть json патч
cat <<EOF > patch.yaml
- op: replace
  path: /spec/replicas
  value: 3
EOF

# Створіть kustomization.yaml
cat <<EOF >./kustomization.yaml
resources:
- deployment.yaml

patches:
- target:
    group: apps
    version: v1
    kind: Deployment
    name: my-nginx
  path: patch.yaml
EOF

Виконайте kubectl kustomize ./, щоб побачити, що поле replicas оновлено:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      run: my-nginx
  template:
    metadata:
      labels:
        run: my-nginx
    spec:
      containers:
      - image: nginx
        name: my-nginx
        ports:
        - containerPort: 80

Крім патчів, Kustomize також дає змогу налаштовувати образи контейнерів або вставляти значення полів з інших обʼєктів у контейнери без створення патчів. Наприклад, можна змінити образ, що використовується в контейнерах, вказавши новий образ у полі images у kustomization.yaml.

cat <<EOF > deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-nginx
spec:
  selector:
    matchLabels:
      run: my-nginx
  replicas: 2
  template:
    metadata:
      labels:
        run: my-nginx
    spec:
      containers:
      - name: my-nginx
        image: nginx
        ports:
        - containerPort: 80
EOF

cat <<EOF >./kustomization.yaml
resources:
- deployment.yaml
images:
- name: nginx
  newName: my.image.registry/nginx
  newTag: "1.4.0"
EOF

Виконайте kubectl kustomize ./, щоб побачити, що використовуваний образ оновлено:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-nginx
spec:
  replicas: 2
  selector:
    matchLabels:
      run: my-nginx
  template:
    metadata:
      labels:
        run: my-nginx
    spec:
      containers:
      - image: my.image.registry/nginx:1.4.0
        name: my-nginx
        ports:
        - containerPort: 80

Іноді застосунку, що працює в Podʼі, потрібні значення конфігурації з інших обʼєктів. Наприклад, Pod з обʼєкта Deployment має прочитати відповідну назву Service зі змінної середовища або з аргументу команди. Оскільки назва Service може змінюватися, коли у файлі kustomization.yaml додається namePrefix або nameSuffix, не рекомендовано жорстко задавати назву Service в аргументі команди. Для цього Kustomize може вставити назву Service у контейнери через replacements.

# Створіть файл deployment.yaml (взявши в лапки роздільник here doc)
cat <<'EOF' > deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-nginx
spec:
  selector:
    matchLabels:
      run: my-nginx
  replicas: 2
  template:
    metadata:
      labels:
        run: my-nginx
    spec:
      containers:
      - name: my-nginx
        image: nginx
        command: ["start", "--host", "MY_SERVICE_NAME_PLACEHOLDER"]
EOF

# Створіть файл service.yaml
cat <<EOF > service.yaml
apiVersion: v1
kind: Service
metadata:
  name: my-nginx
  labels:
    run: my-nginx
spec:
  ports:
  - port: 80
    protocol: TCP
  selector:
    run: my-nginx
EOF

cat <<EOF >./kustomization.yaml
namePrefix: dev-
nameSuffix: "-001"

resources:
- deployment.yaml
- service.yaml

replacements:
- source:
    kind: Service
    name: my-nginx
    fieldPath: metadata.name
  targets:
  - select:
      kind: Deployment
      name: my-nginx
    fieldPaths:
    - spec.template.spec.containers.0.command.2
EOF

Виконайте kubectl kustomize ./, щоб побачити, що назва Service, вставлена в контейнери, — це dev-my-nginx-001:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: dev-my-nginx-001
spec:
  replicas: 2
  selector:
    matchLabels:
      run: my-nginx
  template:
    metadata:
      labels:
        run: my-nginx
    spec:
      containers:
      - command:
        - start
        - --host
        - dev-my-nginx-001
        image: nginx
        name: my-nginx

Base та Overlay

У Kustomize є поняття base і overlay. Base — це тека з файлом kustomization.yaml, яка містить набір ресурсів і повʼязані налаштування. Base може бути локальною текою або текою з віддаленого репозиторію, якщо всередині є файл kustomization.yaml. Overlay — це тека з файлом kustomization.yaml, яка посилається на інші теки kustomization як на свої bases. Base нічого не знає про overlay і може використовуватися в кількох overlay.

Файл kustomization.yaml у теці overlay може посилатися на кілька bases, обʼєднуючи всі ресурси, визначені в цих base, в єдину конфігурацію. Крім того, він може застосовувати налаштування поверх цих ресурсів для задоволення певних вимог.

Ось приклад base:

# Створіть теку для зберігання base
mkdir base
# Створіть файл base/deployment.yaml
cat <<EOF > base/deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-nginx
spec:
  selector:
    matchLabels:
      run: my-nginx
  replicas: 2
  template:
    metadata:
      labels:
        run: my-nginx
    spec:
      containers:
      - name: my-nginx
        image: nginx
EOF

# Створіть файл base/service.yaml
cat <<EOF > base/service.yaml
apiVersion: v1
kind: Service
metadata:
  name: my-nginx
  labels:
    run: my-nginx
spec:
  ports:
  - port: 80
    protocol: TCP
  selector:
    run: my-nginx
EOF
# Створіть файл base/kustomization.yaml
cat <<EOF > base/kustomization.yaml
resources:
- deployment.yaml
- service.yaml
EOF

Цей base можна використовувати в кількох overlay. Ви можете додавати різні namePrefix або інші наскрізні поля в різних overlay. Ось два overlay, які використовують той самий base.

mkdir dev
cat <<EOF > dev/kustomization.yaml
resources:
- ../base
namePrefix: dev-
EOF

mkdir prod
cat <<EOF > prod/kustomization.yaml
resources:
- ../base
namePrefix: prod-
EOF

Як застосовувати, переглядати й видаляти обʼєкти за допомогою Kustomize

Використовуйте --kustomize або -k у командах kubectl, щоб розпізнавати ресурси, якими керує kustomization.yaml. Зверніть увагу, що -k має вказувати на теку kustomization, наприклад,

kubectl apply -k <kustomization directory>/

Для такого kustomization.yaml,

# Створіть файл deployment.yaml
cat <<EOF > deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-nginx
spec:
  selector:
    matchLabels:
      run: my-nginx
  replicas: 2
  template:
    metadata:
      labels:
        run: my-nginx
    spec:
      containers:
      - name: my-nginx
        image: nginx
        ports:
        - containerPort: 80
EOF

# Створіть файл kustomization.yaml
cat <<EOF >./kustomization.yaml
namePrefix: dev-
labels:
  - pairs:
      app: my-nginx
    includeSelectors: true
resources:
- deployment.yaml
EOF

Виконайте таку команду, щоб застосувати обʼєкт Deployment dev-my-nginx:

> kubectl apply -k ./
deployment.apps/dev-my-nginx created

Виконайте одну з наведених нижче команд, щоб переглянути обʼєкт Deployment dev-my-nginx:

kubectl get -k ./
kubectl describe -k ./

Виконайте таку команду, щоб порівняти обʼєкт Deployment dev-my-nginx зі станом, у якому був би кластер, якби маніфест було застосовано:

kubectl diff -k ./

Виконайте таку команду, щоб видалити обʼєкт Deployment dev-my-nginx:

> kubectl delete -k ./
deployment.apps "dev-my-nginx" deleted

Перелік можливостей Kustomize

ПолеТипПояснення
bases[]stringКожен запис у цьому списку має вказувати на теку, що містить файл kustomization.yaml
commonAnnotationsmap[string]stringанотації, які додаються до всіх ресурсів
commonLabelsmap[string]stringмітки, які додаються до всіх ресурсів та селекторів
configMapGenerator[]ConfigMapArgsКожен запис у цьому списку генерує ConfigMap
configurations[]stringКожен запис у цьому списку має вказувати на файл, що містить конфігурації трансформаторів Kustomize
crds[]stringКожен запис у цьому списку має вказувати на файл визначення OpenAPI для типів Kubernetes
generatorOptionsGeneratorOptionsЗмінює поведінку всіх генераторів ConfigMap та Secret
images[]ImageКожен запис змінює назву, теґи та/або дайджест для одного образу без створення патчів
labelsmap[string]stringДодає мітки без автоматичного додавання відповідних селекторів
namePrefixstringзначення цього поля додається на початок назв усіх ресурсів
nameSuffixstringзначення цього поля додається в кінець назв усіх ресурсів
patchesJson6902[]PatchКожен запис у цьому списку має вказувати на обʼєкт Kubernetes та Json Patch
patchesStrategicMerge[]stringКожен запис у цьому списку має вказувати на strategic merge patch обʼєкта Kubernetes
replacements[]Replacementsкопіює значення з поля ресурсу в будь-яку кількість зазначених цілей
resources[]stringКожен запис у цьому списку має вказувати на наявний файл конфігурації ресурсу
secretGenerator[]SecretArgsКожен запис у цьому списку генерує Secret
vars[]VarКожен запис призначений для захоплення тексту з поля одного ресурсу

Що далі

5.3 - Керування обʼєктами Kubernetes за допомогою імперативних команд

Обʼєкти Kubernetes можна швидко створювати, оновлювати й видаляти безпосередньо за допомогою імперативних команд, вбудованих в інструмент командного рядка kubectl. У цьому документі пояснено, як організовано ці команди та як їх використовувати для керування живими обʼєктами.

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

Встановіть kubectl.

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

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

Компроміси

Інструмент kubectl підтримує три види керування обʼєктами:

  • Імперативні команди
  • Імперативне конфігурування обʼєктів
  • Декларативна конфігурація обʼєктів

Переваги й недоліки кожного виду керування обʼєктами розглянуто в розділі Управління обʼєктами Kubernetes.

Як створювати обʼєкти

Інструмент 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 clusterip my-svc --clusterip="None" -o yaml --dry-run=client | kubectl set selector --local -f - 'environment=qa' -o yaml | kubectl create -f -
  1. Команда kubectl create service -o yaml --dry-run=client створює конфігурацію для Service, але виводить її в stdout у форматі YAML замість надсилання до API-сервера Kubernetes.
  2. Команда kubectl set selector --local -f - -o yaml читає конфігурацію зі stdin і записує оновлену конфігурацію в stdout у форматі YAML.
  3. Команда kubectl create -f - створює обʼєкт, використовуючи конфігурацію, отриману через stdin.

Використання --edit для модифікації обʼєктів перед створенням

Можна використати kubectl create --edit, щоб внести довільні зміни в обʼєкт перед його створенням. Ось приклад:

kubectl create service clusterip my-svc --clusterip="None" -o yaml --dry-run=client > /tmp/srv.yaml
kubectl create --edit -f /tmp/srv.yaml
  1. Команда kubectl create service створює конфігурацію для Service та зберігає її у /tmp/srv.yaml.
  2. Команда kubectl create --edit відкриває файл конфігурації для редагування перед створенням обʼєкта.

Що далі

5.4 - Імперативне керування обʼєктами Kubernetes за допомогою файлів конфігурації

Обʼєкти Kubernetes можна створювати, оновлювати й видаляти за допомогою інструмента командного рядка kubectl разом із файлом конфігурації обʼєкта у форматі YAML або JSON. У цьому документі пояснено, як визначати обʼєкти й керувати ними за допомогою файлів конфігурації.

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

Встановіть kubectl.

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

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

Компроміси

Інструмент kubectl підтримує три види керування обʼєктами:

  • Імперативні команди
  • Імперативне конфігурування обʼєктів
  • Декларативна конфігурація обʼєктів

Переваги й недоліки кожного виду керування обʼєктами розглянуто в розділі Управління обʼєктами Kubernetes.

Як створювати обʼєкти

Ви можете використовувати 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 delete <type> <name>
kubectl delete <type> -l <label>

Як переглянути обʼєкт

Ви можете використовувати kubectl get -f, щоб переглянути інформацію про обʼєкт, описаний у файлі конфігурації.

  • kubectl get -f <filename|url> -o yaml

Прапорець -o yaml вказує, що треба вивести повну конфігурацію обʼєкта. Використайте kubectl get -h, щоб побачити список параметрів.

Обмеження

Команди create, replace і delete добре працюють, коли конфігурація кожного обʼєкта повністю визначена й записана в його файлі конфігурації. Однак якщо живий обʼєкт оновлено, а оновлення не внесено до його файлу конфігурації, вони будуть втрачені під час наступного виконання replace. Це може статися, якщо контролер, як-от HorizontalPodAutoscaler, вносить оновлення безпосередньо в живий обʼєкт. Ось приклад:

  1. Ви створюєте обʼєкт з файлу конфігурації.
  2. Інше джерело оновлює обʼєкт, змінюючи якесь поле.
  3. Ви замінюєте обʼєкт з файлу конфігурації. Зміни, внесені іншим джерелом на кроці 2, втрачаються.

Якщо вам потрібна підтримка кількох записувачів для одного обʼєкта, можна використовувати kubectl apply для керування обʼєктом.

Створення та редагування обʼєкта за URL без збереження конфігурації

Припустимо, у вас є URL файлу конфігурації обʼєкта. Ви можете використати kubectl create --edit, щоб внести зміни до конфігурації перед створенням обʼєкта. Це особливо корисно для навчальних матеріалів і завдань, що вказують на файл конфігурації, який читач може змінити.

kubectl create -f <url> --edit

Міграція від імперативних команд до імперативного конфігурування обʼєктів

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

  1. Експортуйте живий обʼєкт у локальний файл конфігурації обʼєкта:

    kubectl get <kind>/<name> -o yaml > <kind>_<name>.yaml
    
  2. Вручну вилучіть поле status із файлу конфігурації обʼєкта.

  3. Для подальшого керування обʼєктом використовуйте виключно replace.

    kubectl replace -f <kind>_<name>.yaml
    

Визначення селекторів контролерів та міток PodTemplate

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

Оновлювати селектори контролерів категорично не рекомендовано.

Рекомендований підхід — визначити одну незмінну мітку PodTemplate, яка використовується тільки селектором контролера без іншого семантичного значення.

Приклад мітки:

selector:
  matchLabels:
      controller-selector: "apps/v1/deployment/nginx"
template:
  metadata:
    labels:
      controller-selector: "apps/v1/deployment/nginx"

Що далі

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 або використовувати одну з цих пісочниць:

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

Використання strategic merge patch для оновлення Deployment

Ось файл конфігурації для Deployment, що має дві репліки. Кожна репліка є Podʼом, який має один контейнер:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: patch-demo
spec:
  replicas: 2
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: patch-demo-ctr
        image: nginx
      tolerations:
      - effect: NoSchedule
        key: dedicated
        value: test-team

Створіть Deployment:

kubectl apply -f https://k8s.io/examples/application/deployment-patch.yaml

Перегляньте Podʼи, повʼязані з вашим Deployment:

kubectl get pods

Вивід показує, що 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 із таким вмістом:

spec:
  template:
    spec:
      containers:
      - name: patch-demo-ctr-2
        image: redis

Застосуйте патч до вашого Deployment:

kubectl patch deployment patch-demo --patch-file patch-file.yaml

Перегляньте Deployment після накладання патчу:

kubectl get deployment patch-demo --output yaml

Вивід показує, що PodSpec у Deployment має два контейнери:

containers:
- image: redis
  imagePullPolicy: Always
  name: patch-demo-ctr-2
  ...
- image: nginx
  imagePullPolicy: Always
  name: patch-demo-ctr
  ...

Перегляньте 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:

type PodSpec struct {
  ...
  Containers []Container `json:"containers" patchStrategy:"merge" patchMergeKey:"name" ...`
  ...
}

Ви також можете побачити стратегію патча в специфікації OpenApi:

"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"
}

І ви можете побачити стратегію патча в документації Kubernetes API.

Створіть файл з назвою patch-file-tolerations.yaml із таким вмістом:

spec:
  template:
    spec:
      tolerations:
      - effect: NoSchedule
        key: disktype
        value: ssd

Застосуйте патч до вашого Deployment:

kubectl patch deployment patch-demo --patch-file patch-file-tolerations.yaml

Перегляньте Deployment після накладання патчу:

kubectl get deployment patch-demo --output yaml

Вивід показує, що PodSpec у Deployment має лише один Toleration:

tolerations:
- effect: NoSchedule
  key: disktype
  value: ssd

Зверніть увагу, що список tolerations у PodSpec замінено, а не обʼєднано. Це тому, що поле Tolerations у PodSpec не має ключа patchStrategy у своєму теґу поля. Тож strategic merge patch використовує стандартну стратегію патча, тобто replace.

type PodSpec struct {
  ...
  Tolerations []Toleration `json:"tolerations,omitempty" protobuf:"bytes,22,opt,name=tolerations"`
  ...
}

Використання JSON merge patch для оновлення Deployment

Strategic merge patch відрізняється від JSON merge patch. Якщо під час JSON merge patch потрібно оновити список, слід вказати весь новий список. Новий список повністю замінює наявний.

Команда kubectl patch має параметр type, який ви можете встановити на одне з цих значень:

Значення параметраТип злиття
jsonJSON Patch, RFC 6902
mergeJSON Merge Patch, RFC 7386
strategicStrategic merge patch

Порівняння JSON patch і JSON merge patch дивіться в JSON Patch and JSON Merge Patch.

Стандартне значення параметра type — strategic. Тож у попередній вправі ви виконали strategic merge patch.

Далі виконайте JSON merge patch для того самого Deployment. Створіть файл з назвою patch-file-2.yaml із таким вмістом:

spec:
  template:
    spec:
      containers:
      - name: patch-demo-ctr-3
        image: gcr.io/google-samples/hello-app:2.0

У вашій команді патча встановіть type на merge:

kubectl patch deployment patch-demo --type merge --patch-file patch-file-2.yaml

Перегляньте Deployment після накладання патчу:

kubectl get deployment patch-demo --output yaml

Список containers, який ви вказали у патчі, має лише один контейнер. Вивід показує, що ваш список з одним контейнером замінив наявний список containers.

spec:
  containers:
  - image: gcr.io/google-samples/hello-app:2.0
    ...
    name: patch-demo-ctr-3

Перегляньте запущені Podʼи:

kubectl get pods

У виводі ви можете побачити, що наявні 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:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: retainkeys-demo
spec:
  selector:
    matchLabels:
      app: nginx
  strategy:
    rollingUpdate:
      maxSurge: 30%
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: retainkeys-demo-ctr
        image: nginx

Створіть Deployment:

kubectl apply -f https://k8s.io/examples/application/deployment-retainkeys.yaml

На цей момент Deployment створено і використовує стратегію RollingUpdate.

Створіть файл з назвою patch-file-no-retainkeys.yaml з таким вмістом:

spec:
  strategy:
    type: Recreate

Застосуйте патч до вашого Deployment:

kubectl patch deployment retainkeys-demo --type strategic --patch-file patch-file-no-retainkeys.yaml

У виводі ви побачите, що неможливо встановити type як Recreate, коли значення визначено для spec.strategy.rollingUpdate:

The Deployment "retainkeys-demo" is invalid: spec.strategy.rollingUpdate: Forbidden: may not be specified when strategy `type` is 'Recreate'

Щоб вилучити значення spec.strategy.rollingUpdate під час оновлення значення type, використовуйте стратегію retainKeys для strategic merge patch.

Створіть ще один файл з назвою patch-file-retainkeys.yaml з таким вмістом:

spec:
  strategy:
    $retainKeys:
    - type
    type: Recreate

Цим патчем ми вказуємо, що хочемо зберегти лише ключ type обʼєкта strategy. Таким чином, під час операції патча rollingUpdate буде вилучено.

Знову застосуйте патч до вашого Deployment з цим новим патчем:

kubectl patch deployment retainkeys-demo --type strategic --patch-file patch-file-retainkeys.yaml

Дослідіть вміст Deployment:

kubectl get deployment retainkeys-demo --output yaml

У виводі показано, що обʼєкт стратегії в Deployment більше не містить ключа rollingUpdate:

spec:
  strategy:
    type: Recreate
  template:

Примітки щодо strategic merge patch зі стратегією retainKeys

Патч, який ви виконали в попередній вправі, називається strategic merge patch зі стратегією retainKeys. Цей метод вводить нову директиву $retainKeys, що має такі стратегії:

  • Вона містить список рядків.
  • Усі поля, які потрібно зберегти, повинні бути присутні в списку $retainKeys.
  • Присутні поля буде обʼєднано з живим обʼєктом.
  • Всі відсутні поля будуть очищені під час застосування патча.
  • Усі поля у списку $retainKeys повинні бути надмножиною або такими ж, як і поля, що присутні в патчі.

Стратегія retainKeys працює не для всіх обʼєктів. Вона працює лише тоді, коли значення ключа patchStrategy у теґу поля у вихідному коді Kubernetes містить retainKeys. Наприклад, поле Strategy структури DeploymentSpec має patchStrategy зі значенням retainKeys:

type DeploymentSpec struct {
  ...
  // +patchStrategy=retainKeys
  Strategy DeploymentStrategy `json:"strategy,omitempty" patchStrategy:"retainKeys" ...`
  ...
}

Ви також можете побачити стратегію retainKeys в специфікації OpenApi:

"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"
    },
    ....
}

Також стратегію retainKeys можна побачити в документації Kubernetes API.

Альтернативні форми команди kubectl patch

Команда kubectl patch приймає YAML або JSON. Вона може приймати патч як файл або безпосередньо в командному рядку.

Створіть файл з назвою patch-file.json з таким вмістом:

{
   "spec": {
      "template": {
         "spec": {
            "containers": [
               {
                  "name": "patch-demo-ctr-2",
                  "image": "redis"
               }
            ]
         }
      }
   }
}

Наведені нижче команди еквівалентні:

kubectl patch deployment patch-demo --patch-file patch-file.yaml
kubectl patch deployment patch-demo --patch 'spec:\n template:\n  spec:\n   containers:\n   - name: patch-demo-ctr-2\n     image: redis'

kubectl patch deployment patch-demo --patch-file patch-file.json
kubectl patch deployment patch-demo --patch '{"spec": {"template": {"spec": {"containers": [{"name": "patch-demo-ctr-2","image": "redis"}]}}}}'

Оновлення кількості реплік обʼєкта за допомогою 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.

Ось маніфест для Deployment, що має дві репліки:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  selector:
    matchLabels:
      app: nginx
  replicas: 2 # tells deployment to run 2 pods matching the template
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.14.2
        ports:
        - containerPort: 80

Створіть Deployment:

kubectl apply -f https://k8s.io/examples/application/deployment.yaml

Перегляньте Podʼи, повʼязані з вашим Deployment:

kubectl get pods -l app=nginx

У виводі видно, що Deployment має два Podʼи. Наприклад:

NAME                                READY   STATUS    RESTARTS   AGE
nginx-deployment-7fb96c846b-22567   1/1     Running   0          47s
nginx-deployment-7fb96c846b-mlgns   1/1     Running   0          47s

Тепер застосуйте патч до Deployment з прапорцем --subresource=[subresource-name]:

kubectl patch deployment nginx-deployment --subresource='scale' --type='merge' -p '{"spec":{"replicas":3}}'

Вивід:

scale.autoscaling/nginx-deployment patched

Перегляньте Podʼи, повʼязані з вашим Deployment після патчу:

kubectl get pods -l app=nginx

У виводі видно, що створено один новий Pod, тож тепер у вас 3 запущені Podʼи.

NAME                                READY   STATUS    RESTARTS   AGE
nginx-deployment-7fb96c846b-22567   1/1     Running   0          107s
nginx-deployment-7fb96c846b-lxfr2   1/1     Running   0          14s
nginx-deployment-7fb96c846b-mlgns   1/1     Running   0          107s

Перегляньте Deployment після патчу:

kubectl get deployment nginx-deployment -o yaml
...
spec:
  replicas: 3
  ...
status:
  ...
  availableReplicas: 3
  readyReplicas: 3
  replicas: 3

Примітка:

Якщо ви запускаєте 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.

See Enable Or Disable Feature Gates for more information.

Kubernetes покладається на активне переписування даних API для підтримки деяких операцій обслуговування, повʼязаних зі зберіганням у стані спокою. Два помітні приклади — версійна схема збережених ресурсів (тобто зміна бажаної схеми зберігання з v1 на v2 для певного ресурсу) та шифрування у стані спокою (тобто перезапис застарілих даних через зміну способу шифрування даних).

Виконання міграції версій сховища гарантує, що всі обʼєкти ресурсу перенесено із застарілої версії сховища. Вимога до виконання міграції сховища — ресурс повинен мати цілочисельну версію ресурсу. Усі ресурси Kubernetes і CRD гарантовано мають цю властивість, але міграція завершиться збоєм, якщо це не так, наприклад для агрегованих API.

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

Встановіть kubectl.

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

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

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

Функціональна можливість StorageVersionMigrator та REST API storagemigration.k8s.io/v1 стандартно увімкнені в усіх кластерах.

Повторне шифрування Secrets Kubernetes за допомогою міграції версій сховища

  • Спочатку налаштуйте постачальника KMS для шифрування даних у стані спокою в etcd за допомогою такої конфігурації шифрування.

    kind: EncryptionConfiguration
    apiVersion: apiserver.config.k8s.io/v1
    resources:
    - resources:
      - secrets
      providers:
      - aescbc:
          keys:
          - name: key1
            secret: c2VjcmV0IGlzIHNlY3VyZQ==
    

    Обовʼязково увімкніть автоматичне перезавантаження файлу конфігурації шифрування, встановивши --encryption-provider-config-automatic-reload у true.

  • Створіть Secret за допомогою kubectl.

    kubectl create secret generic my-secret --from-literal=key1=supersecret
    
  • Перевірте, що серіалізовані дані цього обʼєкта Secret починаються з k8s:enc:aescbc:v1:key1.

  • Оновіть файл конфігурації шифрування таким чином, щоб виконати ротацію ключа шифрування.

    kind: EncryptionConfiguration
    apiVersion: apiserver.config.k8s.io/v1
    resources:
    - resources:
      - secrets
      providers:
      - aescbc:
          keys:
          - name: key2
            secret: c2VjcmV0IGlzIHNlY3VyZSwgaXMgaXQ/
      - aescbc:
          keys:
          - name: key1
            secret: c2VjcmV0IGlzIHNlY3VyZQ==
    
  • Щоб забезпечити повторне шифрування раніше створеного Secret my-secret новим ключем key2, ви використаєте Storage Version Migration.

  • Створіть маніфест StorageVersionMigration з назвою migrate-secret.yaml з таким вмістом:

    kind: StorageVersionMigration
    apiVersion: storagemigration.k8s.io/v1
    metadata:
      name: secrets-migration
    spec:
      resource:
        group: ""
        resource: secrets
    

    Створіть обʼєкт за допомогою kubectl таким чином:

    kubectl apply -f migrate-secret.yaml
    
  • Стежте за міграцією Secrets, перевіряючи .status обʼєкта StorageVersionMigration. Успішна міграція повинна мати стан Succeeded зі значенням true. Отримайте обʼєкт StorageVersionMigration таким чином:

    kubectl wait --for=condition=Succeeded storageversionmigration.storagemigration.k8s.io/secrets-migration
    

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

    kind: StorageVersionMigration
    apiVersion: storagemigration.k8s.io/v1
    metadata:
      name: secrets-migration
      uid: 628f6922-a9cb-4514-b076-12d3c178967c
      resourceVersion: "90"
      creationTimestamp: "2024-03-12T20:29:45Z"
    spec:
      resource:
        group: ""
        resource: secrets
    status:
      conditions:
      - type: Running
        status: "False"
        lastUpdateTime: "2024-03-12T20:29:46Z"
        reason: StorageVersionMigrationInProgress
      - type: Succeeded
        status: "True"
        lastUpdateTime: "2024-03-12T20:29:46Z"
        reason: StorageVersionMigrationSucceeded
      resourceVersion: "84"
    
  • Перевірте, що збережений 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 з таким вмістом:

    apiVersion: apiextensions.k8s.io/v1
    kind: CustomResourceDefinition
    metadata:
      name: selfierequests.example.com
    spec:
      group: example.com
      names:
        plural: selfierequests
        singular: selfierequest
        kind: SelfieRequest
        listKind: SelfieRequestList
      scope: Namespaced
      versions:
      - name: v1
        served: true
        storage: true
        schema:
          openAPIV3Schema:
            type: object
            properties:
              hostPort:
                type: string
      conversion:
        strategy: Webhook
        webhook:
          clientConfig:
            url: "https://127.0.0.1:9443/crdconvert"
            caBundle: <CABundle info>
        conversionReviewVersions:
        - v1
        - v2
    

    Збережена версія на цей момент має бути v1, переконайтеся в цьому, виконавши:

    kubectl get crd selfierequests.example.com -o jsonpath='{.spec.versions[?(@.storage==true)].name}'
    

    Створіть CRD за допомогою kubectl:

    kubectl apply -f test-crd.yaml
    
  • Створіть маніфест для прикладу testcrd. Назвіть маніфест cr1.yaml і використайте такий вміст:

    apiVersion: example.com/v1
    kind: SelfieRequest
    metadata:
      name: cr1
      namespace: default
    

    Створіть CR за допомогою kubectl:

    kubectl apply -f cr1.yaml
    
  • Перевірте, що CR записано і збережено як v1, отримавши обʼєкт з etcd.

    ETCDCTL_API=3 etcdctl get /kubernetes.io/example.com/testcrds/default/cr1 [...] | hexdump -C
    

    де [...] містить додаткові аргументи для зʼєднання із сервером etcd.

  • Оновіть CRD test-crd.yaml, щоб додати версію v2 для обслуговування й зберігання, а v1 залишити лише для обслуговування, таким чином:

    apiVersion: apiextensions.k8s.io/v1
    kind: CustomResourceDefinition
    metadata:
      name: selfierequests.example.com
    spec:
      group: example.com
      names:
        plural: selfierequests
        singular: selfierequest
        kind: SelfieRequest
        listKind: SelfieRequestList
      scope: Namespaced
      versions:
        - name: v2
          served: true
          storage: true
          schema:
            openAPIV3Schema:
              type: object
              properties:
                host:
                  type: string
                port:
                  type: string
        - name: v1
          served: true
          storage: false
          schema:
            openAPIV3Schema:
              type: object
              properties:
                hostPort:
                  type: string
      conversion:
        strategy: Webhook
        webhook:
          clientConfig:
            url: "https://127.0.0.1:9443/crdconvert"
            caBundle: <CABundle info>
          conversionReviewVersions:
            - v1
            - v2
    

    Збережена версія тепер має бути v2, переконайтеся в цьому:

    kubectl get crd selfierequests.example.com -o jsonpath='{.spec.versions[?(@.storage==true)].name}'
    

    Оновіть CRD за допомогою kubectl:

    kubectl apply -f test-crd.yaml
    
  • Створіть файл ресурсу CR з назвою cr2.yaml з таким вмістом:

    apiVersion: example.com/v2
    kind: SelfieRequest
    metadata:
      name: cr2
      namespace: default
    
  • Створіть CR за допомогою kubectl:

    kubectl apply -f cr2.yaml
    
  • Перевірте, що CR записано і збережено як v2, отримавши обʼєкт з etcd.

    ETCDCTL_API=3 etcdctl get /kubernetes.io/example.com/testcrds/default/cr2 [...] | hexdump -C
    

    де [...] містить додаткові аргументи для зʼєднання із сервером etcd.

  • Створіть маніфест StorageVersionMigration з назвою migrate-crd.yaml з таким вмістом:

    kind: StorageVersionMigration
    apiVersion: storagemigration.k8s.io/v1
    metadata:
      name: crdsvm
    spec:
      resource:
        group: example.com
        resource: selfierequests
    

    Створіть обʼєкт за допомогою kubectl таким чином:

    kubectl apply -f migrate-crd.yaml
    
  • Стежте за міграцією Secrets за допомогою статусу. Успішна міграція повинна мати стан Succeeded зі значенням "True" у полі статусу. Отримайте ресурс міграції таким чином:

    kubectl get storageversionmigration.storagemigration.k8s.io/crdsvm -o yaml
    

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

    kind: StorageVersionMigration
    apiVersion: storagemigration.k8s.io/v1
    metadata:
      name: crdsvm
      uid: 13062fe4-32d7-47cc-9528-5067fa0c6ac8
      resourceVersion: "111"
      creationTimestamp: "2024-03-12T22:40:01Z"
    spec:
      resource:
        group: example.com
        resource: testcrds
    status:
      conditions:
        - type: Running
          status: "False"
          lastUpdateTime: "2024-03-12T22:40:03Z"
          reason: StorageVersionMigrationInProgress
        - type: Succeeded
          status: "True"
          lastUpdateTime: "2024-03-12T22:40:03Z"
          reason: StorageVersionMigrationSucceeded
      resourceVersion: "106"
    
  • Перевірте, що раніше створений cr1 тепер записано й збережено як v2, отримавши обʼєкт з etcd.

    ETCDCTL_API=3 etcdctl get /kubernetes.io/example.com/testcrds/default/cr1 [...] | hexdump -C
    

    де [...] містить додаткові аргументи для зʼєднання із сервером etcd.

  • Також перевірте, що статус збереженої версії CRD тепер лише v2:

    kubectl get crd testcrds.example.com -o yaml
    

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

    kind: CustomResourceDefinition
    apiVersion: apiextensions.k8s.io/v1
    metadata:
      name: testcrds.example.com
    spec:
      group: example.com
      names:
        kind: TestCRD
        plural: testcrds
      scope: Namespaced
      versions:
        - name: v1
          served: true
          storage: false
        - name: v2
          served: true
          storage: true
    status:
      acceptedNames:
        kind: TestCRD
        plural: testcrds
      conditions:
        - type: Established
          status: "True"
      storedVersions:
        - v2
    

6 - Керування Secrets

Керування конфіденційними даними налаштувань за допомогою Secrets.

6.1 - Керування Secrets за допомогою kubectl

Створення обʼєктів Secret за допомогою командного рядка kubectl.

На цій сторінці показано, як створювати й редагувати Secrets Kubernetes, керувати ними та видаляти їх за допомогою інструмента командного рядка kubectl.

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

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

Створення Secret

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

Ви можете створити Secret, передавши необроблені дані в команді або зберігши облікові дані у файлах, які ви передаєте в команді. Наведені нижче команди створюють Secret, який зберігає імʼя користувача admin і пароль S!B\*d$zDsb=.

Використання необроблених даних

Виконайте таку команду:

kubectl create secret generic db-user-pass \
    --from-literal=username=admin \
    --from-literal=password='S!B\*d$zDsb='

Щоб екранувати спеціальні символи, такі як $, \, *, = і !, у рядках, потрібно використовувати одинарні лапки ''. Інакше ваша оболонка інтерпретуватиме ці символи.

Примітка:

Поле stringData у Secret погано працює із застосуванням на боці сервера (server-side apply).

Використання вихідних файлів

  1. Збережіть облікові дані у файлах:

    echo -n 'admin' > ./username.txt
    echo -n 'S!B\*d$zDsb=' > ./password.txt
    

    Прапорець -n гарантує, що згенеровані файли не матимуть зайвого символу нового рядка в кінці тексту. Це важливо, бо коли kubectl читає файл і кодує вміст у рядок base64, зайвий символ нового рядка теж кодується. Спеціальні символи в рядках, які ви додаєте у файл, екранувати не потрібно.

  2. Передайте шляхи до файлів у команду kubectl:

    kubectl create secret generic db-user-pass \
        --from-file=./username.txt \
        --from-file=./password.txt
    

    Стандартно назвою ключа є назва файлу. За потреби ви можете задати назву ключа за допомогою --from-file=[key=]source. Наприклад:

    kubectl create secret generic db-user-pass \
        --from-file=username=./username.txt \
        --from-file=password=./password.txt
    

За будь-якого способу вивід подібний до такого:

secret/db-user-pass created

Перевірка Secret

Перевірте, що Secret створено:

kubectl get secrets

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

NAME              TYPE       DATA      AGE
db-user-pass      Opaque     2         51s

Перегляньте подробиці Secret:

kubectl describe secret db-user-pass

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

Name:            db-user-pass
Namespace:       default
Labels:          <none>
Annotations:     <none>

Type:            Opaque

Data
====
password:    12 bytes
username:    5 bytes

Команди kubectl get і kubectl describe стандартно не показують вміст Secret. Це захищає Secret від випадкового розкриття або збереження в логах термінала.

Розкодування Secret

  1. Перегляньте вміст створеного вами Secret:

    kubectl get secret db-user-pass -o jsonpath='{.data}'
    

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

    { "password": "UyFCXCpkJHpEc2I9", "username": "YWRtaW4=" }
    
  2. Розкодуйте дані password:

    echo 'UyFCXCpkJHpEc2I9' | base64 --decode
    

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

    S!B\*d$zDsb=
    

    Увага:

    Це приклад для цілей документації. На практиці цей спосіб може призвести до збереження команди із закодованими даними в історії оболонки. Будь-хто з доступом до вашого компʼютера може знайти цю команду й розкодувати 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: v1
data:
  password: UyFCXCpkJHpEc2I9
  username: YWRtaW4=
kind: Secret
metadata:
  creationTimestamp: "2022-06-28T17:44:13Z"
  name: db-user-pass
  namespace: default
  resourceVersion: "12708504"
  uid: 91becd59-78fa-4c85-823f-6d44436242ac
type: Opaque

Очищення

Щоб видалити Secret, виконайте таку команду:

kubectl delete secret db-user-pass

Що далі

6.2 - Керування Secrets за допомогою файлу конфігурації

Створення обʼєктів Secret за допомогою файлу конфігурації ресурсу.

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

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

Створення Secret

Ви можете спочатку визначити обʼєкт Secret у маніфесті у форматі JSON або YAML, а потім створити цей обʼєкт. Ресурс Secret містить два словники: data і stringData. Поле data використовується для зберігання довільних даних, закодованих у base64. Поле stringData надається для зручності й дозволяє вказувати ті самі дані у вигляді незакодованих рядків. Ключі data і stringData мають складатися з буквено-цифрових символів, -, _ або ..

Наведений нижче приклад зберігає два рядки в Secret за допомогою поля data.

  1. Перетворіть рядки на base64:

    echo -n 'admin' | base64
    echo -n '1f2d1e2e67df' | base64
    

    Примітка:

    Серіалізовані значення JSON і YAML даних Secret кодуються як рядки base64. Символи нового рядка в цих рядках неприпустимі й мають бути вилучені. Під час використання утиліти base64 у Darwin/macOS користувачам слід уникати параметра -b для розбиття довгих рядків. Натомість користувачам Linux слід додавати параметр -w 0 до команд base64 або використовувати конвеєр base64 | tr -d '\n', якщо параметр -w недоступний.

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

    YWRtaW4=
    MWYyZDFlMmU2N2Rm
    
  2. Створіть маніфест:

    apiVersion: v1
    kind: Secret
    metadata:
      name: mysecret
    type: Opaque
    data:
      username: YWRtaW4=
      password: MWYyZDFlMmU2N2Rm
    

    Зверніть увагу, що назва обʼєкта Secret має бути дійсною назвою піддомену DNS.

  3. Створіть Secret за допомогою kubectl apply:

    kubectl apply -f ./secret.yaml
    

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

    secret/mysecret created
    

Щоб перевірити, що Secret створено, і розкодувати дані Secret, дивіться Керування Secrets за допомогою kubectl.

Вказання незакодованих даних під час створення Secret

У деяких сценаріях ви можете натомість використовувати поле stringData. Це поле дозволяє розмістити рядок без кодування base64 безпосередньо в Secret, і цей рядок буде закодовано автоматично під час створення або оновлення Secret.

Практичний приклад: ви розгортаєте застосунок, який використовує Secret для зберігання файлу конфігурації, і хочете заповнити частини цього файлу конфігурації під час розгортання.

Наприклад, якщо ваш застосунок використовує такий файл конфігурації:

apiUrl: "https://my.api.com/api/v1"
username: "<user>"
password: "<password>"

Ви можете зберегти це в Secret, використовуючи таке визначення:

apiVersion: v1
kind: Secret
metadata:
  name: mysecret
type: Opaque
stringData:
  config.yaml: |
    apiUrl: "https://my.api.com/api/v1"
    username: <user>
    password: <password>

Примітка:

Поле stringData у Secret погано працює із застосуванням на боці сервера (server-side apply).

Коли ви отримуєте дані Secret, команда повертає закодовані значення, а не відкритий текст, який ви вказали в stringData.

Наприклад, якщо ви виконаєте таку команду:

kubectl get secret mysecret -o yaml

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

apiVersion: v1
data:
  config.yaml: YXBpVXJsOiAiaHR0cHM6Ly9teS5hcGkuY29tL2FwaS92MSIKdXNlcm5hbWU6IHt7dXNlcm5hbWV9fQpwYXNzd29yZDoge3twYXNzd29yZH19
kind: Secret
metadata:
  creationTimestamp: 2018-11-15T20:40:59Z
  name: mysecret
  namespace: default
  resourceVersion: "7225"
  uid: c280ad2e-e916-11e8-98f2-025000000001
type: Opaque

Вказання як data, так і stringData

Якщо ви вкажете поле і в data, і в stringData, буде використано значення зі stringData.

Наприклад, якщо ви визначите такий Secret:

apiVersion: v1
kind: Secret
metadata:
  name: mysecret
type: Opaque
data:
  username: YWRtaW4=
stringData:
  username: administrator

Примітка:

Поле stringData у Secret погано працює із застосуванням на боці сервера (server-side apply).

Обʼєкт Secret буде створено так:

apiVersion: v1
data:
  username: YWRtaW5pc3RyYXRvcg==
kind: Secret
metadata:
  creationTimestamp: 2018-11-15T20:46:46Z
  name: mysecret
  namespace: default
  resourceVersion: "7579"
  uid: 91460ecb-e917-11e8-98f2-025000000001
type: Opaque

YWRtaW5pc3RyYXRvcg== розкодовується в administrator.

Редагування Secret

Щоб відредагувати дані в Secret, створеному за допомогою маніфесту, змініть поле data або stringData у маніфесті й застосуйте файл до кластера. Ви можете редагувати наявний обʼєкт Secret, якщо він не є незмінним.

Наприклад, якщо ви хочете змінити пароль із попереднього прикладу на birdsarentreal, зробіть таке:

  1. Закодуйте новий рядок пароля:

    echo -n 'birdsarentreal' | base64
    

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

    YmlyZHNhcmVudHJlYWw=
    
  2. Оновіть поле data, вказавши новий рядок пароля:

    apiVersion: v1
    kind: Secret
    metadata:
      name: mysecret
    type: Opaque
    data:
      username: YWRtaW4=
      password: YmlyZHNhcmVudHJlYWw=
    
  3. Застосуйте маніфест до кластера:

    kubectl apply -f ./secret.yaml
    

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

    secret/mysecret configured
    

Kubernetes оновлює наявний обʼєкт Secret. Докладніше: інструмент kubectl помічає, що вже існує обʼєкт Secret із такою самою назвою. kubectl отримує наявний обʼєкт, планує зміни в ньому й надсилає змінений обʼєкт Secret до панелі управління кластера.

Якщо натомість ви вказали kubectl apply --server-side, kubectl використовує застосування на боці сервера.

Очищення

Щоб видалити створений вами Secret:

kubectl delete secret mysecret

Що далі

6.3 - Керування Secrets за допомогою Kustomize

Створення обʼєктів Secret за допомогою файлу kustomization.yaml.

kubectl підтримує використання інструмента керування обʼєктами Kustomize для керування Secrets і ConfigMaps. За допомогою Kustomize ви створюєте генератор ресурсів, який генерує Secret, що його можна застосувати до API-сервера за допомогою kubectl.

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

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

Створення Secret

Ви можете згенерувати Secret, визначивши secretGenerator у файлі kustomization.yaml, який посилається на інші наявні файли, файли .env або літеральні значення. Наприклад, наведені нижче інструкції створюють файл kustomization для імені користувача admin і пароля 1f2d1e2e67df.

Примітка:

Поле stringData у Secret погано працює із застосуванням на боці сервера (server-side apply).

Створення файлу kustomization


secretGenerator:
- name: database-creds
  literals:
  - username=admin
  - password=1f2d1e2e67df
  1. Збережіть облікові дані у файлах. Назви файлів є ключами Secret:

    echo -n 'admin' > ./username.txt
    echo -n '1f2d1e2e67df' > ./password.txt
    

    Прапорець -n гарантує, що в кінці ваших файлів немає символу нового рядка.

  2. Створіть файл kustomization.yaml:

    secretGenerator:
    - name: database-creds
      files:
      - username.txt
      - password.txt
    

Ви також можете визначити secretGenerator у файлі kustomization.yaml, надавши файли .env. Наприклад, наведений нижче файл kustomization.yaml отримує дані з файлу .env.secret:

secretGenerator:
- name: db-user-pass
  envs:
  - .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}'

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

{ "password": "MWYyZDFlMmU2N2Rm", "username": "YWRtaW4=" }
echo 'MWYyZDFlMmU2N2Rm' | base64 --decode

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

1f2d1e2e67df

Докладніше дивіться Керування Secrets за допомогою kubectl і Декларативне керування обʼєктами Kubernetes за допомогою Kustomize.

Редагування Secret

  1. У файлі kustomization.yaml змініть дані, наприклад password.

  2. Застосуйте теку, яка містить файл kustomization:

    kubectl apply -k <directory-path>
    

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

    secret/db-user-pass-6f24b56cc8 created
    

Змінений Secret створюється як новий обʼєкт Secret, а не оновлює наявний обʼєкт Secret. Можливо, вам доведеться оновити посилання на Secret у ваших Podʼах.

Очищення

Щоб видалити Secret, використайте kubectl:

kubectl delete secret db-user-pass

Що далі

7 - Введення даних у застосунки

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

7.1 - Визначення команди та аргументів для контейнера

На цій сторінці показано, як визначати команди й аргументи під час запуску контейнера в Pod.

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

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

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

Визначення команди та аргументів під час створення Podʼа

Під час створення Podʼа ви можете визначити команду й аргументи для контейнерів, які працюють у Podʼі. Щоб визначити команду, додайте поле command у файл конфігурації. Щоб визначити аргументи команди, додайте поле args у файл конфігурації. Команду й аргументи, які ви визначили, не можна змінити після створення Podʼа.

Команда й аргументи, які ви визначаєте у файлі конфігурації, перевизначають стандартну команду й аргументи, надані образом контейнера. Якщо ви визначаєте args, але не визначаєте команду, використовується стандартна команда з вашими новими аргументами.

Примітка:

Поле command відповідає ENTRYPOINT, а поле args — CMD у деяких середовищах виконання контейнерів.

У цій вправі ви створите Pod, який запускає один контейнер. Файл конфігурації Podʼа визначає команду й два аргументи:

apiVersion: v1
kind: Pod
metadata:
  name: command-demo
  labels:
    purpose: demonstrate-command
spec:
  containers:
  - name: command-demo-container
    image: debian
    command: ["printenv"]
    args: ["HOSTNAME", "KUBERNETES_PORT"]
  restartPolicy: OnFailure
  1. Створіть Pod на основі файлу конфігурації YAML:

    kubectl apply -f https://k8s.io/examples/pods/commands.yaml
    
  2. Перегляньте список запущених Podʼів:

    kubectl get pods
    

    Вивід показує, що контейнер, який працював у Podʼі command-demo, завершився.

  3. Щоб побачити вивід команди, яка виконувалася в контейнері, перегляньте логи Podʼа:

    kubectl logs command-demo
    

    Вивід показує значення змінних середовища HOSTNAME та KUBERNETES_PORT:

    command-demo
    tcp://10.3.240.1:443
    

Використання змінних середовища для визначення аргументів

У попередньому прикладі ви визначили аргументи безпосередньо, вказавши рядки. Замість прямого вказування рядків ви можете визначати аргументи за допомогою змінних середовища:

env:
- name: MESSAGE
  value: "hello world"
command: ["/bin/echo"]
args: ["$(MESSAGE)"]

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

Примітка:

Змінна середовища вказується в дужках, "$(VAR)". Це потрібно, щоб змінна розгорталася в полі command або args.

Виконання команди в оболонці

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

command: ["/bin/sh"]
args: ["-c", "while true; do echo hello; sleep 10;done"]

Що далі

7.2 - Визначення залежних змінних середовища

На цій сторінці показано, як визначати залежні змінні середовища для контейнера в Podʼі Kubernetes.

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

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

Визначення залежної змінної середовища для контейнера

Під час створення Podʼа ви можете встановлювати залежні змінні середовища для контейнерів, які працюють у Podʼі. Для цього можна використовувати $(VAR_NAME) у value поля env у файлі конфігурації.

У цій вправі ви створите Pod, який запускає один контейнер. Файл конфігурації Podʼа визначає залежну змінну середовища з поширеним способом використання. Ось маніфест конфігурації Podʼа:

apiVersion: v1
kind: Pod
metadata:
  name: dependent-envars-demo
spec:
  containers:
    - name: dependent-envars-demo
      args:
        - while true; do echo -en '\n'; printf UNCHANGED_REFERENCE=$UNCHANGED_REFERENCE'\n'; printf SERVICE_ADDRESS=$SERVICE_ADDRESS'\n';printf ESCAPED_REFERENCE=$ESCAPED_REFERENCE'\n'; sleep 30; done;
      command:
        - sh
        - -c
      image: busybox:1.28
      env:
        - name: SERVICE_PORT
          value: "80"
        - name: SERVICE_IP
          value: "172.17.0.1"
        - name: UNCHANGED_REFERENCE
          value: "$(PROTOCOL)://$(SERVICE_IP):$(SERVICE_PORT)"
        - name: PROTOCOL
          value: "https"
        - name: SERVICE_ADDRESS
          value: "$(PROTOCOL)://$(SERVICE_IP):$(SERVICE_PORT)"
        - name: ESCAPED_REFERENCE
          value: "$$(PROTOCOL)://$(SERVICE_IP):$(SERVICE_PORT)"
  1. Створіть Pod на основі цього маніфесту:

    kubectl apply -f https://k8s.io/examples/pods/inject/dependent-envars.yaml
    
    pod/dependent-envars-demo created
    
  2. Перегляньте список запущених Podʼів:

    kubectl get pods dependent-envars-demo
    
    NAME                      READY     STATUS    RESTARTS   AGE
    dependent-envars-demo     1/1       Running   0          9s
    
  3. Перевірте логи контейнера, що працює у вашому Podʼі:

    kubectl logs pod/dependent-envars-demo
    
    UNCHANGED_REFERENCE=$(PROTOCOL)://172.17.0.1:80
    SERVICE_ADDRESS=https://172.17.0.1:80
    ESCAPED_REFERENCE=$(PROTOCOL)://172.17.0.1:80
    

Як показано вище, ви визначили правильне посилання на залежність 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 задаються як змінні середовища контейнера. Ви також можете вказати спільний префікс.

Докладніше про ConfigMap та Secret.

На цій сторінці пояснено, як використовувати env.

У цій вправі ви створите Pod, який запускає один контейнер. Файл конфігурації Podʼа визначає змінну середовища з назвою DEMO_GREETING і значенням "Hello from the environment". Ось маніфест конфігурації Podʼа:

apiVersion: v1
kind: Pod
metadata:
  name: envar-demo
  labels:
    purpose: demonstrate-envars
spec:
  containers:
  - name: envar-demo-container
    image: gcr.io/google-samples/hello-app:2.0
    env:
    - name: DEMO_GREETING
      value: "Hello from the environment"
    - name: DEMO_FAREWELL
      value: "Such a sweet sorrow"
  1. Створіть Pod на основі цього маніфесту:

    kubectl apply -f https://k8s.io/examples/pods/inject/envars.yaml
    
  2. Перегляньте перелік запущених Podʼів:

    kubectl get pods -l purpose=demonstrate-envars
    

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

    NAME            READY     STATUS    RESTARTS   AGE
    envar-demo      1/1       Running   0          9s
    
  3. Виведіть змінні середовища контейнера 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.

Назви змінних середовища можуть складатися з будь-яких друкованих символів ASCII, окрім '='.

apiVersion: v1
kind: Pod
metadata:
  name: print-greeting
spec:
  containers:
  - name: env-print-demo
    image: bash
    env:
    - name: GREETING
      value: "Warm greetings to"
    - name: HONORIFIC
      value: "The Most Honorable"
    - name: NAME
      value: "Kubernetes"
    - name: MESSAGE
      value: "$(GREETING) $(HONORIFIC) $(NAME)"
    command: ["echo"]
    args: ["$(MESSAGE)"]

Після створення в контейнері виконується команда echo Warm greetings to The Most Honorable Kubernetes.

Що далі

7.4 - Визначення значень змінних середовища за допомогою init-контейнера

СТАН ФУНКЦІОНАЛУ: Beta since Kubernetes v1.35; (стандартно увімкнено)

На цій сторінці показано, як налаштувати змінні середовища для контейнерів у Podʼі за допомогою файлу.

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

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

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

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

Як працює цей підхід

У цій вправі ви створите Pod, який отримує змінні середовища з файлів, проєцюючи ці значення в запущений контейнер.

apiVersion: v1
kind: Pod
metadata:
  name: envfile-test-pod
spec:
  initContainers:
    - name: setup-envfile
      image:  nginx
      command: ['sh', '-c', "echo \"DB_ADDRESS=\'address\'\nREST_ENDPOINT=\'endpoint\'\" > /data/config.env"]
      volumeMounts:
        - name: config
          mountPath: /data
  containers:
    - name: use-envfile
      image: nginx
      command: [ "/bin/sh", "-c", "env" ]
      env:
        - name: DB_ADDRESS
          valueFrom:
            fileKeyRef:
              path: config.env
              volumeName: config
              key: DB_ADDRESS
              optional: false
  restartPolicy: Never
  volumes:
    - name: config
      emptyDir: {}

У цьому маніфесті initContainer монтує том emptyDir і записує змінні середовища у файл усередині нього, а звичайні контейнери посилаються і на файл, і на ключ змінної середовища через поле fileKeyRef, не монтуючи том. Коли поле optional має значення false, вказаний key у fileKeyRef має існувати у файлі змінних середовища.

Том монтується лише в контейнер, який записує у файл (initContainer), а контейнер-споживач, який використовує змінну середовища, не матиме змонтованого тому.

Формат файлу env відповідає стандарту файлів env у Kubernetes.

Під час ініціалізації контейнера kubelet отримує змінні середовища зі вказаних файлів у томі emptyDir і надає їх контейнеру.

Примітка:

Усі типи контейнерів (init-контейнери, звичайні контейнери, sidecar-контейнери й ефемерні контейнери) підтримують завантаження змінних середовища з файлів.

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

Створіть Pod:

kubectl apply -f https://k8s.io/examples/pods/inject/envars-file-container.yaml

Перевірте, що контейнер у Podʼі працює:

# Якщо новий Pod ще не справний, повторіть цю команду кілька разів.
kubectl get pods

Перевірте логи контейнера на наявність змінних середовища:

kubectl logs envfile-test-pod -c use-envfile | grep DB_ADDRESS

Вивід показує значення вибраних змінних середовища:

DB_ADDRESS=address

Синтаксис файлів env

Формат файлу env, який використовує Kubernetes, є чітко визначеною підмножиною семантики змінних середовища для POSIX-сумісного bash. Будь-який файл env, який підтримує Kubernetes, створює ті самі змінні середовища, що й під час інтерпретації в POSIX-сумісному bash. Однак POSIX-сумісний bash підтримує деякі додаткові формати, які Kubernetes не приймає.

Приклад:

MY_VAR='my-literal-value'

Правила

  • Оголошення змінної: використовуйте форму VAR='value'. Пробіли навколо = ігноруються; пробіли на початку рядка ігноруються; порожні рядки ігноруються.
  • Значення в лапках: значення мають бути взяті в одинарні лапки (').
    • Вміст в одинарних лапках зберігається дослівно. Обробка екранованих послідовностей, згортання пробілів чи інтерпретація символів не застосовуються.
    • Символи нового рядка в одинарних лапках зберігаються (багаторядкові значення підтримуються).
  • Коментарі: рядки, що починаються з #, розглядаються як коментарі та ігноруються. Символ # всередині значення в одинарних лапках не є коментарем.

Приклади:

# comment
DB_ADDRESS='address'

MULTI='line1
line2'

Непідтримувані форми

  • Значення без лапок заборонені:
    • VAR=value — не підтримується.
  • Значення в подвійних лапках заборонені:
    • VAR="value" — не підтримується.
  • Кілька сусідніх рядків у лапках не підтримуються:
    • VAR='val1''val2' — не підтримується.
  • Будь-яка форма інтерполяції, розгортання або конкатенації не підтримується:
    • VAR='a'$OTHER або VAR=${OTHER} — не підтримується.

Сувора вимога щодо одинарних лапок гарантує, що kubelet сприймає значення дослівно під час завантаження змінних середовища з файлів.

Що далі

7.5 - Використання змінних середовища для передачі контейнерам інформації про Pod

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

У Kubernetes є два способи надати поля Podʼа та контейнера запущеному контейнеру:

  • Змінні середовища, як пояснено в цьому завданні
  • Файли томів

Разом ці два способи надання полів Podʼа та контейнера називаються downward API.

Оскільки Services є основним способом взаємодії між контейнеризованими застосунками, якими керує Kubernetes, корисно мати змогу виявляти їх під час виконання.

Докладніше про доступ до Services читайте тут.

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

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

Використання полів Podʼа як значень змінних середовища

У цій частині вправи ви створите Pod з одним контейнером і спроєцюєте поля рівня Podʼа в запущений контейнер як змінні середовища.

apiVersion: v1
kind: Pod
metadata:
  name: dapi-envars-fieldref
spec:
  containers:
    - name: test-container
      image: registry.k8s.io/busybox:1.27.2
      command: [ "sh", "-c"]
      args:
      - while true; do
          echo -en '\n';
          printenv MY_NODE_NAME MY_POD_NAME MY_POD_NAMESPACE;
          printenv MY_POD_IP MY_POD_SERVICE_ACCOUNT;
          sleep 10;
        done;
      env:
        - name: MY_NODE_NAME
          valueFrom:
            fieldRef:
              fieldPath: spec.nodeName
        - name: MY_POD_NAME
          valueFrom:
            fieldRef:
              fieldPath: metadata.name
        - name: MY_POD_NAMESPACE
          valueFrom:
            fieldRef:
              fieldPath: metadata.namespace
        - name: MY_POD_IP
          valueFrom:
            fieldRef:
              fieldPath: status.podIP
        - name: MY_POD_SERVICE_ACCOUNT
          valueFrom:
            fieldRef:
              fieldPath: spec.serviceAccountName
  restartPolicy: Never

У цьому маніфесті ви бачите пʼять змінних середовища. Поле env — це масив визначень змінних середовища. Перший елемент масиву вказує, що змінна середовища MY_NODE_NAME отримує значення з поля spec.nodeName Podʼа. Аналогічно інші змінні середовища отримують свої назви з полів Podʼа.

Примітка:

Поля в цьому прикладі є полями Podʼа. Вони не є полями контейнера в Podʼі.

Створіть Pod:

kubectl apply -f https://k8s.io/examples/pods/inject/dapi-envars-pod.yaml

Перевірте, що контейнер у Podʼі працює:

# Якщо новий Pod ще не справний, повторіть цю команду кілька разів.
kubectl get pods

Перегляньте логи контейнера:

kubectl logs dapi-envars-fieldref

Вивід показує значення вибраних змінних середовища:

minikube
dapi-envars-fieldref
default
172.17.0.4
default

Щоб зрозуміти, чому ці значення є в логу, подивіться на поля command і args у файлі конфігурації. Коли контейнер запускається, він записує значення пʼяти змінних середовища в stdout. Він повторює це кожні десять секунд.

Далі отримайте доступ до оболонки в контейнері, який працює у вашому Podʼі:

kubectl exec -it dapi-envars-fieldref -- sh

В оболонці перегляньте змінні середовища:

# Виконайте це в оболонці всередині контейнера
printenv

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

MY_POD_SERVICE_ACCOUNT=default
...
MY_POD_NAMESPACE=default
MY_POD_IP=172.17.0.4
...
MY_NODE_NAME=minikube
...
MY_POD_NAME=dapi-envars-fieldref

Використання полів контейнера як значень змінних середовища

У попередній вправі ви використовували інформацію з полів рівня Podʼа як значення змінних середовища. У наступній вправі ви передасте поля, які є частиною визначення Podʼа, але взяті з конкретного контейнера, а не з Podʼа загалом.

Ось маніфест іншого Podʼа, який знову має лише один контейнер:

apiVersion: v1
kind: Pod
metadata:
  name: dapi-envars-resourcefieldref
spec:
  containers:
    - name: test-container
      image: registry.k8s.io/busybox:1.27.2
      command: [ "sh", "-c"]
      args:
      - while true; do
          echo -en '\n';
          printenv MY_CPU_REQUEST MY_CPU_LIMIT;
          printenv MY_MEM_REQUEST MY_MEM_LIMIT;
          sleep 10;
        done;
      resources:
        requests:
          memory: "32Mi"
          cpu: "125m"
        limits:
          memory: "64Mi"
          cpu: "250m"
      env:
        - name: MY_CPU_REQUEST
          valueFrom:
            resourceFieldRef:
              containerName: test-container
              resource: requests.cpu
        - name: MY_CPU_LIMIT
          valueFrom:
            resourceFieldRef:
              containerName: test-container
              resource: limits.cpu
        - name: MY_MEM_REQUEST
          valueFrom:
            resourceFieldRef:
              containerName: test-container
              resource: requests.memory
        - name: MY_MEM_LIMIT
          valueFrom:
            resourceFieldRef:
              containerName: test-container
              resource: limits.memory
  restartPolicy: Never

У цьому маніфесті ви бачите чотири змінні середовища. Поле env — це масив визначень змінних середовища. Перший елемент масиву вказує, що змінна середовища MY_CPU_REQUEST отримує значення з поля requests.cpu контейнера з назвою test-container. Аналогічно інші змінні середовища отримують значення з полів, специфічних для цього контейнера.

Створіть Pod:

kubectl apply -f https://k8s.io/examples/pods/inject/dapi-envars-container.yaml

Перевірте, що контейнер у Podʼі працює:

# Якщо новий Pod ще не справний, повторіть цю команду кілька разів.
kubectl get pods

Перегляньте логи контейнера:

kubectl logs dapi-envars-resourcefieldref

Вивід показує значення вибраних змінних середовища:

1
1
33554432
67108864

Що далі

Прочитайте про Pods, контейнери та змінні середовища в застарілій довідці API:

7.6 - Передача інформації про Pod контейнерам через файли

На цій сторінці показано, як Pod може використовувати том downwardAPI, щоб передавати інформацію про себе контейнерам, які працюють у Podʼі. Том downwardAPI може надавати поля Podʼа й контейнера.

У Kubernetes є два способи надати поля Podʼа та контейнера запущеному контейнеру:

Разом ці два способи надання полів Podʼа та контейнера називаються downward API.

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

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

Зберігання полів Podʼа

У цій частині вправи ви створите Pod з одним контейнером і спроєцюєте поля рівня Podʼа в запущений контейнер як файли. Ось маніфест Podʼа:

apiVersion: v1
kind: Pod
metadata:
  name: kubernetes-downwardapi-volume-example
  labels:
    zone: us-est-coast
    cluster: test-cluster1
    rack: rack-22
  annotations:
    build: two
    builder: john-doe
spec:
  containers:
    - name: client-container
      image: registry.k8s.io/busybox:1.27.2
      command: ["sh", "-c"]
      args:
      - while true; do
          if [[ -e /etc/podinfo/labels ]]; then
            echo -en '\n\n'; cat /etc/podinfo/labels; fi;
          if [[ -e /etc/podinfo/annotations ]]; then
            echo -en '\n\n'; cat /etc/podinfo/annotations; fi;
          sleep 5;
        done;
      volumeMounts:
        - name: podinfo
          mountPath: /etc/podinfo
  volumes:
    - name: podinfo
      downwardAPI:
        items:
          - path: "labels"
            fieldRef:
              fieldPath: metadata.labels
          - path: "annotations"
            fieldRef:
              fieldPath: metadata.annotations

У маніфесті ви бачите, що Pod має том downwardAPI, а контейнер монтує цей том у /etc/podinfo.

Подивіться на масив items у downwardAPI. Кожен елемент масиву визначає том downwardAPI. Перший елемент вказує, що значення поля metadata.labels Podʼа слід зберегти у файлі з назвою labels. Другий елемент вказує, що значення поля annotations Podʼа слід зберегти у файлі з назвою annotations.

Примітка:

Поля в цьому прикладі є полями Podʼа. Вони не є полями контейнера в Podʼі.

Створіть Pod:

kubectl apply -f https://k8s.io/examples/pods/inject/dapi-volume.yaml

Перевірте, що контейнер у Podʼі працює:

kubectl get pods

Перегляньте логи контейнера:

kubectl logs kubernetes-downwardapi-volume-example

Вивід показує вміст файлів labels та annotations:

cluster="test-cluster1"
rack="rack-22"
zone="us-est-coast"

build="two"
builder="john-doe"

Отримайте доступ до оболонки в контейнері, який працює у вашому Podʼі:

kubectl exec -it kubernetes-downwardapi-volume-example -- sh

В оболонці перегляньте файл labels:

/# cat /etc/podinfo/labels

Вивід показує, що всі мітки Podʼа записано у файл labels:

cluster="test-cluster1"
rack="rack-22"
zone="us-est-coast"

Аналогічно, перегляньте файл annotations:

/# cat /etc/podinfo/annotations

Перегляньте файли у теці /etc/podinfo:

/# ls -laR /etc/podinfo

У виводі видно, що файли labels та annotations містяться в тимчасовій підтеці: у цьому прикладі ..2982_06_02_21_47_53.299460680. У теці /etc/podinfo ..data є символічним посиланням на тимчасову підтеку. Також у теці /etc/podinfo labels та 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ʼа, який знову має лише один контейнер:

apiVersion: v1
kind: Pod
metadata:
  name: kubernetes-downwardapi-volume-example-2
spec:
  containers:
    - name: client-container
      image: registry.k8s.io/busybox:1.27.2
      command: ["sh", "-c"]
      args:
      - while true; do
          echo -en '\n';
          if [[ -e /etc/podinfo/cpu_limit ]]; then
            echo -en '\n'; cat /etc/podinfo/cpu_limit; fi;
          if [[ -e /etc/podinfo/cpu_request ]]; then
            echo -en '\n'; cat /etc/podinfo/cpu_request; fi;
          if [[ -e /etc/podinfo/mem_limit ]]; then
            echo -en '\n'; cat /etc/podinfo/mem_limit; fi;
          if [[ -e /etc/podinfo/mem_request ]]; then
            echo -en '\n'; cat /etc/podinfo/mem_request; fi;
          sleep 5;
        done;
      resources:
        requests:
          memory: "32Mi"
          cpu: "125m"
        limits:
          memory: "64Mi"
          cpu: "250m"
      volumeMounts:
        - name: podinfo
          mountPath: /etc/podinfo
  volumes:
    - name: podinfo
      downwardAPI:
        items:
          - path: "cpu_limit"
            resourceFieldRef:
              containerName: client-container
              resource: limits.cpu
              divisor: 1m
          - path: "cpu_request"
            resourceFieldRef:
              containerName: client-container
              resource: requests.cpu
              divisor: 1m
          - path: "mem_limit"
            resourceFieldRef:
              containerName: client-container
              resource: limits.memory
              divisor: 1Mi
          - path: "mem_request"
            resourceFieldRef:
              containerName: client-container
              resource: requests.memory
              divisor: 1Mi

У маніфесті ви бачите, що Pod має том downwardAPI, а єдиний контейнер у цьому Podʼі монтує цей том у /etc/podinfo.

Подивіться на масив items у downwardAPI. Кожен елемент масиву визначає файл у томі downward API.

Перший елемент вказує, що в контейнері з назвою client-container значення поля limits.cpu у форматі, заданому 1m, слід опублікувати як файл із назвою cpu_limit. Поле divisor необовʼязкове й має стандартне значення 1. Дільник 1 означає ядра для ресурсів cpu або байти для ресурсів memory.

Створіть Pod:

kubectl apply -f https://k8s.io/examples/pods/inject/dapi-volume-resources.yaml

Отримайте доступ до оболонки в контейнері, який працює у вашому 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/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  selector:
    matchLabels:
      app: nginx
  replicas: 2 # tells deployment to run 2 pods matching the template
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.14.2
        ports:
        - containerPort: 80
  1. Створіть Deployment на основі файлу YAML:

    kubectl apply -f https://k8s.io/examples/application/deployment.yaml
    
  2. Виведіть інформацію про Deployment:

    kubectl describe deployment nginx-deployment
    

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

    Name:     nginx-deployment
    Namespace:    default
    CreationTimestamp:  Tue, 30 Aug 2016 18:11:37 -0700
    Labels:     app=nginx
    Annotations:    deployment.kubernetes.io/revision=1
    Selector:   app=nginx
    Replicas:   2 desired | 2 updated | 2 total | 2 available | 0 unavailable
    StrategyType:   RollingUpdate
    MinReadySeconds:  0
    RollingUpdateStrategy:  1 max unavailable, 1 max surge
    Pod Template:
      Labels:       app=nginx
      Containers:
        nginx:
        Image:              nginx:1.14.2
        Port:               80/TCP
        Environment:        <none>
        Mounts:             <none>
      Volumes:              <none>
    Conditions:
      Type          Status  Reason
      ----          ------  ------
      Available     True    MinimumReplicasAvailable
      Progressing   True    NewReplicaSetAvailable
    OldReplicaSets:   <none>
    NewReplicaSet:    nginx-deployment-1771418926 (2/2 replicas created)
    No events.
    
  3. Перегляньте Podʼи, створені Deployment:

    kubectl get pods -l app=nginx
    

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

    NAME                                READY     STATUS    RESTARTS   AGE
    nginx-deployment-1771418926-7o5ns   1/1       Running   0          16h
    nginx-deployment-1771418926-r18az   1/1       Running   0          16h
    
  4. Виведіть інформацію про Pod:

    kubectl describe pod <pod-name>
    

    де <pod-name> — це назва одного з ваших Podʼів.

Оновлення Deployment

Ви можете оновити Deployment, застосувавши новий файл YAML. Цей файл YAML вказує, що Deployment слід оновити до nginx 1.16.1.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  selector:
    matchLabels:
      app: nginx
  replicas: 2
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.16.1 # Update the version of nginx from 1.14.2 to 1.16.1
        ports:
        - containerPort: 80
  1. Застосуйте новий файл YAML:

    kubectl apply -f https://k8s.io/examples/application/deployment-update.yaml
    
  2. Спостерігайте, як Deployment створює Podʼи з новими назвами й видаляє старі Podʼи:

    kubectl get pods -l app=nginx
    

Масштабування застосунку шляхом збільшення кількості реплік

Ви можете збільшити кількість Podʼів у вашому Deployment, застосувавши новий файл YAML. Цей файл YAML встановлює replicas на 4, що означає, що Deployment повинен мати чотири Podʼи:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  selector:
    matchLabels:
      app: nginx
  replicas: 4 # Update the replicas from 2 to 4
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.16.1
        ports:
        - containerPort: 80
  1. Застосуйте новий файл YAML:

    kubectl apply -f https://k8s.io/examples/application/deployment-scale.yaml
    
  2. Перевірте, що Deployment має чотири Podʼи:

    kubectl get pods -l app=nginx
    

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

    NAME                               READY     STATUS    RESTARTS   AGE
    nginx-deployment-148880595-4zdqq   1/1       Running   0          25s
    nginx-deployment-148880595-6zgi1   1/1       Running   0          25s
    nginx-deployment-148880595-fxcez   1/1       Running   0          2m
    nginx-deployment-148880595-rwovn   1/1       Running   0          2m
    

Докладні процедури масштабування, зокрема зменшення масштабу й масштабування до нуля, дивіться в розділі Масштабування Deployment вручну.

Видалення Deployment

Видаліть Deployment за назвою:

kubectl delete deployment nginx-deployment

ReplicationControllers — старий спосіб

Рекомендований спосіб створення реплікованого застосунку — використовувати Deployment, який своєю чергою використовує ReplicaSet. До того як у Kubernetes зʼявилися Deployment і ReplicaSet, репліковані застосунки налаштовували за допомогою ReplicationController.

Що далі

8.2 - Горизонтальне ручне масштабування для Deployment

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

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

Цілі

  • Масштабування Deployment вгору для обробки більшого трафіку.
  • Зменшення масштабу Deployment для економії ресурсів.
  • Масштабування Deployment до нуля для тимчасового призупинення робочого навантаження.
  • Розуміння, коли використовувати ручне масштабування, а коли HorizontalPodAutoscaler.

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

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

Вам потрібен наявний Deployment. Якщо у вас його немає і ви просто хочете попрактикуватися, можна створити Deployment nginx зі сторінки Запуск застосунку без збереження стану за допомогою Deployment:

kubectl apply -f https://k8s.io/examples/application/deployment.yaml

Перевірте, що Deployment запускає два Podʼи:

kubectl get deployment nginx-deployment

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

NAME               READY   UP-TO-DATE   AVAILABLE   AGE
nginx-deployment   2/2     2            2           10s

Масштабування Deployment вгору

Існує кілька способів змінити кількість реплік наявного Deployment.

Масштабування вгору за допомогою kubectl scale

Використовуйте kubectl scale, щоб встановити кількість реплік:

kubectl scale deployment/nginx-deployment --replicas=4

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

deployment.apps/nginx-deployment scaled

Перевірте, що Deployment має чотири Podʼи:

kubectl get deployment nginx-deployment

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

NAME               READY   UP-TO-DATE   AVAILABLE   AGE
nginx-deployment   4/4     4            4           1m

Декларативне масштабування за допомогою kubectl apply

Замість виконання імперативної команди можна оновити файл маніфесту й застосувати його. Цей підхід добре підходить для робочих процесів із конфігурацією під контролем версій.

Збережіть поточну конфігурацію Deployment у локальний файл:

kubectl get deployment nginx-deployment -o yaml > /tmp/nginx-deployment.yaml

Відредагуйте /tmp/nginx-deployment.yaml і змініть .spec.replicas на 4.

Перед застосуванням порівняйте свої локальні зміни зі станом кластера:

kubectl diff -f /tmp/nginx-deployment.yaml

Застосуйте відредагований маніфест:

kubectl apply -f /tmp/nginx-deployment.yaml

Зменшення масштабу Deployment

Щоб зменшити кількість Podʼів, встановіть --replicas на менше значення:

kubectl scale deployment/nginx-deployment --replicas=2

Kubernetes коректно завершує зайві Podʼи, дотримуючись налаштування terminationGracePeriodSeconds кожного Podʼа.

Перевірте, що Deployment має два Podʼи:

kubectl get pods -l app=nginx

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

NAME                                READY   STATUS    RESTARTS   AGE
nginx-deployment-66b6c48dd5-7gl6h   1/1     Running   0          2m
nginx-deployment-66b6c48dd5-v8mkd   1/1     Running   0          2m

Масштабування до нуля

Ви можете масштабувати Deployment до нуля, щоб тимчасово призупинити робоче навантаження, не видаляючи сам Deployment:

kubectl scale deployment/nginx-deployment --replicas=0

Перевірте, що жоден Pod не працює:

kubectl get deployment nginx-deployment

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

NAME               READY   UP-TO-DATE   AVAILABLE   AGE
nginx-deployment   0/0     0            0           5m

Примітка:

Масштабування до нуля видаляє всі Podʼи, але зберігає Deployment і його ReplicaSet. Ви можете знову масштабувати вгору в будь-який час, встановивши --replicas на додатне число.

Поширені випадки використання масштабування до нуля:

  • Тимчасове призупинення робочого навантаження для економії ресурсів
  • Вікна налагодження або обслуговування
  • Контроль витрат у середовищах розробки або тестування

Інші способи зміни кількості реплік

Окрім kubectl scale, ви можете змінити .spec.replicas за допомогою kubectl edit або kubectl patch.

Масштабування за допомогою kubectl edit

kubectl edit deployment nginx-deployment

Змініть поле .spec.replicas у редакторі, потім збережіть і вийдіть.

Масштабування за допомогою kubectl patch

Ви можете оновити .spec.replicas за допомогою strategic merge patch:

kubectl patch deployment nginx-deployment -p '{"spec":{"replicas":4}}'

Для скриптів використовуйте патч JSON із попередньою перевіркою. Наведена нижче команда встановлює кількість реплік на 4, але лише якщо поточна кількість дорівнює 2:

kubectl patch deployment nginx-deployment --type=json -p='[
  {"op": "test", "path": "/spec/replicas", "value": 2},
  {"op": "replace", "path": "/spec/replicas", "value": 4}
]'

Операція test призводить до збою патчу, якщо поточне значення не збігається, що запобігає небажаним змінам, коли кілька людей або скриптів змінюють той самий Deployment.

Коли використовувати ручне, а коли автоматичне масштабування

АспектРучне масштабуванняАвтоматичне масштабування (HPA)
Найкраще дляПередбачуваних, запланованих або одноразових змін навантаженняЗмінного або непередбачуваного попиту
Як це працюєВи встановлюєте .spec.replicas безпосередньоHPA регулює кількість реплік на основі спостережуваних метрик
Час реакціїНегайно після виконання командиРеагує на метрики з невеликою затримкою
Врахування метрикВідсутнє — кількість реплік вирішуєте виВідстежує CPU, памʼять або власні метрики
ОбслуговуванняПотребує ручного втручання для налаштуванняПрацює автономно після налаштування

Увага:

Якщо HorizontalPodAutoscaler керує Deployment, не встановлюйте репліки вручну. HPA постійно узгоджує кількість реплік і перевизначає будь-які ручні зміни.

Очищення

Видаліть Deployment:

kubectl delete deployment nginx-deployment

Що далі

8.3 - Оновлення Deployment без простою

На цій сторінці показано, як оновити запущений Deployment до нової версії за допомогою поетапного оновлення. Поетапне оновлення поступово замінює старі Podʼи новими, тому ваш застосунок залишається доступним протягом усього процесу.

Цілі

  • Запустити поетапне оновлення Deployment.
  • Стежити за перебігом розгортання.
  • Призупинити та відновити розгортання.
  • Налаштувати параметри стратегії поетапного оновлення.
  • (За потреби) Відкотитися до попередньої ревізії.

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

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

Вам потрібен наявний Deployment. Якщо у вас його немає, створіть Deployment nginx зі сторінки Запуск застосунку без збереження стану за допомогою Deployment:

kubectl apply -f https://k8s.io/examples/application/deployment.yaml

Перевірте, що Deployment запускає два Podʼи:

kubectl get deployment nginx-deployment

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

NAME               READY   UP-TO-DATE   AVAILABLE   AGE
nginx-deployment   2/2     2            2           10s

Виконання поетапного оновлення

Будь-яка зміна в полі .spec.template Deployment запускає поетапне оновлення. Kubernetes створює нові Podʼи з оновленою конфігурацією й поступово завершує старі Podʼи.

Оновлення за допомогою kubectl apply

Ви можете запустити поетапне оновлення, відредагувавши маніфест Deployment і застосувавши зміну. Цей підхід добре працює, якщо ви зберігаєте маніфести в системі контролю версій.

Експортуйте поточний Deployment у локальний файл:

kubectl get deployment nginx-deployment -o yaml > /tmp/nginx-deployment.yaml

Відредагуйте /tmp/nginx-deployment.yaml і змініть .spec.template.spec.containers[0].image з nginx:1.14.2 на nginx:1.16.1.

Перед застосуванням порівняйте свої локальні зміни зі станом кластера:

kubectl diff -f /tmp/nginx-deployment.yaml

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

diff -u -N /tmp/LIVE/apps.v1.Deployment.default.nginx-deployment /tmp/MERGED/apps.v1.Deployment.default.nginx-deployment
--- /tmp/LIVE/apps.v1.Deployment...
+++ /tmp/MERGED/apps.v1.Deployment...
@@ -29,7 +29,7 @@
       containers:
-      - image: nginx:1.14.2
+      - image: nginx:1.16.1
         name: nginx

Застосуйте оновлений маніфест:

kubectl apply -f /tmp/nginx-deployment.yaml

Оновлення лише образу контейнера

Щоб оновити образ контейнера без редагування файлу маніфесту, використовуйте kubectl set image:

kubectl set image deployment/nginx-deployment nginx=nginx:1.16.1

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

deployment.apps/nginx-deployment image updated

Перевірте, що образ було оновлено:

kubectl get deployment nginx-deployment -o jsonpath='{.spec.template.spec.containers[0].image}'

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

nginx:1.16.1

Відстеження перебігу розгортання

Використовуйте kubectl rollout status, щоб стежити за перебігом поетапного оновлення:

kubectl rollout status deployment/nginx-deployment

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

Waiting for deployment "nginx-deployment" rollout to finish: 1 out of 2 new replicas have been updated...
Waiting for deployment "nginx-deployment" rollout to finish: 1 out of 2 new replicas have been updated...
Waiting for deployment "nginx-deployment" rollout to finish: 1 old replicas are pending termination...
deployment "nginx-deployment" successfully rolled out

Після завершення розгортання перевірте Deployment:

kubectl get deployment nginx-deployment

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

NAME               READY   UP-TO-DATE   AVAILABLE   AGE
nginx-deployment   2/2     2            2           2m

Призупинення та відновлення розгортання

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

Призупинення розгортання

kubectl rollout pause deployment/nginx-deployment

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

deployment.apps/nginx-deployment paused

Виконання додаткових змін під час призупинення

Поки розгортання призупинено, ви можете вносити додаткові зміни. Ці зміни не запускають нове розгортання, доки ви його не відновите:

kubectl set image deployment/nginx-deployment nginx=nginx:1.17.0

Примітка:

Ви можете внести кілька змін у призупинений Deployment. Kubernetes застосовує всі зміни разом, коли ви відновлюєте розгортання.

Відновлення розгортання

kubectl rollout resume deployment/nginx-deployment

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

deployment.apps/nginx-deployment resumed

Перевірте, що розгортання завершується:

kubectl rollout status deployment/nginx-deployment

Налаштування стратегії поетапного оновлення

Deployments підтримують два типи стратегій оновлення:

  • RollingUpdate (стандартно): поступово замінює старі Podʼи новими.
  • Recreate: спочатку завершує всі наявні Podʼи, а потім створює нові. Це призводить до простою.

Для стратегії RollingUpdate ці параметри контролюють, як Kubernetes виконує оновлення:

ПараметрЩо контролюєСтандартноПриклад
maxUnavailableМаксимальна кількість Podʼів, які можуть бути недоступні під час оновлення25%1 або 25%
maxSurgeМаксимальна кількість додаткових Podʼів, які можуть бути створені під час оновлення25%1 або 25%

Примітка:

maxUnavailable та maxSurge приймають абсолютне число або відсоток. Kubernetes обчислює відсотки від бажаної кількості реплік, округлюючи вниз для maxUnavailable та округлюючи вгору для maxSurge.

Для налаштування цих параметрів використовуйте kubectl patch:

kubectl patch deployment nginx-deployment -p \
  '{"spec":{"strategy":{"rollingUpdate":{"maxUnavailable":"25%","maxSurge":"25%"}}}}'

Ви також можете задати ці поля в маніфесті Deployment у .spec.strategy.rollingUpdate. Докладні приклади дивіться в розділах max unavailable і max surge документації з концепцій Deployment.

Виявлення розгортання, що застрягло

Якщо розгортання не просувається протягом часу, вказаного в .spec.progressDeadlineSeconds (стандартно: 600 секунд), Kubernetes позначає стан Deployment Progressing як False. Перевірити цей стан можна, описавши Deployment:

kubectl describe deployment nginx-deployment

Шукайте стан Progressing у розділі Conditions виводу. Розгортання, що застрягло, зазвичай вказує на те, що нові Podʼи не можуть запуститися. Розділ Events у виводі може допомогти діагностувати проблему.

Відкочування до попередньої ревізії

Якщо нова версія спричиняє проблеми, ви можете відкотитися до попередньої ревізії.

Перегляд історії розгортання

kubectl rollout history deployment/nginx-deployment

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

deployment.apps/nginx-deployment
REVISION  CHANGE-CAUSE
1         <none>
2         <none>

Примітка:

Стовпець CHANGE-CAUSE показує значення анотації kubernetes.io/change-cause на момент кожної ревізії. Ця анотація не встановлюється автоматично, але якщо ви використовуєте автоматизоване рішення для керування Deployments, ваш інструмент може записувати в цю анотацію певний текст.

Відкочування до попередньої ревізії

kubectl rollout undo deployment/nginx-deployment

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

deployment.apps/nginx-deployment rolled back

Відкочування до конкретної ревізії

kubectl rollout undo deployment/nginx-deployment --to-revision=1

Перевірте, що відкочування завершується:

kubectl rollout status deployment/nginx-deployment

Примітка:

Історія ревізій Deployment зберігається в ReplicaSets, якими він керує. Стандартно Kubernetes зберігає 10 старих ReplicaSets. Ви можете змінити це обмеження, встановивши .spec.revisionHistoryLimit у маніфесті Deployment. Значення 0 повністю вимикає відкочування.

Очищення

Видаліть Deployment:

kubectl delete deployment nginx-deployment

Що далі

8.4 - Запуск одноекземплярного застосунку зі збереженням стану

На цій сторінці показано, як запустити одноекземплярний застосунок зі збереженням стану в Kubernetes, використовуючи PersistentVolume та Deployment. Застосунок — MySQL.

Цілі

  • Створити PersistentVolume, що посилається на диск у вашому середовищі.
  • Створити Deployment MySQL.
  • Відкрити доступ до MySQL іншим Podʼам у кластері за відомим DNS-імʼям.

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

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

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

  • Вам потрібно мати або динамічний provisioner PersistentVolume з типовим StorageClass, або самостійно статично надати PersistentVolumes, щоб задовольнити PersistentVolumeClaims, які використовуються тут.

Розгортання MySQL

Ви можете запустити застосунок зі збереженням стану, створивши Deployment Kubernetes і підʼєднавши його до наявного PersistentVolume за допомогою PersistentVolumeClaim. Наприклад, цей файл YAML описує Deployment, який запускає MySQL і посилається на PersistentVolumeClaim. Файл визначає монтування тому для /var/lib/mysql, а потім створює PersistentVolumeClaim, що шукає том на 20G. Цю заявку задовольняє будь-який наявний том, що відповідає вимогам, або динамічний provisioner.

Примітка: пароль визначено у файлі конфігурації yaml, і це небезпечно. Безпечне рішення дивіться в розділі Kubernetes Secrets.

apiVersion: v1
kind: Service
metadata:
  name: mysql
spec:
  ports:
  - port: 3306
  selector:
    app: mysql
  clusterIP: None
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: mysql
spec:
  selector:
    matchLabels:
      app: mysql
  strategy:
    type: Recreate
  template:
    metadata:
      labels:
        app: mysql
    spec:
      containers:
      - image: mysql:9
        name: mysql
        env:
          # Use secret in real usage
        - name: MYSQL_ROOT_PASSWORD
          value: password
        ports:
        - containerPort: 3306
          name: mysql
        volumeMounts:
        - name: mysql-persistent-storage
          mountPath: /var/lib/mysql
      volumes:
      - name: mysql-persistent-storage
        persistentVolumeClaim:
          claimName: mysql-pv-claim
apiVersion: v1
kind: PersistentVolume
metadata:
  name: mysql-pv-volume
  labels:
    type: local
spec:
  storageClassName: manual
  capacity:
    storage: 20Gi
  accessModes:
    - ReadWriteOnce
  hostPath:
    path: "/mnt/data"
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: mysql-pv-claim
spec:
  storageClassName: manual
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 20Gi
  1. Розгорніть PV та PVC з файлу YAML:

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

    kubectl apply -f https://k8s.io/examples/application/mysql/mysql-deployment.yaml
    
  3. Виведіть інформацію про Deployment:

    kubectl describe deployment mysql
    

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

    Name:                 mysql
    Namespace:            default
    CreationTimestamp:    Tue, 01 Nov 2016 11:18:45 -0700
    Labels:               app=mysql
    Annotations:          deployment.kubernetes.io/revision=1
    Selector:             app=mysql
    Replicas:             1 desired | 1 updated | 1 total | 0 available | 1 unavailable
    StrategyType:         Recreate
    MinReadySeconds:      0
    Pod Template:
      Labels:       app=mysql
      Containers:
        mysql:
        Image:      mysql:9
        Port:       3306/TCP
        Environment:
          MYSQL_ROOT_PASSWORD:      password
        Mounts:
          /var/lib/mysql from mysql-persistent-storage (rw)
      Volumes:
        mysql-persistent-storage:
        Type:       PersistentVolumeClaim (a reference to a PersistentVolumeClaim in the same namespace)
        ClaimName:  mysql-pv-claim
        ReadOnly:   false
    Conditions:
      Type          Status  Reason
      ----          ------  ------
      Available     False   MinimumReplicasUnavailable
      Progressing   True    ReplicaSetUpdated
    OldReplicaSets:       <none>
    NewReplicaSet:        mysql-63082529 (1/1 replicas created)
    Events:
      FirstSeen    LastSeen    Count    From                SubobjectPath    Type        Reason            Message
      ---------    --------    -----    ----                -------------    --------    ------            -------
      33s          33s         1        {deployment-controller }             Normal      ScalingReplicaSet Scaled up replica set mysql-63082529 to 1
    
  4. Перегляньте Podʼи, створені Deployment:

    kubectl get pods -l app=mysql
    

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

    NAME                   READY     STATUS    RESTARTS   AGE
    mysql-63082529-2z3ki   1/1       Running   0          3m
    
  5. Перевірте PersistentVolumeClaim:

    kubectl describe pvc mysql-pv-claim
    

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

    Name:         mysql-pv-claim
    Namespace:    default
    StorageClass:
    Status:       Bound
    Volume:       mysql-pv-volume
    Labels:       <none>
    Annotations:    pv.kubernetes.io/bind-completed=yes
                    pv.kubernetes.io/bound-by-controller=yes
    Capacity:     20Gi
    Access Modes: RWO
    Events:       <none>
    

Доступ до екземпляра MySQL

Наведений вище файл YAML створює сервіс, який дає іншим Podʼам у кластері змогу отримувати доступ до бази даних. Параметр Service clusterIP: None дозволяє DNS-імені Service розвʼязуватися безпосередньо в IP-адресу Podʼа. Це оптимально, коли за Service стоїть лише один Pod і ви не маєте наміру збільшувати кількість Podʼів.

Запустіть клієнта MySQL, щоб підʼєднатися до сервера:

kubectl run -it --rm --image=mysql:9 --restart=Never mysql-client -- mysql -h mysql -ppassword

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

Waiting for pod default/mysql-client-274442439-zyp6i to be running, status is Pending, pod ready: false
If you don't see a command prompt, try pressing enter.

mysql>

Оновлення

Образ або будь-яку іншу частину Deployment можна оновити як зазвичай за допомогою команди kubectl apply. Ось деякі запобіжні заходи, специфічні для застосунків зі збереженням стану:

  • Не масштабуйте застосунок. Це налаштування призначене лише для одноекземплярних застосунків. Базовий PersistentVolume можна змонтувати лише в один Pod. Про кластеризовані застосунки зі збереженням стану дивіться документацію StatefulSet.
  • Використовуйте strategy: type: Recreate у файлі конфігурації YAML для Deployment. Це вказує Kubernetes не використовувати поетапні оновлення. Поетапні оновлення не працюватимуть, оскільки одночасно не може працювати більше одного Podʼа. Стратегія Recreate зупинить перший Pod перед створенням нового з оновленою конфігурацією.

Видалення Deployment

Видаліть розгорнуті обʼєкти за назвою:

kubectl delete deployment,svc mysql
kubectl delete pvc mysql-pv-claim
kubectl delete pv mysql-pv-volume

Якщо ви надали PersistentVolume вручну, вам також потрібно вручну видалити його й звільнити базовий ресурс. Якщо ви використовували динамічний provisioner, він автоматично видаляє PersistentVolume, коли бачить, що ви видалили PersistentVolumeClaim. Деякі динамічні provisioners (наприклад, для EBS і PD) також звільняють базовий ресурс під час видалення PersistentVolume.

Що далі

8.5 - Запуск реплікованого застосунку зі збереженням стану

Ця сторінка показує, як запустити реплікований застосунок зі збереженням стану (StatefulSet). Цей застосунок — реплікована база даних MySQL. У топології цього прикладу є один головний сервер і кілька реплік, що використовують асинхронну реплікацію на основі рядків.

Примітка:

Ця конфігурація не призначена для промислового середовища. Налаштування MySQL залишаються на небезпечних типових значеннях, щоб зосередитися на загальних патернах запуску застосунків зі збереженням стану в Kubernetes.

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

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

  • Вам потрібно мати або динамічний provisioner PersistentVolume з типовим StorageClass, або самостійно статично надати PersistentVolumes, щоб задовольнити PersistentVolumeClaims, які використовуються тут.

  • Цей підручник передбачає, що ви знаєте про Постійні томи та StatefulSets, а також інші основні поняття, такі як Pod, Service та ConfigMap.
  • Трохи знань MySQL корисні, але цей підручник має на меті представити загальні патерни, які можуть бути корисними для інших систем.
  • Ви використовуєте простір імен default або інший простір імен, в якому відсутні обʼєкти, що конфліктують.
  • У вас має бути AMD64-сумісний процесор.

Цілі

  • Розгорнути репліковану топологію MySQL за допомогою StatefulSet.
  • Надіслати клієнтський трафік MySQL.
  • Спостерігати стійкість до перерв у роботі.
  • Масштабувати StatefulSet вгору та вниз.

Розгортання MySQL

Приклад розгортання складається з ConfigMap, двох Service та StatefulSet.

Створення ConfigMap

Створіть ConfigMap із наступного файлу конфігурації YAML:

apiVersion: v1
kind: ConfigMap
metadata:
  name: mysql
  labels:
    app: mysql
    app.kubernetes.io/name: mysql
data:
  primary.cnf: |
    # Apply this config only on the primary.
    [mysqld]
    log-bin
  replica.cnf: |
    # Apply this config only on replicas.
    [mysqld]
    super-read-only

kubectl apply -f https://k8s.io/examples/application/mysql/mysql-configmap.yaml

Цей ConfigMap надає перевизначення для my.cnf, що дозволяє вам незалежно керувати конфігурацією на головному сервері MySQL та його репліках. У цьому випадку ви хочете, щоб головний сервер міг надавати логи реплікації реплікам, а репліки відхиляли будь-які записи, які надходять не через реплікацію.

Немає нічого особливого у самому ConfigMap, що зумовлює застосування різних частин до різних Podʼів. Кожен Pod вирішує, яку частину дивитися при ініціалізації, на основі інформації, що надає контролер StatefulSet.

Створення Service

Створіть Service із наступного файлу конфігурації YAML:

# Headless service for stable DNS entries of StatefulSet members.
apiVersion: v1
kind: Service
metadata:
  name: mysql
  labels:
    app: mysql
    app.kubernetes.io/name: mysql
spec:
  ports:
  - name: mysql
    port: 3306
  clusterIP: None
  selector:
    app: mysql
---
# Client service for connecting to any MySQL instance for reads.
# For writes, you must instead connect to the primary: mysql-0.mysql.
apiVersion: v1
kind: Service
metadata:
  name: mysql-read
  labels:
    app: mysql
    app.kubernetes.io/name: mysql
    readonly: "true"
spec:
  ports:
  - name: mysql
    port: 3306
  selector:
    app: mysql
kubectl apply -f https://k8s.io/examples/application/mysql/mysql-services.yaml

Headless Service надає місце для DNS-записів, які контролери StatefulSet створюють для кожного Podʼа, що є частиною набору. Оскільки headless Service називається mysql, Podʼи доступні через розвʼязання імені <pod-name>.mysql з будь-якого іншого Podʼа в тому самому кластері Kubernetes і просторі імен.

Клієнтський Service, з назвою mysql-read, є звичайним Service з власним кластерним IP, який розподіляє підключення між всіма Podʼами MySQL, які повідомляють про готовність. Набір потенційних точок доступу включає головний сервер MySQL та всі репліки.

Зверніть увагу, що лише запити на читання можуть використовувати клієнтський Service з балансуванням навантаження. Оскільки існує лише один головний сервер MySQL, клієнти повинні підключатися безпосередньо до головного Podʼа MySQL (через його DNS-запис у headless Service) для виконання записів.

Створення StatefulSet

Наостанок, створіть StatefulSet із наступного файлу конфігурації YAML:

apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: mysql
spec:
  selector:
    matchLabels:
      app: mysql
      app.kubernetes.io/name: mysql
  serviceName: mysql
  replicas: 3
  template:
    metadata:
      labels:
        app: mysql
        app.kubernetes.io/name: mysql
    spec:
      initContainers:
      - name: init-mysql
        image: mysql:5.7
        command:
        - bash
        - "-c"
        - |
          set -ex
          # Generate mysql server-id from pod ordinal index.
          [[ $HOSTNAME =~ -([0-9]+)$ ]] || exit 1
          ordinal=${BASH_REMATCH[1]}
          echo [mysqld] > /mnt/conf.d/server-id.cnf
          # Add an offset to avoid reserved server-id=0 value.
          echo server-id=$((100 + $ordinal)) >> /mnt/conf.d/server-id.cnf
          # Copy appropriate conf.d files from config-map to emptyDir.
          if [[ $ordinal -eq 0 ]]; then
            cp /mnt/config-map/primary.cnf /mnt/conf.d/
          else
            cp /mnt/config-map/replica.cnf /mnt/conf.d/
          fi
        volumeMounts:
        - name: conf
          mountPath: /mnt/conf.d
        - name: config-map
          mountPath: /mnt/config-map
      - name: clone-mysql
        image: gcr.io/google-samples/xtrabackup:1.0
        command:
        - bash
        - "-c"
        - |
          set -ex
          # Skip the clone if data already exists.
          [[ -d /var/lib/mysql/mysql ]] && exit 0
          # Skip the clone on primary (ordinal index 0).
          [[ `hostname` =~ -([0-9]+)$ ]] || exit 1
          ordinal=${BASH_REMATCH[1]}
          [[ $ordinal -eq 0 ]] && exit 0
          # Clone data from previous peer.
          ncat --recv-only mysql-$(($ordinal-1)).mysql 3307 | xbstream -x -C /var/lib/mysql
          # Prepare the backup.
          xtrabackup --prepare --target-dir=/var/lib/mysql
        volumeMounts:
        - name: data
          mountPath: /var/lib/mysql
          subPath: mysql
        - name: conf
          mountPath: /etc/mysql/conf.d
      containers:
      - name: mysql
        image: mysql:5.7
        env:
        - name: MYSQL_ALLOW_EMPTY_PASSWORD
          value: "1"
        ports:
        - name: mysql
          containerPort: 3306
        volumeMounts:
        - name: data
          mountPath: /var/lib/mysql
          subPath: mysql
        - name: conf
          mountPath: /etc/mysql/conf.d
        resources:
          requests:
            cpu: 500m
            memory: 1Gi
        livenessProbe:
          exec:
            command: ["mysqladmin", "ping"]
          initialDelaySeconds: 30
          periodSeconds: 10
          timeoutSeconds: 5
        readinessProbe:
          exec:
            # Перевірити, що ми можемо виконувати запити через TCP (skip-networking вимкнено).
            command: ["mysql", "-h", "127.0.0.1", "-e", "SELECT 1"]
          initialDelaySeconds: 5
          periodSeconds: 2
          timeoutSeconds: 1
      - name: xtrabackup
        image: gcr.io/google-samples/xtrabackup:1.0
        ports:
        - name: xtrabackup
          containerPort: 3307
        command:
        - bash
        - "-c"
        - |
          set -ex
          cd /var/lib/mysql

          # Determine binlog position of cloned data, if any.
          if [[ -f xtrabackup_slave_info && "x$(<xtrabackup_slave_info)" != "x" ]]; then
            # XtraBackup already generated a partial "CHANGE MASTER TO" query
            # because we're cloning from an existing replica. (Need to remove the tailing semicolon!)
            cat xtrabackup_slave_info | sed -E 's/;$//g' > change_master_to.sql.in
            # Ignore xtrabackup_binlog_info in this case (it's useless).
            rm -f xtrabackup_slave_info xtrabackup_binlog_info
          elif [[ -f xtrabackup_binlog_info ]]; then
            # We're cloning directly from primary. Parse binlog position.
            [[ `cat xtrabackup_binlog_info` =~ ^(.*?)[[:space:]]+(.*?)$ ]] || exit 1
            rm -f xtrabackup_binlog_info xtrabackup_slave_info
            echo "CHANGE MASTER TO MASTER_LOG_FILE='${BASH_REMATCH[1]}',\
                  MASTER_LOG_POS=${BASH_REMATCH[2]}" > change_master_to.sql.in
          fi

          # Check if we need to complete a clone by starting replication.
          if [[ -f change_master_to.sql.in ]]; then
            echo "Waiting for mysqld to be ready (accepting connections)"
            until mysql -h 127.0.0.1 -e "SELECT 1"; do sleep 1; done

            echo "Initializing replication from clone position"
            mysql -h 127.0.0.1 \
                  -e "$(<change_master_to.sql.in), \
                          MASTER_HOST='mysql-0.mysql', \
                          MASTER_USER='root', \
                          MASTER_PASSWORD='', \
                          MASTER_CONNECT_RETRY=10; \
                        START SLAVE;" || exit 1
            # In case of container restart, attempt this at-most-once.
            mv change_master_to.sql.in change_master_to.sql.orig
          fi

          # Start a server to send backups when requested by peers.
          exec ncat --listen --keep-open --send-only --max-conns=1 3307 -c \
            "xtrabackup --backup --slave-info --stream=xbstream --host=127.0.0.1 --user=root"
        volumeMounts:
        - name: data
          mountPath: /var/lib/mysql
          subPath: mysql
        - name: conf
          mountPath: /etc/mysql/conf.d
        resources:
          requests:
            cpu: 100m
            memory: 100Mi
      volumes:
      - name: conf
        emptyDir: {}
      - name: config-map
        configMap:
          name: mysql
  volumeClaimTemplates:
  - metadata:
      name: data
    spec:
      accessModes: ["ReadWriteOnce"]
      resources:
        requests:
          storage: 10Gi
kubectl apply -f https://k8s.io/examples/application/mysql/mysql-statefulset.yaml

Ви можете спостерігати за процесом запуску, виконавши:

kubectl get pods -l app=mysql --watch

Через деякий час ви повинні побачити, що всі 3 Podʼи стануть Running:

NAME      READY     STATUS    RESTARTS   AGE
mysql-0   2/2       Running   0          2m
mysql-1   2/2       Running   0          1m
mysql-2   2/2       Running   0          1m

Натисніть Ctrl+C, щоб скасувати перегляд.

Примітка:

Якщо ви не бачите жодних змін, переконайтеся, що у вас увімкнений динамічний provisioner PersistentVolume, як зазначено у передумовах.

Цей маніфест використовує різноманітні техніки для керування Podʼами зі збереженням стану в межах StatefulSet. У наступному розділі підкреслено деякі з цих технік, щоб пояснити, що відбувається під час створення Podʼів StatefulSet.

Розуміння ініціалізації Podʼа зі збереженням стану

Контролер StatefulSet запускає Podʼи по одному, в порядку їх індексів. Він чекає, доки кожен Pod не повідомить про готовність, перш ніж запустити наступний.

Крім того, контролер призначає кожному Podʼу унікальне, стабільне імʼя у формі <statefulset-name>-<ordinal-index>, в результаті отримуємо Podʼи з іменами mysql-0, mysql-1 та mysql-2.

Шаблон Podʼа у вищенаведеному маніфесті StatefulSet використовує ці властивості, щоб здійснити впорядкований запуск реплікації MySQL.

Створення конфігурації

Перед запуском будь-яких контейнерів у специфікації Podʼа, спочатку Pod запускає будь-які контейнери ініціалізації у визначеному порядку.

Перший контейнер ініціалізації, init-mysql, генерує спеціальні конфігураційні файли MySQL на основі порядкового індексу.

Скрипт визначає свій власний порядковий індекс, витягуючи його з кінця імені Podʼа, яке повертається командою hostname. Потім він зберігає порядковий індекс (з числовим зміщенням для уникнення зарезервованих значень) у файлі з назвою server-id.cnf в теці conf.d MySQL. Це перетворює унікальний, стабільний ідентифікатор, наданий StatefulSet, у домен ідентифікаторів серверів MySQL, які вимагають таких же властивостей.

Скрипт у контейнері init-mysql також застосовує або primary.cnf, або replica.cnf з ConfigMap, копіюючи вміст у conf.d. Оскільки у топології цього прикладу є лише один головний сервер MySQL та будь-яка кількість реплік, скрипт призначає порядковий індекс 0 головному серверу, а всі інші — репліками. Разом з гарантією контролера StatefulSet щодо порядку розгортання, це забезпечує готовність головного сервера MySQL перед створенням реплік, щоб вони могли почати реплікацію.

Клонування наявних даних

Загалом, коли новий Pod приєднується до набору як репліка, він повинен припускати, що головний сервер MySQL може вже містити дані. Також він повинен припускати, що логи реплікації можуть не сягати самого початку. Ці консервативні припущення є ключем до того, щоб запущений StatefulSet міг масштабуватися вгору та вниз з часом, а не залишатися фіксованим на своєму початковому розмірі.

Другий контейнер ініціалізації, з назвою clone-mysql, виконує операцію клонування на реплікаційному Podʼі першого разу, коли він запускається на порожньому PersistentVolume. Це означає, що він копіює всі наявні дані з іншого працюючого Podʼа, таким чином, його локальний стан є достатньо консистентним для початку реплікації з головного сервера.

MySQL сам по собі не надає механізму для цього, тому приклад використовує популярний відкритий інструмент — Percona XtraBackup. Під час клонування сервер-джерело MySQL може мати знижену продуктивність. Щоб мінімізувати вплив на головний сервер MySQL, скрипт вказує кожному Podʼу отримувати дані з Podʼа, чий порядковий індекс на одиницю менший. Це працює через те, що контролер StatefulSet завжди гарантує, що Pod N є готовим перед запуском Podʼа N+1.

Початок реплікації

Після успішного завершення контейнерів ініціалізації запускаються звичайні контейнери. Podʼи MySQL складаються з контейнера mysql, в якому працює фактичний сервер mysqld, та контейнера xtrabackup, який діє як sidecar.

Sidecar xtrabackup переглядає клоновані файли даних і визначає, чи необхідно ініціалізувати реплікацію MySQL на репліці. У цьому випадку він чекає, доки mysqld буде готовий, а потім виконує команди CHANGE MASTER TO та START SLAVE з параметрами реплікації, отриманими з клонованих файлів XtraBackup.

Після того як репліка починає реплікацію, вона запамʼятовує свій головний сервер MySQL і автоматично підʼєднується, якщо сервер перезапускається або зʼєднання втрачається. Також, оскільки репліки шукають головний сервер за його стабільним DNS-імʼям (mysql-0.mysql), вони автоматично знаходять головний сервер навіть якщо він отримує новий IP Podʼа через перепланування.

Нарешті, після початку реплікації, контейнер xtrabackup слухає зʼєднання з інших Podʼів, які запитують клон даних. Цей сервер залишається активним нескінченно довго в разі, якщо StatefulSet масштабується вгору, або якщо наступний Pod втрачає свій PersistentVolumeClaim і потрібно повторно виконати клонування.

Надсилання клієнтського трафіку

Ви можете надіслати тестові запити до головного сервера MySQL (хост mysql-0.mysql) запустивши тимчасовий контейнер з образом mysql:5.7 і використовуючи бінарний файл клієнта mysql.

kubectl run mysql-client --image=mysql:5.7 -i --rm --restart=Never --\
  mysql -h mysql-0.mysql <<EOF
CREATE DATABASE test;
CREATE TABLE test.messages (message VARCHAR(250));
INSERT INTO test.messages VALUES ('hello');
EOF

Використовуйте хост mysql-read, щоб надіслати тестові запити до будь-якого сервера, який повідомляє про готовність:

kubectl run mysql-client --image=mysql:5.7 -i -t --rm --restart=Never --\
  mysql -h mysql-read -e "SELECT * FROM test.messages"

Ви повинні отримати вивід схожий на цей:

Waiting for pod default/mysql-client to be running, status is Pending, pod ready: false
+---------+
| message |
+---------+
| hello   |
+---------+
pod "mysql-client" deleted

Щоб продемонструвати, що Service mysql-read розподіляє підключення між серверами, ви можете запустити SELECT @@server_id у циклі:

kubectl run mysql-client-loop --image=mysql:5.7 -i -t --rm --restart=Never --\
  bash -ic "while sleep 1; do mysql -h mysql-read -e 'SELECT @@server_id,NOW()'; done"

Ви повинні бачити, що @@server_id змінюється випадковим чином, оскільки може бути вибрана інша точка доступу при кожній спробі підключення:

+-------------+---------------------+
| @@server_id | NOW()               |
+-------------+---------------------+
|         100 | 2006-01-02 15:04:05 |
+-------------+---------------------+
+-------------+---------------------+
| @@server_id | NOW()               |
+-------------+---------------------+
|         102 | 2006-01-02 15:04:06 |
+-------------+---------------------+
+-------------+---------------------+
| @@server_id | NOW()               |
+-------------+---------------------+
|         101 | 2006-01-02 15:04:07 |
+-------------+---------------------+

Ви можете натиснути Ctrl+C, коли захочете зупинити цикл, але цікаво тримати його запущеним в іншому вікні, щоб бачити ефект від наступних кроків.

Симуляція відмови Podʼа та вузла

Щоб продемонструвати підвищену доступність читання з пулу реплік замість одного сервера, залиште цикл SELECT @@server_id, запущений вище, активним, тоді як ви змушуєте Pod вийти зі стану Ready.

Зламайте пробу готовності

Проба готовності для контейнера mysql виконує команду mysql -h 127.0.0.1 -e 'SELECT 1', щоб переконатися, що сервер запущений і може виконувати запити.

Один зі способів змусити цю пробу готовності не спрацювати — зламати цю команду:

kubectl exec mysql-2 -c mysql -- mv /usr/bin/mysql /usr/bin/mysql.off

Ця дія втручається у файлову систему контейнера Podʼа mysql-2 і перейменовує команду mysql, щоб проба готовності не могла її знайти. Через кілька секунд Pod повинен повідомити про один зі своїх контейнерів як неготовий, що можна перевірити за допомогою:

kubectl get pod mysql-2

Перевірте значення 1/2 у стовпці READY:

NAME      READY     STATUS    RESTARTS   AGE
mysql-2   1/2       Running   0          3m

На цьому етапі ви повинні бачити продовження роботи вашого циклу SELECT @@server_id, хоча він більше не повідомляє про 102. Нагадаємо, що скрипт init-mysql визначив server-id як 100 + $ordinal, тож ідентифікатор сервера 102 відповідає Podʼу mysql-2.

Тепер відновіть Pod і він повинен знову зʼявитися у виводі циклу через кілька секунд:

kubectl exec mysql-2 -c mysql -- mv /usr/bin/mysql.off /usr/bin/mysql

Видалення Podʼів

Контролер StatefulSet також створює Podʼи знову, якщо вони видалені, подібно до того, як це робить ReplicaSet для Podʼів без збереження стану.

kubectl delete pod mysql-2

Контролер StatefulSet помічає, що Podʼа mysql-2 більше не існує, і створює новий з тією ж назвою та повʼязаний з тим самим PersistentVolumeClaim. Ви повинні побачити, що ідентифікатор сервера 102 зникне з виводу циклу протягом певного часу і потім повернеться самостійно.

Виконайте drain вузла

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

Спочатку визначте, на якому вузлі знаходиться один із Podʼів MySQL:

kubectl get pod mysql-2 -o wide

Назва вузла повинна зʼявитися у останньому стовпчику:

NAME      READY     STATUS    RESTARTS   AGE       IP            NODE
mysql-2   2/2       Running   0          15m       10.244.5.27   kubernetes-node-9l2t

Потім виконайте drain вузла такою командою: вона виконує cordon вузла, щоб нові Podʼи не могли туди плануватися, а потім виселяє всі наявні Podʼи. Замість <node-name> підставте назву вузла, яку ви знайшли на попередньому кроці.

Увага:

Drain вузла може вплинути на інші робочі навантаження та застосунки, що працюють на тому ж вузлі. Виконуйте наступний крок тільки на тестовому кластері.
# Дивіться вище поради щодо впливу на інші робочі навантаження
kubectl drain <node-name> --force --delete-emptydir-data --ignore-daemonsets

Тепер ви можете спостерігати, як Pod переплановується на іншому вузлі:

kubectl get pod mysql-2 -o wide --watch

Це має виглядати приблизно так:

NAME      READY   STATUS          RESTARTS   AGE       IP            NODE
mysql-2   2/2     Terminating     0          15m       10.244.1.56   kubernetes-node-9l2t
[...]
mysql-2   0/2     Pending         0          0s        <none>        kubernetes-node-fjlm
mysql-2   0/2     Init:0/2        0          0s        <none>        kubernetes-node-fjlm
mysql-2   0/2     Init:1/2        0          20s       10.244.5.32   kubernetes-node-fjlm
mysql-2   0/2     PodInitializing 0          21s       10.244.5.32   kubernetes-node-fjlm
mysql-2   1/2     Running         0          22s       10.244.5.32   kubernetes-node-fjlm
mysql-2   2/2     Running         0          30s       10.244.5.32   kubernetes-node-fjlm

І знову, ви повинні побачити, що ідентифікатор сервера 102 зник з виводу циклу SELECT @@server_id протягом певного часу, а потім повернувся.

Тепер виконайте uncordon вузла, щоб повернути його до звичайного стану:

kubectl uncordon <node-name>

Масштабування кількості реплік

Коли ви використовуєте реплікацію MySQL, ви можете збільшувати пропускну здатність для запитів на читання, додаючи репліки. Для StatefulSet це можна зробити однією командою:

kubectl scale statefulset mysql  --replicas=5

Спостерігайте, як нові Podʼи запускаються, виконавши:

kubectl get pods -l app=mysql --watch

Коли вони будуть готові, ви побачите, що ідентифікатори серверів 103 та 104 починають зʼявлятися у виводі циклу SELECT @@server_id.

Ви також можете перевірити, що ці нові сервери мають дані, які ви додали ще до того, як вони зʼявилися:

kubectl run mysql-client --image=mysql:5.7 -i -t --rm --restart=Never --\
  mysql -h mysql-3.mysql -e "SELECT * FROM test.messages"
Waiting for pod default/mysql-client to be running, status is Pending, pod ready: false
+---------+
| message |
+---------+
| hello   |
+---------+
pod "mysql-client" deleted

Зменшення кількості реплік так само безпроблемне:

kubectl scale statefulset mysql --replicas=3

Примітка:

Хоча збільшення створює нові PersistentVolumeClaims автоматично, зменшення автоматично не видаляє ці PVC.

Це дає вам можливість залишити ці ініціалізовані PVC для швидшого збільшення, або вилучити дані перед їх видаленням.

Ви можете перевірити це, виконавши:

kubectl get pvc -l app=mysql

Це покаже, що всі 5 PVC все ще існують, попри те, що StatefulSet був зменшений до 3:

NAME           STATUS    VOLUME                                     CAPACITY   ACCESSMODES   AGE
data-mysql-0   Bound     pvc-8acbf5dc-b103-11e6-93fa-42010a800002   10Gi       RWO           20m
data-mysql-1   Bound     pvc-8ad39820-b103-11e6-93fa-42010a800002   10Gi       RWO           20m
data-mysql-2   Bound     pvc-8ad69a6d-b103-11e6-93fa-42010a800002   10Gi       RWO           20m
data-mysql-3   Bound     pvc-50043c45-b1c5-11e6-93fa-42010a800002   10Gi       RWO           2m
data-mysql-4   Bound     pvc-500a9957-b1c5-11e6-93fa-42010a800002   10Gi       RWO           2m

Якщо ви не збираєтеся повторно використовувати додаткові PVC, ви можете їх видалити:

kubectl delete pvc data-mysql-3
kubectl delete pvc data-mysql-4

Очищення

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

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

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

    kubectl get pods -l app=mysql
    

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

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

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

Що далі

8.6 - Масштабування StatefulSet

Це завдання показує, як масштабувати StatefulSet. Масштабування StatefulSet означає збільшення або зменшення кількості реплік.

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

  • StatefulSets доступні лише у Kubernetes версії 1.5 або новішій. Щоб перевірити версію Kubernetes, виконайте kubectl version.

  • Не всі застосунки зі збереженням стану добре масштабуються. Якщо ви не впевнені, чи варто масштабувати ваші StatefulSets, докладніше дивіться в концепції StatefulSet або в навчальному матеріалі про StatefulSet.

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

Масштабування StatefulSets

Використання kubectl для масштабування StatefulSets

Спочатку знайдіть StatefulSet, який ви хочете масштабувати.

kubectl get statefulsets <stateful-set-name>

Змініть кількість реплік вашого StatefulSet:

kubectl scale statefulsets <stateful-set-name> --replicas=<new-replicas>

Оновлення ваших StatefulSets на місці

Також можна виконати оновлення на місці ваших StatefulSets.

Якщо ваш StatefulSet спочатку створено за допомогою kubectl apply, оновіть .spec.replicas у маніфестах StatefulSet, а потім виконайте kubectl apply:

kubectl apply -f <stateful-set-file-updated>

Інакше відредагуйте це поле за допомогою kubectl edit:

kubectl edit statefulsets <stateful-set-name>

Або використовуйте kubectl patch:

kubectl patch statefulsets <stateful-set-name> -p '{"spec":{"replicas":<new-replicas>}}'

Усунення несправностей

Зменшення масштабу не працює належним чином

Не можна зменшити масштаб StatefulSet, коли будь-який зі stateful Podʼів, якими він керує, несправний. Зменшення масштабу відбувається лише після того, як ці stateful Podʼи стануть запущеними й готовими.

Якщо spec.replicas > 1, Kubernetes не може визначити причину несправності Podʼа. Це може бути наслідком постійного або тимчасового збою. Тимчасовий збій може бути спричинений перезапуском, потрібним для оновлення або обслуговування.

Якщо Pod несправний через постійний збій, масштабування без усунення збою може призвести до стану, коли кількість членів StatefulSet опуститься нижче певної мінімальної кількості реплік, потрібних для правильної роботи. Це може призвести до недоступності вашого StatefulSet.

Якщо Pod несправний через тимчасовий збій і може знову стати доступним, тимчасова помилка може завадити операції збільшення або зменшення масштабу. Деякі розподілені бази даних мають проблеми, коли вузли приєднуються й виходять одночасно. У таких випадках краще оцінювати операції масштабування на рівні застосунку й виконувати масштабування лише тоді, коли ви впевнені, що кластер вашого застосунку зі збереженням стану повністю справний.

Що далі

8.7 - Видалення StatefulSet

Це завдання показує, як видалити StatefulSet.

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

  • Це завдання передбачає, що у вас у кластері працює застосунок, представлений StatefulSet.

Видалення StatefulSet

Ви можете видалити StatefulSet так само, як й інші ресурси в Kubernetes: скористайтеся командою kubectl delete і вкажіть StatefulSet за файлом або за назвою.

kubectl delete -f <file.yaml>
kubectl delete statefulsets <statefulset-name>

Після видалення самого StatefulSet може знадобитися окремо видалити повʼязаний headless Service.

kubectl delete service <service-name>

Під час видалення StatefulSet через kubectl StatefulSet масштабується до 0. Усі Podʼи, що є частиною цього робочого навантаження, також видаляються. Якщо ви хочете видалити лише StatefulSet, а не Podʼи, використовуйте --cascade=orphan. Наприклад:

kubectl delete -f <file.yaml> --cascade=orphan

Якщо передати --cascade=orphan до kubectl delete, Podʼи, якими керує StatefulSet, залишаться навіть після видалення самого обʼєкта StatefulSet. Якщо Podʼи мають мітку app.kubernetes.io/name=MyApp, їх можна видалити так:

kubectl delete pods -l app.kubernetes.io/name=MyApp

Постійні томи

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

Примітка:

Будьте обережні під час видалення PVC, оскільки це може призвести до втрати даних.

Повне видалення StatefulSet

Щоб видалити все у StatefulSet, зокрема повʼязані Podʼи, можна виконати серію команд, подібних до наведених нижче:

grace=$(kubectl get pods <stateful-set-pod> --template '{{.spec.terminationGracePeriodSeconds}}')
kubectl delete statefulset -l app.kubernetes.io/name=MyApp
sleep $grace
kubectl delete pvc -l app.kubernetes.io/name=MyApp

У наведеному вище прикладі Podʼи мають мітку app.kubernetes.io/name=MyApp; за потреби підставте власну мітку.

Примусове видалення Podʼів StatefulSet

Якщо деякі Podʼи у вашому StatefulSet тривалий час залишаються у стані 'Terminating' або 'Unknown', може знадобитися втрутитися вручну, щоб примусово видалити Podʼи з API-сервера. Це потенційно небезпечне завдання. Докладніше дивіться в розділі Примусове видалення Podʼів StatefulSet.

Що далі

Дізнайтеся більше про примусове видалення Podʼів StatefulSet.

8.8 - Примусове видалення Podʼів StatefulSet

На цій сторінці показано, як видаляти Podʼи, що є частиною StatefulSet, і пояснено, що слід враховувати під час цього.

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

  • Це досить складне завдання, яке може порушити деякі властивості, притаманні StatefulSet.
  • Перш ніж продовжити, ознайомтеся з наведеними нижче міркуваннями.

Міркування щодо StatefulSet

Під час нормальної роботи StatefulSet ніколи немає потреби примусово видаляти Pod StatefulSet. Контролер StatefulSet відповідає за створення, масштабування й видалення членів StatefulSet. Він намагається забезпечити, щоб зазначена кількість Podʼів із порядковими номерами від 0 до N-1 працювала й була готовою. StatefulSet гарантує, що в будь-який момент часу в кластері працює не більше одного Podʼа із заданою ідентичністю. Це називається семантикою щонайбільше один, яку забезпечує StatefulSet.

Примусове видалення вручну слід виконувати обережно, оскільки воно може порушити семантику «щонайбільше один», притаманну StatefulSet. StatefulSets можуть використовуватися для запуску розподілених і кластерних застосунків, яким потрібна стабільна мережева ідентичність і стабільне сховище. Ці застосунки часто мають конфігурацію, що ґрунтується на ансамблі з фіксованої кількості членів із фіксованими ідентичностями. Наявність кількох членів з однаковою ідентичністю може мати катастрофічні наслідки й призвести до втрати даних (наприклад, у сценарії split brain у системах на основі кворуму).

Видалення Podʼів

Ви можете виконати коректне видалення Podʼа за допомогою такої команди:

kubectl delete pods <pod>

Щоб таке видалення призвело до коректного завершення, Pod не повинен задавати pod.Spec.TerminationGracePeriodSeconds зі значенням 0. Практика встановлення pod.Spec.TerminationGracePeriodSeconds на 0 секунд є небезпечною й категорично не рекомендована для Podʼів StatefulSet. Коректне видалення безпечне й гарантує, що Pod коректно завершить роботу до того, як kubelet видалить його назву з API-сервера.

Pod не видаляється автоматично, коли вузол недоступний. Podʼи, що працюють на недоступному вузлі, переходять у стан 'Terminating' або 'Unknown' після тайм-ауту. Podʼи також можуть переходити в ці стани, коли користувач намагається коректно видалити Pod на недоступному вузлі. Pod у такому стані можна вилучити з API-сервера лише такими способами:

  • Обʼєкт Node видаляється (вами або контролером вузлів).
  • kubelet на вузлі, що не відповідає, знову починає відповідати, завершує Pod і вилучає запис з API-сервера.
  • Примусове видалення Podʼа користувачем.

Рекомендована практика — використовувати перший або другий підхід. Якщо підтверджено, що вузол не працює (наприклад, постійно відключений від мережі, вимкнений тощо), видаліть обʼєкт Node. Якщо вузол зазнає розділення мережі, спробуйте усунути проблему або дочекайтеся її усунення. Коли мережу буде відновлено, kubelet завершить видалення Podʼа й звільнить його назву в API-сервері.

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

Примусове видалення

Примусове видалення не чекає від kubelet підтвердження, що Pod завершено. Незалежно від того, чи вдасться примусовому видаленню завершити Pod, воно негайно звільняє його назву в API-сервері. Це дає контролеру StatefulSet змогу створити Pod на заміну з тією самою ідентичністю; це може призвести до дублювання Podʼа, який усе ще працює, і якщо цей Pod усе ще може спілкуватися з іншими членами StatefulSet, це порушить семантику «щонайбільше один», яку StatefulSet має гарантувати.

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

Якщо ви хочете примусово видалити Pod за допомогою kubectl версії >= 1.5, виконайте таке:

kubectl delete pods <pod> --grace-period=0 --force

Якщо ви використовуєте будь-яку версію kubectl <= 1.4, пропустіть параметр --force і використайте:

kubectl delete pods <pod> --grace-period=0

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

kubectl patch pod <pod> -p '{"metadata":{"finalizers":null}}'

Завжди виконуйте примусове видалення Podʼів StatefulSet обережно та з повним розумінням ризиків, повʼязаних із цим.

Що далі

Дізнайтеся більше про налагодження StatefulSet.

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, щоб додати нові види ресурсів, які представляють показники метрик.

Щоб дізнатися, як розгорнути Metrics Server, дивіться документацію metrics-server.

Якщо ви використовуєте Minikube, виконайте таку команду, щоб увімкнути metrics-server:

minikube addons enable metrics-server

Запустіть сервер php-apache і відкрийте до нього доступ

Щоб продемонструвати HorizontalPodAutoscaler, ви спочатку запустите Deployment, який запускає контейнер з образом hpa-example, і відкриєте до нього доступ як до Service за допомогою такого маніфесту:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: php-apache
spec:
  selector:
    matchLabels:
      run: php-apache
  template:
    metadata:
      labels:
        run: php-apache
    spec:
      containers:
      - name: php-apache
        image: registry.k8s.io/hpa-example
        ports:
        - containerPort: 80
        resources:
          limits:
            cpu: 500m
          requests:
            cpu: 200m
---
apiVersion: v1
kind: Service
metadata:
  name: php-apache
  labels:
    run: php-apache
spec:
  ports:
  - port: 80
  selector:
    run: php-apache

Для цього виконайте таку команду:

kubectl apply -f https://k8s.io/examples/application/php-apache.yaml
deployment.apps/php-apache created
service/php-apache created

Створіть HorizontalPodAutoscaler

Тепер, коли сервер працює, створіть автомасштабувальник за допомогою kubectl. У цьому допоможе підкоманда kubectl autoscale, що є частиною kubectl.

Незабаром ви виконаєте команду, яка створить HorizontalPodAutoscaler, що підтримує від 1 до 10 реплік Podʼів, керованих Deployment php-apache, який ви створили на першому кроці цих інструкцій.

Загалом, контролер HPA збільшуватиме й зменшуватиме кількість реплік (оновлюючи Deployment), щоб підтримувати середнє використання CPU на рівні 50% по всіх Podʼах. Потім Deployment оновлює ReplicaSet — так працюють усі Deployments у Kubernetes — а потім ReplicaSet додає або вилучає Podʼи відповідно до змін у його .spec.

Оскільки кожен Pod запитує 200 мілі-ядер через kubectl run, це означає середнє використання CPU 100 мілі-ядер. Докладніше про алгоритм дивіться в розділі Деталі алгоритму.

Створіть HorizontalPodAutoscaler:

kubectl autoscale deployment php-apache --cpu=50% --min=1 --max=10
horizontalpodautoscaler.autoscaling/php-apache autoscaled

Ви можете перевірити поточний статус щойно створеного HorizontalPodAutoscaler, виконавши:

# Можна використовувати "hpa" або "horizontalpodautoscaler"; працюють обидві назви.
kubectl get hpa

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

NAME         REFERENCE                     TARGET    MINPODS   MAXPODS   REPLICAS   AGE
php-apache   Deployment/php-apache/scale   0% / 50%  1         10        1          18s

(якщо ви бачите інші HorizontalPodAutoscalers з іншими назвами, це означає, що вони вже існували, і зазвичай це не проблема).

Зверніть увагу, що поточне споживання CPU становить 0%, оскільки немає клієнтів, що надсилають запити на сервер (стовпець TARGET показує середнє значення по всіх Podʼах, керованих відповідним Deployment).

Збільшення навантаження

Далі подивіться, як автомасштабувальник реагує на збільшене навантаження. Для цього ви запустите інший Pod, який діятиме як клієнт. Контейнер у клієнтському Podʼі працює в нескінченному циклі, надсилаючи запити до сервісу php-apache.

# Виконайте це в окремому терміналі,
# щоб навантаження продовжувалося, і ви могли продовжити роботу з рештою кроків
kubectl run -i --tty load-generator --rm --image=busybox:1.28 --restart=Never -- /bin/sh -c "while sleep 0.01; do wget -q -O- http://php-apache; done"

Тепер виконайте:

# натисніть Ctrl+C, щоб припинити перегляд, коли будете готові
kubectl get hpa php-apache --watch

Приблизно за хвилину ви маєте побачити вище навантаження на CPU; наприклад:

NAME         REFERENCE                     TARGET      MINPODS   MAXPODS   REPLICAS   AGE
php-apache   Deployment/php-apache/scale   305% / 50%  1         10        1          3m

а потім більше реплік. Наприклад:

NAME         REFERENCE                     TARGET      MINPODS   MAXPODS   REPLICAS   AGE
php-apache   Deployment/php-apache/scale   305% / 50%  1         10        7          3m

Тут споживання CPU зросло до 305% від запиту. У результаті Deployment було змінено до 7 реплік:

kubectl get deployment php-apache

Ви маєте побачити, що кількість реплік збігається з числом із HorizontalPodAutoscaler

NAME         READY   UP-TO-DATE   AVAILABLE   AGE
php-apache   7/7      7           7           19m

Примітка:

Стабілізація кількості реплік може зайняти кілька хвилин. Оскільки обсяг навантаження ніяк не контролюється, кінцева кількість реплік може відрізнятися від цього прикладу.

Зупиніть генерування навантаження

Щоб завершити приклад, припиніть надсилати навантаження.

У терміналі, де ви створили Pod з образом busybox, зупиніть генерування навантаження, натиснувши <Ctrl> + C.

Потім перевірте результат (приблизно за хвилину):

# натисніть Ctrl+C, щоб припинити перегляд, коли будете готові
kubectl get hpa php-apache --watch

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

NAME         REFERENCE                     TARGET       MINPODS   MAXPODS   REPLICAS   AGE
php-apache   Deployment/php-apache/scale   0% / 50%     1         10        1          11m

і Deployment також показує, що його масштаб зменшився:

kubectl get deployment php-apache
NAME         READY   UP-TO-DATE   AVAILABLE   AGE
php-apache   1/1     1            1           27m

Щойно використання CPU впало до 0, HPA автоматично зменшив кількість реплік назад до 1.

Автоматичне масштабування реплік може зайняти кілька хвилин.

Автомасштабування за кількома метриками та власними метриками

Ви можете додати інші метрики для автомасштабування Deployment php-apache, використовуючи версію API autoscaling/v2.

Спочатку отримайте YAML вашого HorizontalPodAutoscaler у формі autoscaling/v2:

kubectl get hpa php-apache -o yaml > /tmp/hpa-v2.yaml

Відкрийте файл /tmp/hpa-v2.yaml у редакторі, і ви побачите такий YAML:

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: php-apache
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: php-apache
  minReplicas: 1
  maxReplicas: 10
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 50
status:
  observedGeneration: 1
  lastScaleTime: <some-time>
  currentReplicas: 1
  desiredReplicas: 1
  currentMetrics:
  - type: Resource
    resource:
      name: cpu
    current:
      averageUtilization: 0
      averageValue: 0

Зверніть увагу, що поле targetCPUUtilizationPercentage замінено масивом під назвою metrics. Метрика використання CPU є метрикою ресурсу, оскільки вона подана як відсоток ресурсу, вказаного в контейнерах Podʼа. Зверніть увагу, що ви можете вказати інші метрики ресурсів, крім CPU. Стандартно єдина інша підтримувана метрика ресурсу — це memory. Ці ресурси не змінюють назв від кластера до кластера й мають бути доступними завжди, доки доступний API metrics.k8s.io.

Ви також можете вказувати метрики ресурсів у безпосередніх значеннях, а не у відсотках від запитаного значення, використовуючи target.type зі значенням AverageValue замість Utilization і встановлюючи відповідне поле target.averageValue замість target.averageUtilization.

  metrics:
  - type: Resource
    resource:
      name: memory
      target:
        type: AverageValue
        averageValue: 500Mi

Є ще два типи метрик, обидва вважаються власними метриками: метрики Podʼів і метрики обʼєктів. Ці метрики можуть мати назви, специфічні для кластера, і потребують розширенішого налаштування моніторингу кластера.

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

Метрики Podʼів вказуються за допомогою такого блоку метрики:

type: Pods
pods:
  metric:
    name: packets-per-second
  target:
    type: AverageValue
    averageValue: 1k

Другий альтернативний тип метрики — це метрики обʼєктів. Ці метрики описують інший обʼєкт у тому самому просторі імен, а не Podʼи. Метрики не обовʼязково отримуються з обʼєкта; вони лише описують його. Метрики обʼєктів підтримують типи target Value і AverageValue. Для Value ціль порівнюється безпосередньо з метрикою, отриманою з API. Для AverageValue значення, отримане з API власних метрик, ділиться на кількість Podʼів перед порівнянням із ціллю. Наведений нижче приклад — це подання метрики requests-per-second у YAML.

type: Object
object:
  metric:
    name: requests-per-second
  describedObject:
    apiVersion: networking.k8s.io/v1
    kind: Ingress
    name: main-route
  target:
    type: Value
    value: 2k

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

Наприклад, якщо ваша система моніторингу збирає метрики мережевого трафіку, ви можете оновити наведене вище визначення за допомогою kubectl edit, щоб воно мало такий вигляд:

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: php-apache
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: php-apache
  minReplicas: 1
  maxReplicas: 10
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 50
  - type: Pods
    pods:
      metric:
        name: packets-per-second
      target:
        type: AverageValue
        averageValue: 1k
  - type: Object
    object:
      metric:
        name: requests-per-second
      describedObject:
        apiVersion: networking.k8s.io/v1
        kind: Ingress
        name: main-route
      target:
        type: Value
        value: 10k
status:
  observedGeneration: 1
  lastScaleTime: <some-time>
  currentReplicas: 1
  desiredReplicas: 1
  currentMetrics:
  - type: Resource
    resource:
      name: cpu
    current:
      averageUtilization: 0
      averageValue: 0
  - type: Object
    object:
      metric:
        name: requests-per-second
      describedObject:
        apiVersion: networking.k8s.io/v1
        kind: Ingress
        name: main-route
      current:
        value: 10k

Тоді ваш HorizontalPodAutoscaler намагатиметься забезпечити, щоб кожен Pod споживав приблизно 50% запитаного CPU, обслуговував 1000 пакетів за секунду, а всі Podʼи за Ingress main-route разом обслуговували 10000 запитів за секунду.

Автомасштабування за конкретнішими метриками

Багато конвеєрів метрик дають змогу описувати метрики або за назвою, або за набором додаткових дескрипторів, які називаються мітками. Для всіх типів метрик, крім метрик ресурсів (Podʼів, обʼєктів і зовнішніх, описаних нижче), ви можете вказати додатковий селектор міток, який передається вашому конвеєру метрик. Наприклад, якщо ви збираєте метрику http_requests з міткою verb, можна вказати такий блок метрики, щоб масштабувати лише за запитами GET:

type: Object
object:
  metric:
    name: http_requests
    selector: {matchLabels: {verb: GET}}

Цей селектор використовує той самий синтаксис, що й повні селектори міток Kubernetes. Конвеєр моніторингу визначає, як згорнути кілька серій в одне значення, якщо назва й селектор відповідають кільком серіям. Селектор є адитивним і не може вибирати метрики, що описують обʼєкти, які не є цільовим обʼєктом (цільові Podʼи для типу Pods та описаний обʼєкт для типу Object).

Застосунки, що працюють у Kubernetes, можуть потребувати автомасштабування за метриками, які не мають очевидного звʼязку з жодним обʼєктом у кластері Kubernetes, наприклад метриками, що описують розміщений сервіс, який не має прямої кореляції з просторами імен Kubernetes. У Kubernetes 1.10 і новіших версіях цей випадок можна вирішити за допомогою зовнішніх метрик.

Використання зовнішніх метрик потребує знання вашої системи моніторингу; налаштування подібне до потрібного для власних метрик. Зовнішні метрики дають змогу автоматично масштабувати кластер на основі будь-якої метрики, доступної у вашій системі моніторингу. Надайте блок metric з name і selector, як вище, і використовуйте тип метрики External замість Object. Якщо metricSelector відповідає кільком часовим рядам, HorizontalPodAutoscaler використовує суму їхніх значень. Зовнішні метрики підтримують цільові типи Value і AverageValue, які працюють точно так само, як і для типу Object.

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

- type: External
  external:
    metric:
      name: queue_messages_ready
      selector:
        matchLabels:
          queue: "worker_tasks"
    target:
      type: AverageValue
      averageValue: 30

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

Додаток: стани статусу Horizontal Pod Autoscaler

Використовуючи форму autoscaling/v2 HorizontalPodAutoscaler, ви зможете бачити стани статусу, які Kubernetes встановлює на HorizontalPodAutoscaler. Ці стани статусу вказують, чи може HorizontalPodAutoscaler масштабуватися і чи є наразі якісь обмеження.

Стани показано в полі status.conditions. Щоб побачити стани, що впливають на HorizontalPodAutoscaler, можна використати kubectl describe hpa:

kubectl describe hpa cm-test
Name:                           cm-test
Namespace:                      prom
Labels:                         <none>
Annotations:                    <none>
CreationTimestamp:              Fri, 16 Jun 2017 18:09:22 +0000
Reference:                      ReplicationController/cm-test
Metrics:                        ( current / target )
  "http_requests" on pods:      66m / 500m
Min replicas:                   1
Max replicas:                   4
ReplicationController pods:     1 current / 1 desired
Conditions:
  Type                  Status  Reason                  Message
  ----                  ------  ------                  -------
  AbleToScale           True    ReadyForNewScale        the last scale time was sufficiently old as to warrant a new scale
  ScalingActive         True    ValidMetricFound        the HPA was able to successfully calculate a replica count from pods metric http_requests
  ScalingLimited        False   DesiredWithinRange      the desired replica count is within the acceptable range
Events:

Для цього HorizontalPodAutoscaler видно кілька станів у справному статусі. Перший, AbleToScale, вказує, чи може HPA отримувати й оновлювати масштаби, а також чи не завадять масштабуванню умови, повʼязані з backoff. Другий, ScalingActive, вказує, чи увімкнено HPA (тобто кількість реплік цілі не дорівнює нулю) і чи може він обчислювати бажані масштаби. Якщо він False, це зазвичай вказує на проблеми з отриманням метрик. Нарешті, останній стан, ScalingLimited, вказує, що бажаний масштаб обмежено максимумом або мінімумом HorizontalPodAutoscaler. Це ознака того, що вам може знадобитися збільшити або зменшити обмеження мінімальної чи максимальної кількості реплік у вашому HorizontalPodAutoscaler.

Кількості

Усі метрики в HorizontalPodAutoscaler і в API метрик вказуються за допомогою спеціальної нотації цілих чисел, відомої в Kubernetes як кількість. Наприклад, кількість 10500m у десятковій нотації записується як 10.5. API метрик за можливості повертають цілі числа без суфікса, а інакше зазвичай повертають кількості в міліодиницях. Це означає, що значення вашої метрики може коливатися між 1 і 1500m, або між 1 і 1.5 у десятковій нотації.

Інші можливі сценарії

Декларативне створення автомасштабувальника

Замість того щоб створювати HorizontalPodAutoscaler імперативно командою kubectl autoscale, можна створити його декларативно за допомогою такого маніфесту:

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: php-apache
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: php-apache
  minReplicas: 1
  maxReplicas: 10
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 50

Потім створіть автомасштабувальник, виконавши таку команду:

kubectl create -f https://k8s.io/examples/application/hpa/php-apache.yaml
horizontalpodautoscaler.autoscaling/php-apache created

8.10 - Вказання бюджету порушень для вашого застосунку

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

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

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

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

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

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

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

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

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

  • Deployment
  • ReplicationController
  • ReplicaSet
  • StatefulSet

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

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

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

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

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

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

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

Значення для minAvailable або maxUnavailable можуть бути виражені як цілі числа або як відсотки.

  • Коли ви вказуєте ціле число, воно означає кількість Podʼів. Наприклад, якщо встановити minAvailable на 10, завжди мають бути доступними 10 Podʼів, навіть під час порушення.
  • Коли ви вказуєте відсоток, задаючи значення як рядкове представлення відсотка (наприклад, "50%"), воно означає відсоток від загальної кількості Podʼів. Наприклад, якщо встановити minAvailable на "50%", принаймні 50% Podʼів залишаться доступними під час порушення.

Коли ви вказуєте значення як відсоток, воно може не відповідати точній кількості Podʼів. Наприклад, якщо у вас є 7 Podʼів і ви встановите minAvailable на "50%", не одразу очевидно, чи означає це, що мають бути доступними 3 чи 4 Podʼи. Kubernetes округлює вгору до найближчого цілого числа, тому в цьому випадку мають бути доступними 4 Podʼи. Коли ви вказуєте значення maxUnavailable як відсоток, Kubernetes округлює вгору кількість Podʼів, які можуть зазнати порушення. Тому порушення може перевищити визначений вами відсоток maxUnavailable. Ви можете ознайомитися з кодом, який керує такою поведінкою.

Вказання PodDisruptionBudget

PodDisruptionBudget має три поля:

  • Селектор міток .spec.selector, що вказує набір Podʼів, до яких він застосовується. Це поле обовʼязкове.
  • .spec.minAvailable — опис кількості Podʼів із цього набору, які мають залишитися доступними після виселення, навіть за відсутності виселеного Podʼа. minAvailable може бути абсолютним числом або відсотком.
  • .spec.maxUnavailable — опис кількості Podʼів із цього набору, які можуть бути недоступними після виселення. Це також може бути абсолютне число або відсоток.

Примітка:

Порожній селектор ({}) відповідає кожному Podʼу у просторі імен.

Ви можете вказати лише одне з полів maxUnavailable і minAvailable в одному PodDisruptionBudget. maxUnavailable можна використовувати лише для контролю виселення Podʼів, якими керує один і той самий повʼязаний контролер. У наведених нижче прикладах «бажані репліки» — це scale контролера, що керує Podʼами, вибраними PodDisruptionBudget.

Приклад 1: із minAvailable 5 виселення дозволяються, доки після них залишається 5 або більше справних Podʼів серед вибраних selector у PodDisruptionBudget.

Приклад 2: із minAvailable 30% виселення дозволяються, доки принаймні 30% від кількості бажаних реплік справні.

Приклад 3: із maxUnavailable 5 виселення дозволяються, доки серед загальної кількості бажаних реплік є не більше 5 несправних реплік.

Приклад 4: із maxUnavailable 30% виселення дозволяються, доки кількість несправних реплік не перевищує 30% від загальної кількості бажаних реплік, округлених вгору до найближчого цілого числа. Якщо загальна кількість бажаних реплік лише одна, ця єдина репліка все одно може зазнати порушення, що фактично означає 100% недоступність.

Зазвичай один бюджет використовується для набору Podʼів, керованих контролером, наприклад Podʼів в одному ReplicaSet або StatefulSet.

Примітка:

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

Якщо ви встановите maxUnavailable на 0% або 0 чи minAvailable на 100% або на кількість реплік, ви вимагаєте нуль добровільних виселень. Якщо задати нуль добровільних виселень для обʼєкта робочого навантаження, як-от ReplicaSet, ви не зможете успішно виконати drain вузла, на якому працює один із цих Podʼів. Якщо спробувати виконати drain вузла, де працює Pod, який не можна виселити, drain ніколи не завершиться. Це дозволено семантикою PodDisruptionBudget.

Нижче наведено приклади визначень бюджетів порушень Podʼів. Вони відповідають Podʼам з міткою app: zookeeper.

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

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

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

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

Наприклад, якщо наведений вище обʼєкт zk-pdb вибирає Podʼи StatefulSet розміром 3, обидві специфікації означають те саме. Рекомендовано використовувати maxUnavailable, оскільки він автоматично реагує на зміни кількості реплік відповідного контролера.

Створення обʼєкта PDB

Створити або оновити обʼєкт PDB можна за допомогою kubectl.

kubectl apply -f mypdb.yaml

Перевірка статусу PDB

Використайте kubectl, щоб перевірити, що ваш PDB створено.

Якщо у вашому просторі імен насправді немає Podʼів, що відповідають app: zookeeper, ви побачите щось подібне:

kubectl get poddisruptionbudgets
NAME     MIN AVAILABLE   MAX UNAVAILABLE   ALLOWED DISRUPTIONS   AGE
zk-pdb   2               N/A               0                     7s

Якщо є відповідні Podʼи (скажімо, 3), ви побачите щось подібне:

kubectl get poddisruptionbudgets
NAME     MIN AVAILABLE   MAX UNAVAILABLE   ALLOWED DISRUPTIONS   AGE
zk-pdb   2               N/A               1                     7s

Ненульове значення ALLOWED DISRUPTIONS означає, що контролер порушень побачив Podʼи, порахував відповідні Podʼи й оновив статус PDB.

Ви можете отримати більше інформації про статус PDB за допомогою цієї команди:

kubectl get poddisruptionbudgets zk-pdb -o yaml
apiVersion: policy/v1
kind: PodDisruptionBudget
metadata:
  annotations:
…
  creationTimestamp: "2020-03-04T04:22:56Z"
  generation: 1
  name: zk-pdb
…
status:
  currentHealthy: 3
  desiredHealthy: 2
  disruptionsAllowed: 1
  expectedPods: 3
  observedGeneration: 1

Справність Podʼа

Поточна реалізація вважає справними Podʼи, які мають елемент .status.conditions з type="Ready" і status="True". Ці Podʼи відстежуються через поле .status.currentHealthy у статусі PDB.

Політика виселення несправних Podʼів

This is a stable feature in Kubernetes, and has been since the 1.31 release. You can no longer toggle this feature (the associated feature gate has been removed).

PodDisruptionBudget, що захищає застосунок, гарантує, що кількість Podʼів у .status.currentHealthy не опуститься нижче за кількість, вказану в .status.desiredHealthy, не дозволяючи виселення справних Podʼів. За допомогою .spec.unhealthyPodEvictionPolicy ви також можете визначити критерії, за яких несправні Podʼи слід розглядати для виселення. Стандартна поведінка, коли політику не вказано, відповідає політиці IfHealthyBudget.

Політики:

IfHealthyBudget
Запущені (.status.phase="Running"), але ще несправні Podʼи можна виселити, лише якщо захищений застосунок не зазнає порушення (.status.currentHealthy щонайменше дорівнює .status.desiredHealthy).

Ця політика гарантує, що запущені Podʼи застосунку, який уже зазнав порушення, мають найкращий шанс стати справними. Це має негативні наслідки для drain вузлів, який можуть блокувати застосунки з некоректною поведінкою, захищені PDB. Зокрема, застосунки з Podʼами у стані CrashLoopBackOff (через помилку або неправильну конфігурацію) або Podʼами, яким просто не вдається повідомити про стан Ready.

AlwaysAllow
Запущені (.status.phase="Running"), але ще несправні Podʼи вважаються такими, що зазнали порушення, і їх можна виселити незалежно від того, чи виконуються критерії PDB.

Це означає, що запущені Podʼи застосунку, який зазнав порушення, можуть не отримати шансу стати справними. За допомогою цієї політики менеджери кластера можуть легко виселяти застосунки з некоректною поведінкою, захищені PDB. Зокрема, застосунки з Podʼами у стані CrashLoopBackOff (через помилку або неправильну конфігурацію) або Podʼами, яким просто не вдається повідомити про стан Ready.

Примітка:

Podʼи у фазах Pending, Succeeded або Failed завжди вважаються кандидатами на виселення.

Довільні робочі навантаження та довільні селектори

Цей розділ можна пропустити, якщо ви використовуєте PDB лише з вбудованими ресурсами робочих навантажень (Deployment, ReplicaSet, StatefulSet і ReplicationController) або з власними ресурсами, які реалізують субресурс scale, і де селектор PDB точно відповідає селектору ресурсу-власника Podʼа.

Ви можете використовувати PDB з Podʼами, керованими іншим ресурсом, «оператором», або з окремими Podʼами, але з такими обмеженнями:

  • можна використовувати лише .spec.minAvailable, а не .spec.maxUnavailable.
  • можна використовувати лише ціле значення з .spec.minAvailable, а не відсоток.

Інші конфігурації доступності використовувати неможливо, оскільки Kubernetes не може визначити загальну кількість Podʼів без підтримуваного ресурсу-власника.

Ви можете використовувати селектор, який вибирає підмножину або надмножину Podʼів, що належать ресурсу робочого навантаження. Eviction API забороняє виселення будь-якого Podʼа, що підпадає під кілька PDB, тому більшість користувачів захоче уникати селекторів, що перекриваються. Розумне використання PDB, що перекриваються, — коли Podʼи переводяться з одного PDB на інший.

8.11 - Отримання доступу до API Kubernetes з Podʼа

У цьому посібнику показано, як отримати доступ до API Kubernetes зсередини Podʼа.

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

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

Отримання доступу до API зсередини Podʼа

Під час доступу до API зсередини Podʼа пошук API-сервера й автентифікація на ньому дещо відрізняються від випадку зовнішнього клієнта.

Найпростіший спосіб використовувати API Kubernetes із Podʼа — застосувати одну з офіційних клієнтських бібліотек. Ці бібліотеки можуть автоматично знаходити API-сервер і автентифікуватися.

Використання офіційних клієнтських бібліотек

Зсередини Podʼа рекомендовано підʼєднуватися до API Kubernetes такими способами:

У кожному випадку для безпечного звʼязку з API-сервером використовуються облікові дані службового облікового запису Podʼа.

Прямий доступ до REST API

Під час роботи в Podʼі ваш контейнер може сформувати HTTPS URL для API-сервера Kubernetes, отримавши змінні середовища KUBERNETES_SERVICE_HOST і KUBERNETES_SERVICE_PORT_HTTPS. Внутрішньокластерну адресу API-сервера також опубліковано в Service з назвою kubernetes у просторі імен default, тож Podʼи можуть використовувати kubernetes.default.svc як DNS-імʼя локального API-сервера.

Примітка:

Kubernetes не гарантує, що API-сервер має дійсний сертифікат для імені хоста kubernetes.default.svc; однак від панелі управління очікується, що вона надасть дійсний сертифікат для імені хоста або IP-адреси, які представляє $KUBERNETES_SERVICE_HOST.

Рекомендований спосіб автентифікації на API-сервері — за допомогою облікових даних службового облікового запису. Стандартно Pod повʼязаний зі службовим обліковим записом, а облікові дані (токен) цього запису розміщуються в дереві файлової системи кожного контейнера цього Podʼа, у /var/run/secrets/kubernetes.io/serviceaccount/token.

Якщо доступний, набір сертифікатів розміщується в дереві файлової системи кожного контейнера у /var/run/secrets/kubernetes.io/serviceaccount/ca.crt, і його слід використовувати для перевірки серверного сертифіката API-сервера.

Нарешті, стандартний простір імен для операцій API в межах простору імен розміщується у файлі /var/run/secrets/kubernetes.io/serviceaccount/namespace у кожному контейнері.

Використання kubectl proxy

Якщо ви хочете надсилати запити до API без офіційної клієнтської бібліотеки, можна запустити kubectl proxy як команду нового sidecar-контейнера в Podʼі. Так kubectl proxy автентифікуватиметься в API й відкриє доступ до нього на інтерфейсі localhost Podʼа, щоб інші контейнери в Podʼі могли використовувати його безпосередньо.

Без використання проксі

Можна обійтися без kubectl proxy, передаючи токен автентифікації безпосередньо API-серверу. Внутрішній сертифікат захищає зʼєднання.

# Вказати імʼя хоста внутрішнього API-сервера
APISERVER=https://kubernetes.default.svc

# Шлях до токена ServiceAccount
SERVICEACCOUNT=/var/run/secrets/kubernetes.io/serviceaccount

# Прочитати простір імен цього Podʼа
NAMESPACE=$(cat ${SERVICEACCOUNT}/namespace)

# Прочитати bearer-токен ServiceAccount
TOKEN=$(cat ${SERVICEACCOUNT}/token)

# Вказати внутрішній центр сертифікації (CA)
CACERT=${SERVICEACCOUNT}/ca.crt

# Досліджувати API за допомогою TOKEN
curl --cacert ${CACERT} --header "Authorization: Bearer ${TOKEN}" -X GET ${APISERVER}/api

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

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

9 - Запуск Jobs

Запуск Jobs із паралельною обробкою.

9.1 - Виконання автоматизованих завдань за допомогою CronJob

На цій сторінці показано, як виконувати автоматизовані завдання за допомогою обʼєкта Kubernetes CronJob.

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

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

Створення CronJob

CronJobs потребують файлу конфігурації. Ось маніфест CronJob, який щохвилини запускає просте демонстраційне завдання:

apiVersion: batch/v1
kind: CronJob
metadata:
  name: hello
spec:
  schedule: "* * * * *"
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: hello
            image: busybox:1.28
            imagePullPolicy: IfNotPresent
            command:
            - /bin/sh
            - -c
            - date; echo Hello from the Kubernetes cluster
          restartPolicy: OnFailure

Запустіть приклад CronJob за допомогою цієї команди:

kubectl create -f https://k8s.io/examples/application/job/cronjob.yaml

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

cronjob.batch/hello created

Після створення 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 бере одну одиницю роботи з черги завдань, виконує її, видаляє її з черги та завершує роботу.

Ось огляд кроків у цьому прикладі:

  1. Запустіть сервіс черги повідомлень. У цьому прикладі використовується RabbitMQ, але можна використати інший. На практиці ви налаштували б сервіс черги повідомлень один раз і повторно використовували б його для багатьох Jobs.
  2. Створіть чергу й заповніть її повідомленнями. Кожне повідомлення представляє одне завдання, яке потрібно виконати. У цьому прикладі повідомлення — це ціле число, над яким ми виконаємо тривалі обчислення.
  3. Запустіть Job, який працює над завданнями з черги. Job запускає кілька Podʼів. Кожен Pod бере одне завдання з черги повідомлень, обробляє його й завершує роботу.

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

Ви вже маєте знати базове, непаралельне використання Job.

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

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

Цей приклад завдання також передбачає, що Docker встановлено локально.

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

У цьому прикладі використовується RabbitMQ, проте ви можете адаптувати його для іншого сервісу повідомлень типу AMQP.

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

Запустіть RabbitMQ таким чином:

# Створіть Service для використання StatefulSet
kubectl create -f https://kubernetes.io/examples/application/job/rabbitmq/rabbitmq-service.yaml
service "rabbitmq-service" created
kubectl create -f https://kubernetes.io/examples/application/job/rabbitmq/rabbitmq-statefulset.yaml
statefulset "rabbitmq" created

Тестування сервісу черги повідомлень

Тепер можна спробувати звернутися до черги повідомлень. Ми створимо тимчасовий інтерактивний Pod, встановимо на ньому деякі інструменти й поекспериментуємо з чергами.

Спочатку створіть тимчасовий інтерактивний Pod.

# Створіть тимчасовий інтерактивний контейнер
kubectl run -i --tty temp --image ubuntu:22.04
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ʼа:

apt-get update && apt-get install -y curl ca-certificates amqp-tools python3 dnsutils

Пізніше ви створите образ контейнера, що містить ці пакети.

Далі перевірте, чи можете виявити Service для RabbitMQ:

# Виконайте ці команди всередині Podʼа
# Зверніть увагу, що rabbitmq-service має DNS-імʼя, надане Kubernetes:
nslookup rabbitmq-service
Server:        10.0.0.10
Address:    10.0.0.10#53

Name:    rabbitmq-service.default.svc.cluster.local
Address: 10.0.147.152

(IP-адреси будуть іншими)

Якщо надбудову 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.
export BROKER_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 $f
done

Ви додали 8 повідомлень до черги.

Створення образу контейнера

Тепер ви готові створити образ, який ви будете запускати як Job.

Job використовуватиме утиліту amqp-consume, щоб читати повідомлення з черги й виконувати фактичну роботу. Ось дуже простий приклад програми:

#!/usr/bin/env python

# Just prints standard out and sleeps for 10 seconds.
import sys
import time
print("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) і змінити назву образу контейнера на ту, яку ви використали.

apiVersion: batch/v1
kind: Job
metadata:
  name: job-wq-1
spec:
  completions: 8
  parallelism: 2
  template:
    metadata:
      name: job-wq-1
    spec:
      containers:
      - name: c
        image: gcr.io/<project>/job-wq-1
        env:
        - name: BROKER_URL
          value: amqp://guest:guest@rabbitmq-service:5672
        - name: QUEUE
          value: job1
      restartPolicy: OnFailure

У цьому прикладі кожен 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.

Нижче наведено огляд кроків у цьому прикладі:

  1. Визначте маніфест Job з індексованим завершенням. Downward API дозволяє передати анотацію індексу Podʼа контейнеру як змінну середовища або файл.
  2. Запустіть Indexed Job на основі цього маніфесту.

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

Ви вже маєте знати базове, непаралельне використання Job.

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

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

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

Оберіть підхід

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

  1. Прочитати змінну середовища JOB_COMPLETION_INDEX. Контролер Job автоматично повʼязує цю змінну з анотацією, що містить індекс завершення.
  2. Прочитати файл, який містить індекс завершення.
  3. Якщо програму не можна змінити, її можна обгорнути скриптом, який читає індекс будь-яким із наведених вище способів і перетворює його на щось, що програма може використати як вхідні дані.

У цьому прикладі уявіть, що ви обрали варіант 3 і хочете запустити утиліту rev. Ця програма приймає файл як аргумент і виводить його вміст у зворотному порядку.

rev data.txt

Ви використаєте інструмент rev з образу контейнера busybox.

Оскільки це лише приклад, кожен Pod виконує лише дрібну частину роботи (розвертає короткий рядок). У реальному робочому навантаженні ви могли б, наприклад, створити Job, що представляє завдання створення 60 секунд відео на основі даних сцени. Кожним робочим елементом у Job рендерингу відео був би рендеринг певного кадру цього відеокліпу. Індексоване завершення означало б, що кожен Pod у Job знає, який кадр рендерити й публікувати, рахуючи кадри від початку кліпу.

Визначте Indexed Job

Ось приклад маніфесту Job, який використовує режим завершення Indexed:

apiVersion: batch/v1
kind: Job
metadata:
  name: 'indexed-job'
spec:
  completions: 5
  parallelism: 3
  completionMode: Indexed
  template:
    spec:
      restartPolicy: Never
      initContainers:
      - name: 'input'
        image: 'docker.io/library/bash'
        command:
        - "bash"
        - "-c"
        - |
          items=(foo bar baz qux xyz)
          echo ${items[$JOB_COMPLETION_INDEX]} > /input/data.txt
        volumeMounts:
        - mountPath: /input
          name: input
      containers:
      - name: 'worker'
        image: 'docker.io/library/busybox'
        command:
        - "rev"
        - "/input/data.txt"
        volumeMounts:
        - mountPath: /input
          name: input
      volumes:
      - name: input
        emptyDir: {}

У наведеному вище прикладі ви використовуєте вбудовану змінну середовища JOB_COMPLETION_INDEX, яку контролер Job встановлює для всіх контейнерів. Init-контейнер зіставляє індекс зі статичним значенням і записує його у файл, спільний із контейнером робочого процесу через том emptyDir. За бажання можна визначити власну змінну середовища через downward API, щоб публікувати індекс у контейнери. Також можна завантажити список значень із ConfigMap як змінну середовища або файл.

Або ви можете безпосередньо використати downward API для передачі значення анотації як файлу тому, як показано в наведеному нижче прикладі:

apiVersion: batch/v1
kind: Job
metadata:
  name: 'indexed-job'
spec:
  completions: 5
  parallelism: 3
  completionMode: Indexed
  template:
    spec:
      restartPolicy: Never
      containers:
      - name: 'worker'
        image: 'docker.io/library/busybox'
        command:
        - "rev"
        - "/input/data.txt"
        volumeMounts:
        - mountPath: /input
          name: input
      volumes:
      - name: input
        downwardAPI:
          items:
          - path: "data.txt"
            fieldRef:
              fieldPath: metadata.annotations['batch.kubernetes.io/job-completion-index']

Запуск Job

Тепер запустіть Job:

# Це використовує перший підхід (покладаючись на $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.

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

Ви вже маєте знати основи використання Job.

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

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

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

Примітка:

Якщо ви використовуєте minikube або подібний інструмент, може знадобитися виконати додаткові кроки, щоб забезпечити наявність DNS.

Запуск Job із взаємодією між Podʼами

Щоб увімкнути взаємодію між Podʼами за іменами хостів Podʼів у Job, потрібно зробити таке:

  1. Налаштуйте headless Service із дійсним селектором міток для Podʼів, створених вашим Job. Headless Service має бути в тому самому просторі імен, що й Job. Простий спосіб зробити це — використати селектор job-name: <your-job-name>, оскільки Kubernetes автоматично додає мітку job-name. Ця конфігурація спонукає систему DNS створити записи імен хостів Podʼів, що виконують ваш Job.

  2. Налаштуйте headless Service як сервіс піддомену для Podʼів Job, додавши таке значення до специфікації шаблону Job:

    subdomain: <headless-svc-name>
    

Приклад

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

Примітка:

У скрипті Bash, який виконується в кожному Podʼі у наведеному нижче прикладі, імена хостів Podʼів можуть також мати префікс простору імен, якщо Pod має бути доступний ззовні простору імен.
apiVersion: v1
kind: Service
metadata:
  name: headless-svc
spec:
  clusterIP: None # clusterIP має бути None для створення headless Service
  selector:
    job-name: example-job # має відповідати назві Job
---
apiVersion: batch/v1
kind: Job
metadata:
  name: example-job
spec:
  completions: 3
  parallelism: 3
  completionMode: Indexed
  template:
    spec:
      subdomain: headless-svc # має відповідати назві Service
      restartPolicy: Never
      containers:
      - name: example-workload
        image: bash:latest
        command:
        - 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 бере одну одиницю роботи з черги завдань, обробляє її й повторює це, доки не буде досягнуто кінця черги.

Ось загальний огляд кроків у цьому прикладі:

  1. Запустіть сервіс зберігання для робочої черги. У цьому прикладі ви використаєте Redis для зберігання робочих елементів. У попередньому прикладі ви використовували RabbitMQ. У цьому прикладі ви використаєте Redis і власну клієнтську бібліотеку робочої черги, тому що AMQP не дає клієнтам зручного способу виявити, що робоча черга скінченної довжини порожня. На практиці ви один раз налаштуєте сховище на кшталт Redis і повторно використовуватимете його для робочих черг багатьох Jobs та для інших потреб.
  2. Створіть чергу й заповніть її повідомленнями. Кожне повідомлення представляє одне завдання, яке потрібно виконати. У цьому прикладі повідомлення — це ціле число, над яким ми виконаємо тривалі обчислення.
  3. Запустіть Job, який працює над завданнями з черги. Job запускає кілька Podʼів. Кожен Pod бере одне завдання з черги повідомлень, обробляє його й повторює це, доки не буде досягнуто кінця черги.

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

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

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

Цей приклад завдання також передбачає, що Docker встановлено локально. Docker використовується для збирання образів контейнерів.

Ви маєте знати базове, непаралельне використання Job.

Запуск Redis

Для простоти в цьому прикладі ви запустите один екземпляр Redis. Приклад масштабованого й відмовостійкого розгортання Redis дивіться в прикладі Redis.

Ви також можете безпосередньо завантажити такі файли:

Щоб запустити один екземпляр Redis, потрібно створити Pod redis і Service redis:

kubectl apply -f https://k8s.io/examples/application/job/redis/redis-pod.yaml
kubectl apply -f https://k8s.io/examples/application/job/redis/redis-service.yaml

Заповнення черги завданнями

Тепер заповнімо чергу кількома «завданнями». У цьому прикладі завдання — це рядки, які потрібно вивести.

Запустіть тимчасовий інтерактивний Pod для запуску Redis CLI.

kubectl run -i --tty temp --image redis --command "/bin/sh"
Waiting for pod default/redis2-c7h78 to be running, status is Pending, pod ready: false
Hit enter for command prompt

Тепер натисніть Enter, запустіть Redis CLI і створіть список із кількома робочими елементами.

redis-cli -h redis
redis:6379> rpush job2 "apple"
(integer) 1
redis:6379> rpush job2 "banana"
(integer) 2
redis:6379> rpush job2 "cherry"
(integer) 3
redis:6379> rpush job2 "date"
(integer) 4
redis:6379> rpush job2 "fig"
(integer) 5
redis:6379> rpush job2 "grape"
(integer) 6
redis:6379> rpush job2 "lemon"
(integer) 7
redis:6379> rpush job2 "melon"
(integer) 8
redis:6379> rpush job2 "orange"
(integer) 9
redis:6379> lrange job2 0 -1
1) "apple"
2) "banana"
3) "cherry"
4) "date"
5) "fig"
6) "grape"
7) "lemon"
8) "melon"
9) "orange"

Отже, список із ключем job2 буде робочою чергою.

Примітка: якщо Kube DNS налаштовано неправильно, може знадобитися змінити перший крок у наведеному вище блоці на redis-cli -h $REDIS_SERVICE_HOST.

Створення образу контейнера

Тепер ви готові створити образ, який оброблятиме роботу в цій черзі.

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

Надається проста клієнтська бібліотека робочої черги Redis rediswq.py (Завантажити).

Програма-«робітник» у кожному Podʼі Job використовує клієнтську бібліотеку робочої черги, щоб отримувати роботу. Ось вона:

#!/usr/bin/env python

import time
import rediswq

host="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()))
while not q.empty():
  item = q.lease(lease_secs=10, block=True, timeout=2) 
  if item is not None:
    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

Потрібно надіслати образ у публічний репозиторій або налаштувати кластер для доступу до вашого приватного репозиторію.

Визначення Job

Ось маніфест для створення Job:

apiVersion: batch/v1
kind: Job
metadata:
  name: job-wq-2
spec:
  parallelism: 2
  template:
    metadata:
      name: job-wq-2
    spec:
      containers:
      - name: c
        image: gcr.io/myproject/job-wq-2
      restartPolicy: OnFailure

Примітка:

Не забудьте відредагувати маніфест, змінивши gcr.io/myproject на свій власний шлях.

У цьому прикладі кожен Pod працює над кількома елементами черги, а потім завершується, коли елементів більше немає. Оскільки робочі процеси самі виявляють, що робоча черга порожня, а контролер Job не знає про робочу чергу, він покладається на те, що робочі процеси повідомлять про завершення роботи. Робочі процеси сигналізують, що черга порожня, успішно завершуючись. Тож щойно будь-який робочий процес успішно завершиться, контролер знає, що роботу виконано і що Podʼи незабаром завершаться. Тому кількість завершень Job потрібно лишити незаданою. Контролер Job також зачекає завершення інших Podʼів.

Запуск Job

Отже, тепер запустіть Job:

# передбачається, що ви вже завантажили та відредагували маніфест
kubectl apply -f ./job.yaml

Тепер трохи зачекайте, а потім перевірте стан Job:

kubectl describe jobs/job-wq-2
Name:             job-wq-2
Namespace:        default
Selector:         controller-uid=b1c7e4e3-92e1-11e7-b85e-fa163ee3c11f
Labels:           controller-uid=b1c7e4e3-92e1-11e7-b85e-fa163ee3c11f
                  job-name=job-wq-2
Annotations:      <none>
Parallelism:      2
Completions:      <unset>
Start Time:       Mon, 11 Jan 2022 17:07:59 +0000
Pods Statuses:    1 Running / 0 Succeeded / 0 Failed
Pod Template:
  Labels:       controller-uid=b1c7e4e3-92e1-11e7-b85e-fa163ee3c11f
                job-name=job-wq-2
  Containers:
   c:
    Image:              container-registry.example/exampleproject/job-wq-2
    Port:
    Environment:        <none>
    Mounts:             <none>
  Volumes:              <none>
Events:
  FirstSeen    LastSeen    Count    From            SubobjectPath    Type        Reason            Message
  ---------    --------    -----    ----            -------------    --------    ------            -------
  33s          33s         1        {job-controller }                Normal      SuccessfulCreate  Created pod: job-wq-2-lglf8

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

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

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

Ви маєте знати базове, непаралельне використання Job.

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

Для базового шаблонування вам потрібна утиліта командного рядка sed.

Для виконання прикладу з розширеним шаблонуванням потрібен робочий Python і бібліотека шаблонів Jinja2 для Python.

Після налаштування Python ви можете встановити Jinja2, виконавши:

pip install --user jinja2

Створення Job на основі шаблону

Спочатку завантажте наведений нижче шаблон Job у файл job-tmpl.yaml. Ось що ви завантажите:

apiVersion: batch/v1
kind: Job
metadata:
  name: process-item-$ITEM
  labels:
    jobgroup: jobexample
spec:
  template:
    metadata:
      name: jobexample
      labels:
        jobgroup: jobexample
    spec:
      containers:
      - name: c
        image: busybox:1.28
        command: ["sh", "-c", "echo Processing item $ITEM && sleep 5"]
      restartPolicy: Never
# Використайте curl для завантаження job-tmpl.yaml
curl -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, щоб розгорнути шаблон:

alias render_template='python -c "from jinja2 import Template; import sys; print(Template(sys.stdin.read()).render());"'

Використайте render_template, щоб перетворити параметри й шаблон на один файл YAML із маніфестами Kubernetes:

# Це потребує визначеного раніше псевдоніма
cat job.yaml.jinja2 | render_template > jobs.yaml

Ви можете переглянути jobs.yaml, щоб переконатися, що скрипт render_template спрацював правильно.

Коли ви переконаєтеся, що render_template працює так, як задумано, можна передати його вивід до kubectl:

cat job.yaml.jinja2 | render_template | kubectl apply -f -

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).

У цьому документі показано, як використовувати політику збоїв Podʼа разом зі стандартною політикою backoff для збоїв Podʼа, щоб краще контролювати обробку збоїв на рівні контейнера або Podʼа в межах Job.

Визначення політики збоїв Podʼа може допомогти:

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

Ви вже маєте знати основи використання Job.

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

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

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

Сценарії використання

Розгляньмо такі сценарії використання для Jobs, які визначають політику збоїв Podʼа:

Використання політики збоїв Podʼа для уникнення непотрібних повторних спроб запуску Podʼів

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

  1. Перегляньте наведений нижче маніфест:

    apiVersion: batch/v1
    kind: Job
    metadata:
      name: job-pod-failure-policy-failjob
    spec:
      completions: 8
      parallelism: 2
      template:
        spec:
          restartPolicy: Never
          containers:
          - name: main
            image: docker.io/library/bash:5
            command: ["bash"]
            args:
            - -c
            - echo "Hello world! I'm going to exit with 42 to simulate a software bug." && sleep 30 && exit 42
      backoffLimit: 6
      podFailurePolicy:
        rules:
        - action: FailJob
          onExitCodes:
            containerName: main
            operator: In
            values: [42]
    
  2. Застосуйте маніфест:

    kubectl create -f https://k8s.io/examples/controllers/job-pod-failure-policy-failjob.yaml
    
  3. Приблизно через 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 зазнає збою.

Очищення

Видаліть створений Job:

kubectl delete jobs/job-pod-failure-policy-failjob

Кластер автоматично очищає Podʼи.

Використання політики збоїв Podʼа для ігнорування порушень роботи Podʼів

У наведеному нижче прикладі ви дізнаєтеся, як за допомогою політики збоїв Podʼа зробити так, щоб порушення роботи Podʼів не збільшували лічильник повторних спроб Podʼа в межах .spec.backoffLimit.

Увага:

У цьому прикладі важливий час, тому варто прочитати кроки перед виконанням. Щоб спричинити порушення роботи Podʼа, важливо виконати drain вузла, поки Pod працює на ньому (протягом 90 секунд після планування Podʼа).
  1. Перегляньте наведений нижче маніфест:

    apiVersion: batch/v1
    kind: Job
    metadata:
      name: job-pod-failure-policy-ignore
    spec:
      completions: 4
      parallelism: 2
      template:
        spec:
          restartPolicy: Never
          containers:
          - name: main
            image: docker.io/library/bash:5
            command: ["bash"]
            args:
            - -c
            - echo "Hello world! I'm going to exit with 0 (success)." && sleep 90 && exit 0
      backoffLimit: 0
      podFailurePolicy:
        rules:
        - action: Ignore
          onPodConditions:
          - type: DisruptionTarget
    
  2. Застосуйте маніфест:

    kubectl create -f https://k8s.io/examples/controllers/job-pod-failure-policy-ignore.yaml
    
  3. Виконайте цю команду, щоб перевірити nodeName, на який заплановано Pod:

    nodeName=$(kubectl get pods -l job-name=job-pod-failure-policy-ignore -o jsonpath='{.items[0].spec.nodeName}')
    
  4. Виконайте drain вузла, щоб виселити Pod до його завершення (протягом 90 секунд):

    kubectl drain nodes/$nodeName --ignore-daemonsets --grace-period=0
    
  5. Перевірте .status.failed, щоб переконатися, що лічильник для Job не збільшено:

    kubectl get jobs -l job-name=job-pod-failure-policy-ignore -o yaml
    
  6. Виконайте 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ʼа).
  1. Перегляньте наведений нижче маніфест:

    apiVersion: batch/v1
    kind: Job
    metadata:
      name: job-pod-failure-policy-config-issue
    spec:
      completions: 8
      parallelism: 2
      template:
        spec:
          restartPolicy: Never
          containers:
          - name: main
            image: "non-existing-repo/non-existing-image:example"
      backoffLimit: 6
      podFailurePolicy:
        rules:
        - action: FailJob
          onPodConditions:
          - type: ConfigIssue
    
  2. Застосуйте маніфест:

    kubectl create -f https://k8s.io/examples/controllers/job-pod-failure-policy-config-issue.yaml
    

    Зверніть увагу, що образ налаштовано неправильно, оскільки його не існує.

  3. Перевірте статус Podʼів Job, виконавши команду:

    kubectl get pods -l job-name=job-pod-failure-policy-config-issue -o yaml
    

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

    containerStatuses:
    - image: non-existing-repo/non-existing-image:example
       ...
       state:
       waiting:
          message: Back-off pulling image "non-existing-repo/non-existing-image:example"
          reason: ImagePullBackOff
          ...
    phase: Pending
    

    Зверніть увагу, що Pod лишається у фазі Pending, оскільки не може завантажити неправильно налаштований образ. Це, в принципі, могло б бути тимчасовою проблемою, і образ міг би завантажитися. Однак у цьому випадку образу не існує, тому ми вказуємо на це за допомогою власного стану.

  4. Додайте власний стан. Спочатку підготуйте патч, виконавши команду:

    cat <<EOF > patch.yaml
    status:
      conditions:
      - type: ConfigIssue
        status: "True"
        reason: "NonExistingImage"
        lastTransitionTime: "$(date -u +"%Y-%m-%dT%H:%M:%SZ")"
    EOF
    

    По-друге, виберіть один із Podʼів, створених Job, виконавши команду:

    podName=$(kubectl get pods -l job-name=job-pod-failure-policy-config-issue -o jsonpath='{.items[0].metadata.name}')
    

    Потім застосуйте патч до одного з Podʼів, виконавши таку команду:

    kubectl patch pod $podName --subresource=status --patch-file=patch.yaml
    

    Якщо патч успішно застосовано, ви отримаєте повідомлення такого типу:

    pod/job-pod-failure-policy-config-issue-k6pvp patched
    
  5. Видаліть Pod, щоб перевести його у фазу Failed, виконавши команду:

    kubectl delete pods/$podName
    
  6. Перевірте статус 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 має автоматизувати контролер, наданий користувачем.

Очищення

Видаліть створений Job:

kubectl delete jobs/job-pod-failure-policy-config-issue

Кластер автоматично очищає Podʼи.

Використання політики збоїв Podʼа для уникнення непотрібних повторних спроб запуску Podʼів за індексами

Щоб уникнути непотрібних перезапусків Podʼів для кожного індексу, можна використовувати можливості політика збоїв Podʼа й обмеження backoff на індекс. У цьому розділі сторінки показано, як використовувати ці можливості разом.

  1. Перегляньте наведений нижче маніфест:

    apiVersion: batch/v1
    kind: Job
    metadata:
      name: job-backoff-limit-per-index-failindex
    spec:
      completions: 4
      parallelism: 2
      completionMode: Indexed
      backoffLimitPerIndex: 1
      template:
        spec:
          restartPolicy: Never
          containers:
          - name: main
            image: docker.io/library/python:3
            command:
              # 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: 6
      podFailurePolicy:
        rules:
        - action: FailIndex
          onExitCodes:
            containerName: main
            operator: In
            values: [42]
    
  2. Застосуйте маніфест:

    kubectl create -f https://k8s.io/examples/controllers/job-backoff-limit-per-index-failindex.yaml
    
  3. Приблизно через 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.
  4. Перевірте статус Job, виконавши:

    kubectl get jobs -l job-name=job-backoff-limit-per-index-failindex -o yaml
    

    У статусі Job поле failedIndexes показує "0,1", оскільки обидва індекси зазнали збою. Оскільки індекс 1 не повторювався, кількість збійних Podʼів, вказана в полі статусу "failed", дорівнює 3.

Очищення

Видаліть створений Job:

kubectl delete jobs/job-backoff-limit-per-index-failindex

Кластер автоматично очищає Podʼи.

Альтернативи

Ви можете покладатися лише на політику backoff для збоїв Podʼа, вказавши поле .spec.backoffLimit у Job. Однак у багатьох ситуаціях важко знайти баланс: значення .spec.backoffLimit має бути достатньо низьким, щоб уникати непотрібних повторних спроб Podʼів, але достатньо високим, щоб Job не завершувався через порушення роботи Podʼів.

10 - Доступ до застосунків у кластері

Налаштування балансування навантаження, перенаправлення портів, фаєрвола або конфігурації DNS для доступу до застосунків у кластері.

10.1 - Розгортання й доступ до Kubernetes Dashboard

Розгорніть вебінтерфейс (Kubernetes Dashboard) і отримайте до нього доступ.

Kubernetes Dashboard є застарілим та не підтримується.

Проєкт Kubernetes Dashboard заархівовано, і він більше не підтримується активно. Для нових встановлень розгляньте Headlamp.

Примітка:

Про розгортання в кластері, подібне до Kubernetes Dashboard, дивіться настанови зі встановлення Headlamp у кластері.

Dashboard — це вебінтерфейс користувача Kubernetes. За допомогою Dashboard можна розгортати контейнеризовані застосунки в кластері Kubernetes, усувати несправності контейнеризованих застосунків і керувати ресурсами кластера. Також Dashboard дає змогу переглядати застосунки, що працюють у кластері, а ще створювати або змінювати окремі ресурси Kubernetes (як-от Deployments, Jobs, DaemonSets тощо). Наприклад, можна масштабувати Deployment, запустити поетапне оновлення, перезапустити Pod або розгорнути нові застосунки за допомогою майстра розгортання.

Dashboard також надає інформацію про стан ресурсів Kubernetes у кластері та про помилки, що могли виникнути.

Kubernetes Dashboard UI

Розгортання інтерфейсу Dashboard

Примітка:

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

Стандартно інтерфейс Dashboard не розгорнуто. Щоб розгорнути його, виконайте таку команду:

# Додайте репозиторій kubernetes-dashboard
helm repo add kubernetes-dashboard https://kubernetes.github.io/dashboard/
# Розгорніть Helm Release з назвою "kubernetes-dashboard" за допомогою чарта kubernetes-dashboard
helm upgrade --install kubernetes-dashboard kubernetes-dashboard/kubernetes-dashboard --create-namespace --namespace kubernetes-dashboard

Доступ до інтерфейсу Dashboard

Щоб захистити дані кластера, Dashboard стандартно розгортається з мінімальною конфігурацією RBAC. Наразі Dashboard підтримує лише вхід за допомогою Bearer Token. Щоб створити токен для цієї демонстрації, скористайтеся нашим посібником зі створення зразка користувача.

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

Зразок користувача, створений у цьому навчальному матеріалі, матиме адміністративні привілеї й призначений лише для навчання.

Проксі з командного рядка

Увімкнути доступ до Dashboard можна за допомогою інструмента командного рядка kubectl, виконавши таку команду:

kubectl -n kubernetes-dashboard port-forward svc/kubernetes-dashboard-kong-proxy 8443:443

kubectl зробить Dashboard доступним за адресою https://localhost:8443.

Доступ до інтерфейсу можливий лише з машини, на якій виконано команду. Більше параметрів дивіться в kubectl port-forward --help.

Примітка:

Метод автентифікації kubeconfig не підтримує зовнішніх постачальників ідентифікації або автентифікацію на основі сертифікатів X.509.

Вітальна сторінка

Коли ви відкриваєте Dashboard у порожньому кластері, показується вітальна сторінка. Вона містить посилання на цей документ, а також кнопку для розгортання вашого першого застосунку. Крім того, можна переглянути, які системні застосунки стандартно працюють у просторі імен kube-system вашого кластера, наприклад сам Dashboard.

Вітальна сторінка Kubernetes 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.

    Приклад:

    release=1.0
    tier=frontend
    environment=pod
    track=stable
    
  • Простір імен: 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ʼу.

Переглядач логів

Що далі

Докладніше дивіться на сторінці проєкту Kubernetes Dashboard.

10.2 - Доступ до кластерів

У цій темі розглянуто кілька способів взаємодії з кластерами.

Перший доступ за допомогою 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-сервер і автентифікується. Запустіть її так:

kubectl proxy --port=8080

Докладніше дивіться в описі kubectl proxy.

Після цього можна досліджувати API за допомогою curl, wget або браузера, замінивши localhost на [::1] для IPv6, ось так:

curl http://localhost:8080/api/

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

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

Без kubectl proxy

Використайте kubectl apply і kubectl describe secret..., щоб створити токен для стандартного ServiceAccount за допомогою grep/cut:

Спочатку створіть Secret, запитавши токен для стандартного ServiceAccount:

kubectl apply -f - <<EOF
apiVersion: v1
kind: Secret
metadata:
  name: default-token
  annotations:
    kubernetes.io/service-account.name: default
type: kubernetes.io/service-account-token
EOF

Далі зачекайте, поки контролер токенів заповнить Secret токеном:

while ! kubectl describe secret default-token | grep -E '^token' >/dev/null; do
  echo "waiting for token..." >&2
  sleep 1
done

Отримайте й використайте згенерований токен:

APISERVER=$(kubectl config view --minify | grep server | cut -f 2- -d ":" | tr -d " ")
TOKEN=$(kubectl describe secret default-token | grep -E '^token' | cut -f2 -d':' | tr -d " ")

curl $APISERVER/api --header "Authorization: Bearer $TOKEN" --insecure

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

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

За допомогою jsonpath:

APISERVER=$(kubectl config view --minify -o jsonpath='{.clusters[0].cluster.server}')
TOKEN=$(kubectl get secret default-token -o jsonpath='{.data.token}' | base64 --decode)

curl $APISERVER/api --header "Authorization: Bearer $TOKEN" --insecure

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

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

У наведених вище прикладах використано прапорець --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

Щоб використовувати клієнт Python, виконайте таку команду: pip install kubernetes. Інші варіанти встановлення дивіться на сторінці Python Client Library.

Клієнт Python може використовувати той самий файл kubeconfig, що й CLI kubectl, щоб знайти API-сервер і автентифікуватися на ньому. Дивіться цей приклад.

Інші мови

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

Доступ до API з Podʼа

Під час доступу до API з Podʼа пошук API-сервера й автентифікація на ньому дещо відрізняються.

Докладніше дивіться в розділі Доступ до API зсередини Podʼа.

Доступ до сервісів, що працюють у кластері

У попередньому розділі описано, як підʼєднатися до API-сервера Kubernetes. Про підʼєднання до інших сервісів, що працюють у кластері Kubernetes, дивіться Доступ до сервісів кластера.

Запит перенаправлення

Можливості перенаправлення визнано застарілими й вилучено. Натомість використовуйте проксі (дивіться нижче).

Так багато проксі

Під час роботи з Kubernetes можна зустріти кілька різних проксі:

  1. kubectl proxy:

    • працює на компʼютері користувача або в Podʼі
    • проксіює з адреси localhost до API-сервера Kubernetes
    • від клієнта до проксі використовується HTTP
    • від проксі до API-сервера використовується HTTPS
    • знаходить API-сервер
    • додає заголовки автентифікації
  2. apiserver proxy:

    • є бастіоном, вбудованим в API-сервер
    • зʼєднує користувача поза кластером з IP-адресами кластера, які інакше можуть бути недосяжними
    • працює в процесах API-сервера
    • від клієнта до проксі використовується HTTPS (або http, якщо так налаштовано API-сервер)
    • від проксі до цілі може використовуватися HTTP або HTTPS на вибір проксі, на основі наявної інформації
    • може використовуватися для доступу до Node, Pod або Service
    • забезпечує балансування навантаження, коли використовується для доступу до Service
  3. kube proxy:

    • працює на кожному вузлі
    • проксіює UDP і TCP
    • не розуміє HTTP
    • забезпечує балансування навантаження
    • використовується лише для доступу до сервісів
  4. Проксі або балансувальник навантаження перед API-сервером (або кількома):

    • наявність і реалізація різняться від кластера до кластера (наприклад, nginx)
    • розташовується між усіма клієнтами та одним чи кількома API-серверами
    • працює як балансувальник навантаження, якщо є кілька API-серверів.
  5. Хмарні балансувальники навантаження для зовнішніх сервісів:

    • надаються деякими хмарними провайдерами (наприклад, 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 з таким вмістом:

apiVersion: v1
kind: Config
preferences: {}

clusters:
- cluster:
  name: development
- cluster:
  name: test

users:
- name: developer
- name: experimenter

contexts:
- context:
  name: dev-frontend
- context:
  name: dev-storage
- context:
  name: exp-test

Файл конфігурації описує кластери, користувачів і контексти. Ваш файл 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.
kubectl config --kubeconfig=config-demo set-credentials developer --client-certificate=fake-cert-file --client-key=fake-key-file
kubectl config --kubeconfig=config-demo set-credentials experimenter --username=exp --password=some-password

Примітка:

  • Щоб видалити користувача, можна виконати команду kubectl --kubeconfig=config-demo config unset users.<name>;
  • Щоб видалити кластер, можна виконати команду kubectl --kubeconfig=config-demo config unset clusters.<name>;
  • Щоб видалити контекст, можна виконати команду kubectl --kubeconfig=config-demo config unset contexts.<name>.

Додайте відомості про контексти до файлу конфігурації:

kubectl config --kubeconfig=config-demo set-context dev-frontend --cluster=development --namespace=frontend --user=developer
kubectl config --kubeconfig=config-demo set-context dev-storage --cluster=development --namespace=storage --user=developer
kubectl config --kubeconfig=config-demo set-context exp-test --cluster=test --namespace=default --user=experimenter

Відкрийте файл config-demo, щоб побачити додані відомості. Замість відкриття файлу config-demo можна використати команду config view.

kubectl config --kubeconfig=config-demo view

Вивід показує два кластери, двох користувачів і три контексти:

apiVersion: v1
clusters:
- cluster:
    certificate-authority: fake-ca-file
    server: https://1.2.3.4
  name: development
- cluster:
    insecure-skip-tls-verify: true
    server: https://5.6.7.8
  name: test
contexts:
- context:
    cluster: development
    namespace: frontend
    user: developer
  name: dev-frontend
- context:
    cluster: development
    namespace: storage
    user: developer
  name: dev-storage
- context:
    cluster: test
    namespace: default
    user: experimenter
  name: exp-test
current-context: ""
kind: Config
preferences: {}
users:
- name: developer
  user:
    client-certificate: fake-cert-file
    client-key: fake-key-file
- name: experimenter
  user:
    # Примітка до документації (цей коментар НЕ є частиною виводу команди).
    # Зберігання паролів у конфігурації клієнта Kubernetes ризиковано.
    # Кращою альтернативою є використання втулка облікових даних
    # і окреме зберігання цих даних.
    # Дивіться https://kubernetes.io/docs/reference/access-authn-authz/authentication/#client-go-credential-plugins
    password: some-password
    username: 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 config --kubeconfig=config-demo use-context dev-frontend

Тепер кожна введена команда kubectl застосовуватиметься до кластера й простору імен, зазначених у контексті dev-frontend. Команда використовуватиме облікові дані користувача, зазначеного в контексті dev-frontend.

Щоб побачити лише інформацію про конфігурацію, повʼязану з поточним контекстом, використовуйте прапорець --minify.

kubectl config --kubeconfig=config-demo view --minify

Вивід показує інформацію про конфігурацію, повʼязану з контекстом dev-frontend:

apiVersion: v1
clusters:
- cluster:
    certificate-authority: fake-ca-file
    server: https://1.2.3.4
  name: development
contexts:
- context:
    cluster: development
    namespace: frontend
    user: developer
  name: dev-frontend
current-context: dev-frontend
kind: Config
preferences: {}
users:
- name: developer
  user:
    client-certificate: fake-cert-file
    client-key: fake-key-file

Тепер припустимо, що ви хочете попрацювати деякий час у тестовому кластері.

Змініть поточний контекст на exp-test:

kubectl config --kubeconfig=config-demo use-context exp-test

Тепер будь-яка введена команда kubectl застосовуватиметься до стандартного простору імен кластера test. Команда використовуватиме облікові дані користувача, зазначеного в контексті exp-test.

Перегляньте конфігурацію, повʼязану з новим поточним контекстом exp-test.

kubectl config --kubeconfig=config-demo view --minify

Нарешті, припустимо, що ви хочете попрацювати деякий час у просторі імен storage кластера development.

Змініть поточний контекст на dev-storage:

kubectl config --kubeconfig=config-demo use-context dev-storage

Перегляньте конфігурацію, повʼязану з новим поточним контекстом dev-storage.

kubectl config --kubeconfig=config-demo view --minify

Створення другого файлу конфігурації

У теці config-exercise створіть файл з назвою config-demo-2 з таким вмістом:

apiVersion: v1
kind: Config
preferences: {}

contexts:
- context:
    cluster: development
    namespace: ramp
    user: developer
  name: dev-ramp-up

Наведений вище файл конфігурації визначає новий контекст з назвою dev-ramp-up.

Встановіть змінну середовища KUBECONFIG

Перевірте, чи є у вас змінна середовища з назвою KUBECONFIG. Якщо так, збережіть її поточне значення, щоб пізніше відновити його. Наприклад:

Linux

export KUBECONFIG_SAVED="$KUBECONFIG"

Windows PowerShell

$Env:KUBECONFIG_SAVED=$ENV:KUBECONFIG

Змінна середовища KUBECONFIG — це список шляхів до файлів конфігурації. У Linux і Mac елементи списку розділяються двокрапкою, а у Windows — крапкою з комою. Якщо у вас є змінна середовища KUBECONFIG, ознайомтеся з файлами конфігурації зі списку.

Тимчасово додайте два шляхи до змінної середовища KUBECONFIG. Наприклад:

Linux

export KUBECONFIG="${KUBECONFIG}:config-demo:config-demo-2"

Windows PowerShell

$Env:KUBECONFIG=("config-demo;config-demo-2")

У теці config-exercise виконайте цю команду:

kubectl config view

Вивід показує обʼєднану інформацію з усіх файлів, зазначених у змінній середовища KUBECONFIG. Зокрема, зверніть увагу, що обʼєднана інформація містить контекст dev-ramp-up з файлу config-demo-2 і три контексти з файлу config-demo:

contexts:
- context:
    cluster: development
    namespace: frontend
    user: developer
  name: dev-frontend
- context:
    cluster: development
    namespace: ramp
    user: developer
  name: dev-ramp-up
- context:
    cluster: development
    namespace: storage
    user: developer
  name: dev-storage
- context:
    cluster: test
    namespace: default
    user: experimenter
  name: exp-test

Докладніше про обʼєднання файлів kubeconfig дивіться в розділі Організація доступу до кластера за допомогою файлів kubeconfig.

Ознайомтеся з текою $HOME/.kube

Якщо у вас уже є кластер і ви можете взаємодіяти з ним за допомогою kubectl, то, ймовірно, у теці $HOME/.kube є файл з назвою config.

Перейдіть до теки $HOME/.kube і перегляньте, які файли там є. Зазвичай там є файл з назвою config. У цій теці можуть бути й інші файли конфігурації. Коротко ознайомтеся з їхнім вмістом.

Додайте $HOME/.kube/config до змінної середовища KUBECONFIG

Якщо у вас є файл $HOME/.kube/config і він ще не зазначений у змінній середовища KUBECONFIG, додайте його туди зараз. Наприклад:

Linux

export KUBECONFIG="${KUBECONFIG}:${HOME}/.kube/config"

Windows PowerShell

$Env:KUBECONFIG="$Env:KUBECONFIG;$HOME\.kube\config"

Перегляньте інформацію про конфігурацію, обʼєднану з усіх файлів, які тепер зазначені у змінній середовища KUBECONFIG. У теці config-exercise введіть:

kubectl config view

Очищення

Поверніть змінній середовища KUBECONFIG її початкове значення. Наприклад:

Linux

export KUBECONFIG="$KUBECONFIG_SAVED"

Windows PowerShell

$Env:KUBECONFIG=$ENV:KUBECONFIG_SAVED

Перевірте субʼєкт, представлений kubeconfig

Не завжди очевидно, які атрибути (імʼя користувача, групи) ви отримаєте після автентифікації в кластері. Це може бути ще складніше, якщо ви керуєте більше ніж одним кластером одночасно.

Існує підкоманда kubectl для перевірки атрибутів субʼєкта, таких як імʼя користувача, для вибраного контексту клієнта Kubernetes: kubectl auth whoami.

Докладніше про це читайте в розділі API-доступ до інформації автентифікації клієнта.

Що далі

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

На цій сторінці показано, як за допомогою kubectl port-forward підʼєднатися до сервера MongoDB, що працює в кластері Kubernetes. Таке підʼєднання може бути корисним для налагодження бази даних.

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

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

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

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

  • Встановіть MongoDB Shell.

Створення Deployment і Service для MongoDB

  1. Створіть Deployment, що запускає MongoDB:

    kubectl apply -f https://k8s.io/examples/application/mongodb/mongo-deployment.yaml
    

    Вивід успішної команди підтверджує, що Deployment створено:

    deployment.apps/mongo created
    

    Перегляньте статус Podʼа, щоб переконатися, що він готовий:

    kubectl get pods
    

    Вивід показує створений Pod:

    NAME                     READY   STATUS    RESTARTS   AGE
    mongo-75f59d57f4-4nd6q   1/1     Running   0          2m4s
    

    Перегляньте статус Deployment:

    kubectl get deployment
    

    Вивід показує, що Deployment створено:

    NAME    READY   UP-TO-DATE   AVAILABLE   AGE
    mongo   1/1     1            1           2m21s
    

    Deployment автоматично керує ReplicaSet. Перегляньте статус ReplicaSet за допомогою:

    kubectl get replicaset
    

    Вивід показує, що ReplicaSet створено:

    NAME               DESIRED   CURRENT   READY   AGE
    mongo-75f59d57f4   1         1         1       3m12s
    
  2. Створіть Service, щоб відкрити доступ до MongoDB у мережі:

    kubectl apply -f https://k8s.io/examples/application/mongodb/mongo-service.yaml
    

    Вивід успішної команди підтверджує, що 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
    
  3. Переконайтеся, що сервер 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ʼа

  1. kubectl port-forward дозволяє використовувати назву ресурсу, наприклад назву Podʼа, щоб вибрати відповідний Pod для перенаправлення порту.

    # Замініть mongo-75f59d57f4-4nd6q на назву Podʼа
    kubectl port-forward mongo-75f59d57f4-4nd6q 28015:27017
    

    що те саме, що й

    kubectl port-forward pods/mongo-75f59d57f4-4nd6q 28015:27017
    

    або

    kubectl port-forward deployment/mongo 28015:27017
    

    або

    kubectl port-forward replicaset/mongo-75f59d57f4 28015:27017
    

    або

    kubectl port-forward service/mongo 28015:27017
    

    Будь-яка з наведених вище команд працює. Вивід подібний до такого:

    Forwarding from 127.0.0.1:28015 -> 27017
    Forwarding from [::1]:28015 -> 27017
    

    Примітка:

    kubectl port-forward не завершується сам. Щоб продовжити вправи, потрібно відкрити інший термінал.
  2. Запустіть інтерфейс командного рядка MongoDB:

    mongosh --port 28015
    
  3. У командному рядку 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.

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

Що далі

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

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

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

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

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

Цілі

  • Запустити два екземпляри застосунку Hello World.
  • Створити обʼєкт Service, який відкриває порт вузла.
  • Використовувати обʼєкт Service для доступу до запущеного застосунку.

Створення Service для застосунку, що працює у двох Podʼах

Ось файл конфігурації Deployment застосунку:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: hello-world
spec:
  selector:
    matchLabels:
      run: load-balancer-example
  replicas: 2
  template:
    metadata:
      labels:
        run: load-balancer-example
    spec:
      containers:
        - name: hello-world
          image: us-docker.pkg.dev/google-samples/containers/gke/hello-app:2.0
          ports:
            - containerPort: 8080
              protocol: TCP
  1. Запустіть застосунок Hello World у кластері: створіть Deployment застосунку за допомогою наведеного вище файлу:

    kubectl apply -f https://k8s.io/examples/service/access/hello-application.yaml
    

    Попередня команда створює Deployment і повʼязаний ReplicaSet. ReplicaSet має два Podʼи, кожен з яких запускає застосунок Hello World.

  2. Перегляньте інформацію про Deployment:

    kubectl get deployments hello-world
    kubectl describe deployments hello-world
    
  3. Перегляньте інформацію про ваші обʼєкти ReplicaSet:

    kubectl get replicasets
    kubectl describe replicasets
    
  4. Створіть обʼєкт Service, який відкриває доступ до Deployment:

    kubectl expose deployment hello-world --type=NodePort --name=example-service
    
  5. Перегляньте інформацію про Service:

    kubectl describe services example-service
    

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

    Name:                   example-service
    Namespace:              default
    Labels:                 run=load-balancer-example
    Annotations:            <none>
    Selector:               run=load-balancer-example
    Type:                   NodePort
    IP:                     10.32.0.16
    Port:                   <unset> 8080/TCP
    TargetPort:             8080/TCP
    NodePort:               <unset> 31496/TCP
    Endpoints:              10.200.1.4:8080,10.200.2.5:8080
    Session Affinity:       None
    Events:                 <none>
    

    Занотуйте значення NodePort для Service. Наприклад, у попередньому виводі значення NodePort становить 31496.

  6. Виведіть 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
    
  7. Отримайте публічну IP-адресу одного з вузлів, на якому працює Pod Hello World. Спосіб отримання цієї адреси залежить від того, як налаштовано кластер. Наприклад, якщо ви використовуєте Minikube, адресу вузла можна побачити, виконавши kubectl cluster-info. Якщо ви використовуєте екземпляри Google Compute Engine, переглянути публічні адреси вузлів можна командою gcloud compute instances list.

  8. На вибраному вузлі створіть правило фаєрвола, яке дозволяє TCP-трафік на порт вузла. Наприклад, якщо значення NodePort вашого Service — 31568, створіть правило фаєрвола, яке дозволяє TCP-трафік на порт 31568. Різні хмарні провайдери пропонують різні способи налаштування правил фаєрвола.

  9. Використовуйте адресу вузла та порт вузла для доступу до застосунку Hello World:

    curl http://<public-node-ip>:<node-port>
    

    де <public-node-ip> — публічна IP-адреса вашого вузла, а <node-port> — значення NodePort вашого сервісу. Відповідь на успішний запит — вітальне повідомлення:

    Hello, world!
    Version: 2.0.0
    Hostname: hello-world-cdd4458f4-m47c8
    

Використання файлу конфігурації Service

Замість kubectl expose можна використати файл конфігурації Service, щоб створити Service.

Очищення

Щоб видалити Service, введіть цю команду:

kubectl delete services example-service

Щоб видалити Deployment, ReplicaSet і Podʼи, на яких працює застосунок Hello World, введіть цю команду:

kubectl delete deployment hello-world

Що далі

Скористайтеся навчальним матеріалом Підключення застосунків за допомогою Services.

10.6 - Зʼєднання фронтенду з бекендом за допомогою Services

Це завдання показує, як створити мікросервіси фронтенду й бекенду. Мікросервіс бекенду — це сервіс привітання. Фронтенд відкриває доступ до бекенду за допомогою nginx та обʼєкта Service Kubernetes.

Цілі

  • Створити й запустити приклад мікросервісу бекенду hello за допомогою обʼєкта Deployment.
  • Використовувати обʼєкт Service для надсилання трафіку до кількох реплік мікросервісу бекенду.
  • Створити й запустити мікросервіс фронтенду nginx, також за допомогою обʼєкта Deployment.
  • Налаштувати мікросервіс фронтенду на надсилання трафіку до мікросервісу бекенду.
  • Використати обʼєкт Service type=LoadBalancer, щоб відкрити доступ до мікросервісу фронтенду ззовні кластера.

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

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

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

Це завдання використовує Services із зовнішніми балансувальниками навантаження, які потребують підтримуваного середовища. Якщо ваше середовище їх не підтримує, натомість можна використати Service типу NodePort.

Створення бекенду за допомогою Deployment

Бекенд — це простий мікросервіс привітання. Ось файл конфігурації Deployment бекенду:

---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: backend
spec:
  selector:
    matchLabels:
      app: hello
      tier: backend
      track: stable
  replicas: 3
  template:
    metadata:
      labels:
        app: hello
        tier: backend
        track: stable
    spec:
      containers:
        - name: hello
          image: "gcr.io/google-samples/hello-go-gke:1.0"
          ports:
            - name: http
              containerPort: 80
...

Створіть Deployment для бекенду:

kubectl apply -f https://k8s.io/examples/service/access/backend-deployment.yaml

Перегляньте інформацію про Deployment бекенду:

kubectl describe deployment backend

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

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ʼи, до яких спрямовувати трафік.

Спочатку перегляньте файл конфігурації Service:

---
apiVersion: v1
kind: Service
metadata:
  name: hello
spec:
  selector:
    app: hello
    tier: backend
  ports:
  - protocol: TCP
    port: 80
    targetPort: http
...

У файлі конфігурації видно, що Service з назвою hello спрямовує трафік до Podʼів із мітками app: hello і tier: backend.

Створіть Service для бекенду:

kubectl apply -f https://k8s.io/examples/service/access/backend-service.yaml

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

---
apiVersion: v1
kind: Service
metadata:
  name: frontend
spec:
  selector:
    app: hello
    tier: frontend
  ports:
  - protocol: "TCP"
    port: 80
    targetPort: 80
  type: LoadBalancer
...
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: frontend
spec:
  selector:
    matchLabels:
      app: hello
      tier: frontend
      track: stable
  replicas: 1
  template:
    metadata:
      labels:
        app: hello
        tier: frontend
        track: stable
    spec:
      containers:
        - name: nginx
          image: "gcr.io/google-samples/hello-frontend:1.0"
          lifecycle:
            preStop:
              exec:
                command: ["/usr/sbin/nginx","-s","quit"]
...

Створіть Deployment і Service фронтенду:

kubectl apply -f https://k8s.io/examples/service/access/frontend-deployment.yaml
kubectl apply -f https://k8s.io/examples/service/access/frontend-service.yaml

Вивід підтверджує, що обидва ресурси створено:

deployment.apps/frontend created
service/frontend created

Примітка:

Конфігурацію nginx вбудовано в образ контейнера. Кращий спосіб — використати ConfigMap, щоб легше змінювати конфігурацію.

Взаємодія із Service фронтенду

Після створення Service типу LoadBalancer цією командою можна знайти зовнішню IP-адресу:

kubectl get service frontend --watch

Це показує конфігурацію Service frontend і відстежує зміни. Спочатку зовнішня IP-адреса вказана як <pending>:

NAME       TYPE           CLUSTER-IP      EXTERNAL-IP   PORT(S)  AGE
frontend   LoadBalancer   10.51.252.116   <pending>     80/TCP   10s

Щойно зовнішню IP-адресу буде надано, конфігурація оновиться й міститиме нову IP-адресу в колонці EXTERNAL-IP:

NAME       TYPE           CLUSTER-IP      EXTERNAL-IP        PORT(S)  AGE
frontend   LoadBalancer   10.51.252.116   XXX.XXX.XXX.XXX    80/TCP   1m

Тепер цю IP-адресу можна використовувати для взаємодії із сервісом frontend ззовні кластера.

Надсилання трафіку через фронтенд

Фронтенд і бекенд тепер зʼєднані. Ви можете звернутися до точки доступу командою curl за зовнішньою IP-адресою Service фронтенду.

curl http://${EXTERNAL_IP} # замініть це на EXTERNAL-IP, який ви бачили раніше

Вивід показує повідомлення, згенероване бекендом:

{"message":"Hello"}

Очищення

Щоб видалити Services, введіть цю команду:

kubectl delete services frontend backend

Щоб видалити Deployments, ReplicaSets і Podʼи, у яких працюють застосунки бекенду й фронтенду, введіть цю команду:

kubectl delete deployment frontend backend

Що далі

10.7 - Створення зовнішнього балансувальника навантаження

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

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

Ви також можете використовувати Ingress замість Service. Докладніше дивіться в документації про Ingress.

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

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

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

Створення Service

Створення Service з маніфесту

Щоб створити зовнішній балансувальник навантаження, додайте такий рядок до маніфесту Service:

    type: LoadBalancer

Ваш маніфест може виглядати так:

apiVersion: v1
kind: Service
metadata:
  name: example-service
spec:
  selector:
    app: example
  ports:
    - port: 8765
      targetPort: 9376
  type: LoadBalancer

Створення Service за допомогою kubectl

Також можна створити сервіс командою kubectl expose із прапорцем --type=LoadBalancer:

kubectl expose deployment example --port=8765 --target-port=9376 \
        --name=example-service --type=LoadBalancer

Ця команда створює новий Service із тими самими селекторами, що й у вказаного ресурсу (у наведеному прикладі — Deployment з назвою example).

Докладніше, зокрема про необовʼязкові прапорці, дивіться в довіднику kubectl expose.

Пошук вашої IP-адреси

Щоб знайти IP-адресу, створену для вашого сервісу, отримайте інформацію про сервіс через kubectl:

kubectl describe services example-service

що має дати вивід, подібний до такого:

Name:                     example-service
Namespace:                default
Labels:                   app=example
Annotations:              <none>
Selector:                 app=example
Type:                     LoadBalancer
IP Families:              <none>
IP:                       10.3.22.96
IPs:                      10.3.22.96
LoadBalancer Ingress:     192.0.2.89
Port:                     <unset>  8765/TCP
TargetPort:               9376/TCP
NodePort:                 <unset>  30593/TCP
Endpoints:                172.17.0.3:9376
Session Affinity:         None
External Traffic Policy:  Cluster
Events:                   <none>

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 вмикає цю можливість. Наприклад:

apiVersion: v1
kind: Service
metadata:
  name: example-service
spec:
  selector:
    app: example
  ports:
    - port: 8765
      targetPort: 9376
  externalTrafficPolicy: Local
  type: LoadBalancer

Застереження й обмеження під час збереження вихідних 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 version.

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

Перелік усіх образів контейнерів у всіх просторах імен

  • Отримайте всі Podʼи у всіх просторах імен за допомогою kubectl get pods --all-namespaces.
  • Відформатуйте вивід, щоб він містив лише перелік назв образів контейнерів, за допомогою -o jsonpath={.items[*].spec['initContainers', 'containers'][*].image}. Це рекурсивно витягне поле image з отриманого json.
  • Відформатуйте вивід за допомогою стандартних інструментів: tr, sort, uniq.
    • Використовуйте tr для заміни пробілів на нові рядки.
    • Використовуйте sort для сортування результатів.
    • Використовуйте uniq для підрахунку образів.
kubectl get pods --all-namespaces -o jsonpath="{.items[*].spec['initContainers', 'containers'][*].image}" |\
tr -s '[[:space:]]' '\n' |\
sort |\
uniq -c

Jsonpath інтерпретується так:

  • .items[*]: для кожного отриманого значення.
  • .spec: отримати spec.
  • ['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 або використовувати одну з цих пісочниць:

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

Створення Podʼа, що запускає два контейнери

У цій вправі ви створите Pod, який запускає два контейнери. Ці контейнери спільно використовують том, через який вони можуть взаємодіяти. Ось файл конфігурації Podʼа:

apiVersion: v1
kind: Pod
metadata:
  name: two-containers
spec:

  restartPolicy: Never

  volumes:
  - name: shared-data
    emptyDir: {}

  containers:

  - name: nginx-container
    image: nginx
    volumeMounts:
    - name: shared-data
      mountPath: /usr/share/nginx/html

  - name: debian-container
    image: debian
    volumeMounts:
    - name: shared-data
      mountPath: /pod-data
    command: ["/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.

Створіть Pod і два контейнери:

kubectl apply -f https://k8s.io/examples/pods/two-container-pod.yaml

Перегляньте інформацію про Pod та контейнери:

kubectl get pod two-containers --output=yaml

Ось частина виводу:

apiVersion: v1
kind: Pod
metadata:
  ...
  name: two-containers
  namespace: default
  ...
spec:
  ...
  containerStatuses:

  - containerID: docker://c1d8abd1 ...
    image: debian
    ...
    lastState:
      terminated:
        ...
    name: debian-container
    ...

  - containerID: docker://96c1ff2c5bb ...
    image: nginx
    ...
    name: nginx-container
    ...
    state:
      running:
    ...

Ви бачите, що контейнер debian завершив роботу, а контейнер nginx досі працює.

Отримайте доступ до оболонки контейнера nginx:

kubectl exec -it two-containers -c nginx-container -- /bin/bash

В оболонці перевірте, що nginx працює:

root@two-containers:/# apt-get update
root@two-containers:/# apt-get install curl procps
root@two-containers:/# ps aux

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

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 видалено й створено заново, усі дані, збережені в спільному томі, втрачаються.

Що далі

10.10 - Налаштування DNS для кластера

Kubernetes пропонує надбудову DNS для кластера, яка стандартно ввімкнена в більшості підтримуваних середовищ. У Kubernetes версії 1.11 і новіших рекомендовано CoreDNS, який стандартно встановлюється з kubeadm.

Докладніше про налаштування CoreDNS для кластера Kubernetes дивіться Налаштування сервісу DNS.

10.11 - Доступ до сервісів, що працюють у кластерах

На цій сторінці показано, як підʼєднатися до сервісів, що працюють у кластері Kubernetes.

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

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

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

Доступ до сервісів, що працюють у кластері

У Kubernetes вузли, Podʼи і сервіси мають власні IP-адреси. У багатьох випадках IP-адреси вузлів, Podʼів і деяких сервісів у кластері не маршрутизуються, тому вони недосяжні з машини поза кластером, наприклад із вашого настільного компʼютера.

Способи підʼєднання

Є кілька варіантів підʼєднання до вузлів, Podʼів і сервісів ззовні кластера:

  • Доступ до сервісів через публічні IP-адреси.
    • Використайте Service типу NodePort або LoadBalancer, щоб зробити сервіс доступним ззовні кластера. Дивіться документацію про Services і kubectl expose.
    • Залежно від середовища кластера сервіс може стати доступним лише у вашій корпоративній мережі або в інтернеті. Подумайте, чи є сервіс, до якого відкривається доступ, безпечним. Чи виконує він власну автентифікацію?
    • Розміщуйте Podʼи за сервісами. Щоб отримати доступ до одного конкретного Podʼа з набору реплік, наприклад для налагодження, додайте до Podʼа унікальну мітку й створіть новий Service, який вибирає цю мітку.
    • У більшості випадків розробнику застосунків не потрібно звертатися до вузлів безпосередньо за їхніми nodeIP.
  • Доступ до сервісів, вузлів або Podʼів за допомогою дієслова Proxy.
    • Виконує автентифікацію й авторизацію на API-сервері перед доступом до віддаленого сервісу. Використовуйте це, якщо сервіси недостатньо безпечні для відкриття в інтернет, для доступу до портів на IP-адресі вузла або для налагодження.
    • Проксі можуть викликати проблеми для деяких вебзастосунків.
    • Працює лише для HTTP/HTTPS.
    • Описано тут.
  • Доступ з вузла або Podʼа в кластері.
    • Запустіть 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/.

Примітка:

Про те, як передавати облікові дані або використовувати kubectl proxy, дивіться Доступ до кластерів за допомогою API Kubernetes.

Ручне створення URL проксі API-сервера

Як згадано вище, 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, використайте:

    http://192.0.2.1/api/v1/namespaces/kube-system/services/elasticsearch-logging/proxy/_search?q=user:kimchy
    
  • Щоб отримати інформацію про справність кластера Elasticsearch _cluster/health?pretty=true, використайте:

    https://192.0.2.1/api/v1/namespaces/kube-system/services/elasticsearch-logging/proxy/_cluster/health?pretty=true
    

    Інформація про справність подібна до такої:

    {
      "cluster_name" : "kubernetes_logging",
      "status" : "yellow",
      "timed_out" : false,
      "number_of_nodes" : 1,
      "number_of_data_nodes" : 1,
      "active_primary_shards" : 5,
      "active_shards" : 5,
      "relocating_shards" : 0,
      "initializing_shards" : 0,
      "unassigned_shards" : 5
    }
    
  • Щоб отримати інформацію про справність сервісу Elasticsearch через https _cluster/health?pretty=true, використайте:

    https://192.0.2.1/api/v1/namespaces/kube-system/services/https:elasticsearch-logging:/proxy/_cluster/health?pretty=true
    

Використання браузерів для доступу до сервісів, що працюють у кластері

Ви можете ввести URL проксі API-сервера в адресний рядок браузера. Однак:

  • Браузери зазвичай не можуть передавати токени, тому може знадобитися базова автентифікація (пароль). API-сервер можна налаштувати на прийняття базової автентифікації, але ваш кластер може бути не налаштований на це.
  • Деякі вебзастосунки можуть не працювати, особливо ті, що мають клієнтський javascript, який створює URL, не враховуючи префікс шляху проксі.

11 - Розширення Kubernetes

Розуміння розширених способів адаптації кластера Kubernetes до потреб вашого робочого середовища.

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

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

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

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

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

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

Примітка:

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

Увага:

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

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

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

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

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

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

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

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

aggregation auth flows

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Примітка:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

--enable-aggregator-routing=true

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

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


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

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

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

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

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

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

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

Що далі

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

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

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

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

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

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

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

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

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

Що далі

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Примітка:

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

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

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

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

Увага:

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

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

kubectl create -f my-scheduler.yaml

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

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

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

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

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

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

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

Примітка:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    kubectl create -f pod3.yaml
    

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

    kubectl get pods
    

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

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

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

kubectl get events

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

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

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

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

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

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

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

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

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

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

kubectl proxy --port=8080

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

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

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

curl http://localhost:8080/api/

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

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

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

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

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

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

Що далі

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

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. Використання змінної середовища:

export HTTPS_PROXY=socks5://localhost:1080

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

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

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

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

Примітка:

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

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

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

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

Очищення

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

12 - TLS

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

Створіть приватний ключ

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

# Створіть приватний ключ
openssl genrsa -out myuser.key 3072

Створіть запит на підписання сертифіката X.509

Примітка:

Це не те саме, що 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/v1
kind: CertificateSigningRequest
metadata:
  name: myuser # example
spec:
  # This is an encoded CSR. Change this to the base64-encoded contents of myuser.csr
  request: LS0tLS1CRUdJTiBDRVJUSUZJQ0FURSBSRVFVRVNULS0tLS0KTUlJQ1ZqQ0NBVDRDQVFBd0VURVBNQTBHQTFVRUF3d0dZVzVuWld4aE1JSUJJakFOQmdrcWhraUc5dzBCQVFFRgpBQU9DQVE4QU1JSUJDZ0tDQVFFQTByczhJTHRHdTYxakx2dHhWTTJSVlRWMDNHWlJTWWw0dWluVWo4RElaWjBOCnR2MUZtRVFSd3VoaUZsOFEzcWl0Qm0wMUFSMkNJVXBGd2ZzSjZ4MXF3ckJzVkhZbGlBNVhwRVpZM3ExcGswSDQKM3Z3aGJlK1o2MVNrVHF5SVBYUUwrTWM5T1Nsbm0xb0R2N0NtSkZNMUlMRVI3QTVGZnZKOEdFRjJ6dHBoaUlFMwpub1dtdHNZb3JuT2wzc2lHQ2ZGZzR4Zmd4eW8ybmlneFNVekl1bXNnVm9PM2ttT0x1RVF6cXpkakJ3TFJXbWlECklmMXBMWnoyalVnald4UkhCM1gyWnVVV1d1T09PZnpXM01LaE8ybHEvZi9DdS8wYk83c0x0MCt3U2ZMSU91TFcKcW90blZtRmxMMytqTy82WDNDKzBERHk5aUtwbXJjVDBnWGZLemE1dHJRSURBUUFCb0FBd0RRWUpLb1pJaHZjTgpBUUVMQlFBRGdnRUJBR05WdmVIOGR4ZzNvK21VeVRkbmFjVmQ1N24zSkExdnZEU1JWREkyQTZ1eXN3ZFp1L1BVCkkwZXpZWFV0RVNnSk1IRmQycVVNMjNuNVJsSXJ3R0xuUXFISUh5VStWWHhsdnZsRnpNOVpEWllSTmU3QlJvYXgKQVlEdUI5STZXT3FYbkFvczFqRmxNUG5NbFpqdU5kSGxpT1BjTU1oNndLaTZzZFhpVStHYTJ2RUVLY01jSVUyRgpvU2djUWdMYTk0aEpacGk3ZnNMdm1OQUxoT045UHdNMGM1dVJVejV4T0dGMUtCbWRSeEgvbUNOS2JKYjFRQm1HCkkwYitEUEdaTktXTU0xMzhIQXdoV0tkNjVoVHdYOWl4V3ZHMkh4TG1WQzg0L1BHT0tWQW9FNkpsYWFHdTlQVmkKdjlOSjVaZlZrcXdCd0hKbzZXdk9xVlA3SVFjZmg3d0drWm89Ci0tLS0tRU5EIENFUlRJRklDQVRFIFJFUVVFU1QtLS0tLQo=
  signerName: kubernetes.io/kube-apiserver-client
  expirationSeconds: 86400 # one day
  usages:
  - 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.

Спочатку потрібно додати нові облікові дані:

kubectl config set-credentials myuser --client-key=myuser.key --client-certificate=myuser.crt --embed-certs=true

Потім потрібно додати контекст:

kubectl config set-context myuser --cluster=kubernetes --user=myuser

Перевірте:

kubectl --context myuser auth whoami

Ви маєте побачити вивід, який підтверджує, що ви — «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

Еквівалентний YAML:

apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  name: developer
rules:
- apiGroups: [""]
  resources: ["pods"]
  verbs: ["create", "get", "list", "update", "delete"]

Це приклад команди для створення RoleBinding для цього нового користувача:

kubectl create rolebinding developer-binding-myuser --role=developer --user=myuser

Еквівалентний YAML:

apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: developer-binding-myuser
subjects:
- kind: User
  name: myuser
  apiGroup: rbac.authorization.k8s.io
roleRef:
  kind: Role
  name: developer
  apiGroup: rbac.authorization.k8s.io

Що далі

12.2 - Керування сертифікатами TLS у кластері

Kubernetes надає API certificates.k8s.io, який дозволяє отримувати сертифікати TLS, підписані центром сертифікації (CA), який ви контролюєте. Ці CA й сертифікати ваші робочі навантаження можуть використовувати для встановлення довіри.

API certificates.k8s.io використовує протокол, подібний до чернетки ACME.

Примітка:

Сертифікати, створені за допомогою API certificates.k8s.io, підписуються окремим CA. Кластер можна налаштувати на використання для цього кореневого CA кластера, але ніколи не слід на це покладатися. Не вважайте, що ці сертифікати проходитимуть перевірку кореневим CA кластера.

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

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

Вам потрібен інструмент cfssl. Ви можете завантажити cfssl з https://github.com/cloudflare/cfssl/releases.

Деякі кроки на цій сторінці використовують інструмент 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), виконавши таку команду:

cat <<EOF | cfssl genkey - | cfssljson -bare server
{
  "hosts": [
    "my-svc.my-namespace.svc.cluster.local",
    "my-pod.my-namespace.pod.cluster.local",
    "192.0.2.24",
    "10.0.34.2"
  ],
  "CN": "my-pod.my-namespace.pod.cluster.local",
  "key": {
    "algo": "ecdsa",
    "size": 256
  }
}
EOF

Де 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ʼа. Ви маєте побачити вивід, подібний до такого:

2022/02/01 11:45:32 [INFO] generate received request
2022/02/01 11:45:32 [INFO] received CSR
2022/02/01 11:45:32 [INFO] generating key: ecdsa-256
2022/02/01 11:45:32 [INFO] encoded CSR

Ця команда генерує два файли: server.csr із запитом на сертифікат PKCS#10 у кодуванні PEM і server-key.pem із ключем у кодуванні PEM до сертифіката, який ще буде створено.

Створення обʼєкта CertificateSigningRequest для надсилання до API Kubernetes

Згенеруйте маніфест CSR (у форматі YAML) і надішліть його на API-сервер. Для цього виконайте таку команду:

cat <<EOF | kubectl apply -f -
apiVersion: certificates.k8s.io/v1
kind: CertificateSigningRequest
metadata:
  name: my-svc.my-namespace
spec:
  request: $(cat server.csr | base64 | tr -d '\n')
  signerName: example.com/serving
  usages:
  - digital signature
  - key encipherment
  - server auth
EOF

Зверніть увагу, що файл 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; наприклад:

kubectl certificate approve my-svc.my-namespace
certificatesigningrequest.certificates.k8s.io/my-svc.my-namespace approved

Тепер ви маєте побачити таке:

kubectl get csr
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).

Видача сертифіката

{
    "signing": {
        "default": {
            "usages": [
                "digital signature",
                "key encipherment",
                "server auth"
            ],
            "expiry": "876000h",
            "ca_constraint": {
                "is_ca": false
            }
        }
    }
}

Використайте конфігурацію підписування server-signing-config.json, а також файл ключа й сертифікат центру сертифікації, щоб підписати запит на сертифікат:

kubectl get csr my-svc.my-namespace -o jsonpath='{.spec.request}' | \
  base64 --decode | \
  cfssl sign -ca ca.pem -ca-key ca-key.pem -config server-signing-config.json - | \
  cfssljson -bare ca-signed-server

Ви маєте побачити вивід, подібний до такого:

2022/02/01 11:52:26 [INFO] signed certificate with serial number 576048928624926584381415936700914530534472870337

Це створює файл підписаного серверного сертифіката ca-signed-server.pem.

Завантаження підписаного сертифіката

Нарешті, додайте підписаний сертифікат до статусу обʼєкта API:

kubectl get csr my-svc.my-namespace -o json | \
  jq '.status.certificate = "'$(base64 ca-signed-server.pem | tr -d '\n')'"' | \
  kubectl replace --raw /apis/certificates.k8s.io/v1/certificatesigningrequests/my-svc.my-namespace/status -f -

Примітка:

Тут використовується інструмент командного рядка 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, виконавши таку команду:

kubectl get csr my-svc.my-namespace -o jsonpath='{.status.certificate}' \
    | base64 --decode > 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 і використовувати його як корінь довіри для перевірки серверного сертифіката:

kubectl create configmap example-serving-ca --from-file ca.crt=ca.pem
configmap/example-serving-ca created

Схвалення CertificateSigningRequests

Адміністратор Kubernetes (з відповідними дозволами) може вручну схвалювати або відхиляти CertificateSigningRequests за допомогою команд kubectl certificate approve і kubectl certificate deny. Однак якщо ви плануєте активно використовувати цей API, варто розглянути написання автоматизованого контролера сертифікатів.

Увага:

Можливість схвалювати CSR визначає, хто кому довіряє у вашому середовищі. Цю можливість не слід надавати широко або легковажно.

Перш ніж надати дозвіл approve, переконайтеся, що ви впевнено розумієте і вимоги до перевірки, покладені на схвалювача, і наслідки видачі конкретного сертифіката.

Незалежно від того, чи є схвалювач машиною, чи людиною, що використовує kubectl, як описано вище, роль схвалювача полягає в перевірці, що CSR відповідає двом вимогам:

  1. Субʼєкт CSR контролює приватний ключ, використаний для підписання CSR. Це усуває загрозу того, що третя сторона видаватиме себе за авторизованого субʼєкта. У наведеному вище прикладі цей крок полягав би в перевірці, що Pod контролює приватний ключ, використаний для генерації CSR.
  2. Субʼєкт 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-сервера.

  1. Розподіліть нові сертифікати CA й приватні ключі (наприклад, ca.crt, ca.key, front-proxy-ca.crt і front-proxy-ca.key) на всі вузли панелі управління в теку сертифікатів Kubernetes.

  2. Оновіть прапорець --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.

  3. Зачекайте, поки менеджер контролерів оновить ca.crt у Secrets для ServiceAccount, щоб вони містили і старі, і нові сертифікати CA.

    Якщо якісь Podʼи запускаються до того, як API-сервери почнуть використовувати новий CA, нові Podʼи отримають це оновлення й довірятимуть і старим, і новим CA.

  4. Перезапустіть усі Podʼи, що використовують конфігурації всередині кластера (наприклад, kube-proxy, CoreDNS тощо), щоб вони могли використовувати оновлені дані центру сертифікації із Secrets, повʼязаних із ServiceAccounts.

    • Переконайтеся, що CoreDNS, kube-proxy та інші Podʼи, які використовують конфігурації всередині кластера, працюють належним чином.
  5. Додайте і старий, і новий CA до файлу, вказаного у прапорцях --client-ca-file і --kubelet-certificate-authority, у конфігурації kube-apiserver.

  6. Додайте і старий, і новий CA до файлу, вказаного у прапорці --client-ca-file, у конфігурації kube-scheduler.

  7. Оновіть сертифікати облікових записів користувачів, замінивши вміст client-certificate-data і client-key-data відповідно.

    Докладніше про створення сертифікатів для окремих облікових записів користувачів дивіться в розділі Налаштування сертифікатів для облікових записів користувачів.

    Крім того, оновіть розділ certificate-authority-data у файлах kubeconfig, вказавши відповідно закодовані в Base64 дані старого й нового центру сертифікації.

  8. Оновіть прапорець --root-ca-file для Cloud Controller Manager, щоб він містив і старий, і новий CA, а потім перезапустіть cloud-controller-manager.

    Примітка:

    Якщо у вашому кластері немає cloud-controller-manager, цей крок можна пропустити.
  9. Виконайте наведені нижче кроки поетапно.

    1. Перезапустіть усі інші агреговані API-сервери або обробники вебхуків, щоб вони довіряли новим сертифікатам CA.

    2. Перезапустіть kubelet, оновивши файл, вказаний у clientCAFile у конфігурації kubelet, і certificate-authority-data у kubelet.conf, щоб використовувати і старий, і новий CA на всіх вузлах.

      Якщо ваш kubelet не використовує ротацію клієнтських сертифікатів, оновіть client-certificate-data і client-key-data у kubelet.conf на всіх вузлах, а також файл клієнтського сертифіката kubelet, який зазвичай міститься в /var/lib/kubelet/pki.

    3. Перезапустіть 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).
      
    4. Додайте анотації до DaemonSets і Deployments, щоб запустити заміну Podʼів безпечнішим поетапним способом.

      for namespace in $(kubectl get namespace -o jsonpath='{.items[*].metadata.name}'); do
          for 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"}}}}}';
          done
          for 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"}}}}}';
          done
      done
      

      Примітка:

        Щоб обмежити кількість одночасних порушень, яких зазнає ваш застосунок, дивіться [налаштування бюджету порушень Podʼів](/docs/tasks/run-application/configure-pdb/).
      

      Залежно від того, як ви використовуєте StatefulSets, вам також може знадобитися виконати подібну поетапну заміну.

  10. Якщо ваш кластер використовує токени початкового завантаження для приєднання вузлів, оновіть ConfigMap cluster-info у просторі імен kube-public, додавши новий CA.

    base64_encoded_ca="$(base64 -w0 /etc/kubernetes/pki/ca.crt)"
    
    kubectl get cm/cluster-info --namespace kube-public -o yaml | \
        /bin/sed "s/\(certificate-authority-data:\).*/\1 ${base64_encoded_ca}/" | \
        kubectl apply -f -
    
  11. Перевірте роботу кластера.

    1. Перевірте логи компонентів панелі управління, а також kubelet і kube-proxy. Переконайтеся, що ці компоненти не повідомляють про помилки TLS; докладніше дивіться в розділі перегляд логів.

    2. Перевірте логи агрегованих API-серверів і Podʼів, що використовують конфігурацію всередині кластера.

  12. Після успішної перевірки роботи кластера:

    1. Оновіть усі токени ServiceAccount, щоб вони містили лише новий сертифікат CA.

      • Усі Podʼи, що використовують kubeconfig всередині кластера, зрештою потрібно буде перезапустити, щоб вони отримали новий Secret і жоден Pod не залежав від старого CA кластера.
    2. Перезапустіть компоненти панелі управління, вилучивши старий CA з файлів kubeconfig і файлів, вказаних у прапорцях --client-ca-file і --root-ca-file відповідно.

    3. На кожному вузлі перезапустіть 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ʼа.

apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: example-daemonset
spec:
  selector:
    matchLabels:
      app.kubernetes.io/name: example
  template:
    metadata:
      labels:
        app.kubernetes.io/name: example
    spec:
      containers:
      - name: pause
        image: registry.k8s.io/pause
      initContainers:
      - name: log-machine-id
        image: busybox:1.37
        command: ['sh', '-c', 'cat /etc/machine-id > /var/log/machine-id.log']
        volumeMounts:
        - name: machine-id
          mountPath: /etc/machine-id
          readOnly: true
        - name: log-dir
          mountPath: /var/log
      volumes:
      - name: machine-id
        hostPath:
          path: /etc/machine-id
          type: File
      - name: log-dir
        hostPath:
          path: /var/log
  1. Створіть DaemonSet на основі маніфесту (YAML):

    kubectl apply -f https://k8s.io/examples/application/basic-daemonset.yaml
    
  2. Після застосування ви можете перевірити, що DaemonSet запускає Pod на кожному вузлі кластера:

    kubectl get pods -o wide
    

    Вивід міститиме по одному Podʼу на вузол, наприклад:

    NAME                                READY   STATUS    RESTARTS   AGE    IP       NODE
    example-daemonset-xxxxx             1/1     Running   0          5m     x.x.x.x  node-1
    example-daemonset-yyyyy             1/1     Running   0          5m     x.x.x.x  node-2
    
  3. Ви можете переглянути вміст залогованого файлу /etc/machine-id, перевіривши теку логів, змонтовану з хоста:

    kubectl exec <pod-name> -- cat /var/log/machine-id.log
    

    Де <pod-name> — назва одного з ваших Podʼів.

Очищення

Щоб видалити DaemonSet, виконайте цю команду:

kubectl delete --cascade=foreground --ignore-not-found --now daemonsets/example-daemonset

Цей простий приклад DaemonSet знайомить із ключовими компонентами, такими як init-контейнери й томи hostPath, які можна розширювати для складніших сценаріїв. Докладніше дивіться DaemonSet.

Що далі

13.2 - Виконання поетапного оновлення DaemonSet

На цій сторінці показано, як виконати поетапне оновлення DaemonSet.

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

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

Стратегія оновлення DaemonSet

DaemonSet має два типи стратегій оновлення:

  • 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.

Ви також можете встановити .spec.updateStrategy.rollingUpdate.maxUnavailable (стандартно 1), .spec.minReadySeconds (стандартно 0) та .spec.updateStrategy.rollingUpdate.maxSurge (стандартно 0).

Створення DaemonSet зі стратегією оновлення RollingUpdate

Цей файл YAML визначає DaemonSet зі стратегією оновлення RollingUpdate:

apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: fluentd-elasticsearch
  namespace: kube-system
  labels:
    k8s-app: fluentd-logging
spec:
  selector:
    matchLabels:
      name: fluentd-elasticsearch
  updateStrategy:
    type: RollingUpdate
    rollingUpdate:
      maxUnavailable: 1
  template:
    metadata:
      labels:
        name: fluentd-elasticsearch
    spec:
      tolerations:
      # ці tolerations дозволяють запускати DaemonSet на вузлах панелі управління
      # видаліть їх, якщо ваші вузли панелі управління не повинні запускати Podʼи
      - key: node-role.kubernetes.io/control-plane
        operator: Exists
        effect: NoSchedule
      - key: node-role.kubernetes.io/master
        operator: Exists
        effect: NoSchedule
      containers:
      - name: fluentd-elasticsearch
        image: quay.io/fluentd_elasticsearch/fluentd:v5.0.1
        volumeMounts:
        - name: varlog
          mountPath: /var/log
        - name: varlibdockercontainers
          mountPath: /var/lib/docker/containers
          readOnly: true
      terminationGracePeriodSeconds: 30
      volumes:
      - name: varlog
        hostPath:
          path: /var/log
      - name: varlibdockercontainers
        hostPath:
          path: /var/lib/docker/containers

Перевіривши стратегію оновлення в маніфесті DaemonSet, створіть DaemonSet:

kubectl create -f https://k8s.io/examples/controllers/fluentd-daemonset.yaml

Або скористайтесь командою kubectl apply, щоб створити той самий DaemonSet, якщо ви плануєте оновлювати DaemonSet за допомогою kubectl apply.

kubectl apply -f https://k8s.io/examples/controllers/fluentd-daemonset.yaml

Перевірка стратегії оновлення RollingUpdate у DaemonSet

Перевірте стратегію оновлення вашого DaemonSet і переконайтеся, що вона встановлена в RollingUpdate:

kubectl get ds/fluentd-elasticsearch -o go-template='{{.spec.updateStrategy.type}}{{"\n"}}' -n kube-system

Якщо ви ще не створили DaemonSet у системі, натомість перевірте маніфест DaemonSet такою командою:

kubectl apply -f https://k8s.io/examples/controllers/fluentd-daemonset.yaml --dry-run=client -o go-template='{{.spec.updateStrategy.type}}{{"\n"}}'

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

RollingUpdate

Якщо вивід не RollingUpdate, поверніться й відповідно змініть обʼєкт DaemonSet або маніфест.

Оновлення шаблону DaemonSet

Будь-які оновлення .spec.template у DaemonSet зі стратегією RollingUpdate запускають поетапне оновлення. Оновімо DaemonSet, застосувавши новий файл YAML. Це можна зробити кількома різними командами kubectl.

apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: fluentd-elasticsearch
  namespace: kube-system
  labels:
    k8s-app: fluentd-logging
spec:
  selector:
    matchLabels:
      name: fluentd-elasticsearch
  updateStrategy:
    type: RollingUpdate
    rollingUpdate:
      maxUnavailable: 1
  template:
    metadata:
      labels:
        name: fluentd-elasticsearch
    spec:
      tolerations:
      # ці tolerations дозволяють запускати DaemonSet на вузлах панелі управління
      # видаліть їх, якщо ваші вузли панелі управління не повинні запускати Podʼи
      - key: node-role.kubernetes.io/control-plane
        operator: Exists
        effect: NoSchedule
      - key: node-role.kubernetes.io/master
        operator: Exists
        effect: NoSchedule
      containers:
      - name: fluentd-elasticsearch
        image: quay.io/fluentd_elasticsearch/fluentd:v5.0.1
        resources:
          limits:
            memory: 200Mi
          requests:
            cpu: 100m
            memory: 200Mi
        volumeMounts:
        - name: varlog
          mountPath: /var/log
        - name: varlibdockercontainers
          mountPath: /var/lib/docker/containers
          readOnly: true
      terminationGracePeriodSeconds: 30
      volumes:
      - name: varlog
        hostPath:
          path: /var/log
      - name: varlibdockercontainers
        hostPath:
          path: /var/lib/docker/containers

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

Якщо ви оновлюєте DaemonSets за допомогою файлів конфігурації, використовуйте kubectl apply:

kubectl apply -f https://k8s.io/examples/controllers/fluentd-daemonset-update.yaml

Імперативні команди

Якщо ви оновлюєте DaemonSets за допомогою імперативних команд, використовуйте kubectl edit :

kubectl edit ds/fluentd-elasticsearch -n kube-system
Оновлення лише образу контейнера

Якщо вам потрібно оновити лише образ контейнера у шаблоні 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 із простору імен:

kubectl delete ds fluentd-elasticsearch -n kube-system

Що далі

13.3 - Виконання відкочування DaemonSet

На цій сторінці показано, як виконати відкочування DaemonSet.

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

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

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

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

Ви вже маєте знати, як виконати поетапне оновлення DaemonSet.

Виконання відкочування DaemonSet

Крок 1: Знайдіть ревізію DaemonSet, до якої потрібно відкотитися

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

Виведіть усі ревізії DaemonSet:

kubectl rollout history daemonset <daemonset-name>

Це поверне список ревізій DaemonSet:

daemonsets "<daemonset-name>"
REVISION        CHANGE-CAUSE
1               ...
2               ...
...
  • Причина зміни копіюється з анотації DaemonSet kubernetes.io/change-cause до його ревізій під час їх створення. Ви можете вказати --record=true у kubectl, щоб записати виконану команду в анотацію причини зміни.

Щоб переглянути подробиці конкретної ревізії:

kubectl rollout history daemonset <daemonset-name> --revision=1

Це поверне подробиці цієї ревізії:

daemonsets "<daemonset-name>" with revision #1
Pod Template:
Labels:       foo=bar
Containers:
app:
 Image:        ...
 Port:         ...
 Environment:  ...
 Mounts:       ...
Volumes:      ...

Крок 2: Відкотіться до конкретної ревізії

# Вкажіть номер ревізії, отриманий на кроці 1, у --to-revision
kubectl 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.

Усунення несправностей

13.4 - Запуск Podʼів лише на деяких вузлах

На цій сторінці показано, як запускати Podʼи лише на деяких вузлах у складі DaemonSet

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

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

Запуск Podʼів лише на деяких вузлах

Уявімо, що ви хочете запустити DaemonSet, але ці Podʼи демонів потрібно запускати лише на вузлах із локальним твердотільним сховищем (SSD). Наприклад, Pod може надавати вузлу сервіс кешування, а кеш корисний лише тоді, коли доступне локальне сховище з низькою затримкою.

Крок 1: Додайте мітки до вузлів

Додайте мітку ssd=true до вузлів, які мають SSD.

kubectl label nodes example-node-1 example-node-2 ssd=true

Крок 2: Створіть маніфест

Створімо DaemonSet, який розгортатиме Podʼи демонів лише на вузлах з міткою SSD.

Далі використайте nodeSelector, щоб DaemonSet запускав Podʼи лише на вузлах, де мітка ssd має значення "true".

apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: ssd-driver
  labels:
    app: nginx
spec:
  selector:
    matchLabels:
      app: ssd-driver-pod
  template:
    metadata:
      labels:
        app: ssd-driver-pod
    spec:
      nodeSelector:
        ssd: "true"
      containers:
        - name: example-container
          image: example-image

Крок 3: Створіть DaemonSet

Створіть 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-адрес.

cat <<EOF | kubectl apply -f -
apiVersion: networking.k8s.io/v1
kind: ServiceCIDR
metadata:
  name: newcidr1
spec:
  cidrs:
  - 10.96.0.0/24
EOF
servicecidr.networking.k8s.io/newcidr1 created

і це дозволить створювати нові 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/v1
kind: ServiceCIDR
metadata:
  creationTimestamp: "2023-10-12T15:11:07Z"
  deletionGracePeriodSeconds: 0
  deletionTimestamp: "2023-10-12T15:12:45Z"
  finalizers:
  - networking.k8s.io/service-cidr-finalizer
  name: newcidr1
  resourceVersion: "1133"
  uid: 5ffd8afe-c78f-4e60-ae76-cec448a8af40
spec:
  cidrs:
  - 10.96.0.0/24
status:
  conditions:
  - lastTransitionTime: "2023-10-12T15:12:45Z"
    message: There are still IPAddresses referencing the ServiceCIDR, please remove
      them or create a new ServiceCIDR
    reason: OrphanIPAddress
    status: "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, додайте таку умову:

  matchConditions:
  - name: 'exclude-default-servicecidr'
    expression: "object.metadata.name != 'kubernetes'"

як у наведених нижче прикладах.

Обмеження діапазонів 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/v1
kind: ValidatingAdmissionPolicy
metadata:
  name: "servicecidrs.default"
spec:
  failurePolicy: Fail
  matchConstraints:
    resourceRules:
    - apiGroups:   ["networking.k8s.io"]
      apiVersions: ["v1"]
      operations:  ["CREATE", "UPDATE"]
      resources:   ["servicecidrs"]
  matchConditions:
  - name: 'exclude-default-servicecidr'
    expression: "object.metadata.name != 'kubernetes'"
  variables:
  - name: allowed
    expression: "['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/v1
kind: ValidatingAdmissionPolicyBinding
metadata:
  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/v1
kind: ValidatingAdmissionPolicy
metadata:
  name: "servicecidrs.deny"
spec:
  failurePolicy: Fail
  matchConstraints:
    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/v1
kind: ValidatingAdmissionPolicyBinding
metadata:
  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:

kubectl get nodes k8s-linuxpool1-34450317-0 -o go-template --template='{{range .status.addresses}}{{printf "%s: %s\n" .type .address}}{{end}}'
Hostname: k8s-linuxpool1-34450317-0
InternalIP: 10.0.0.5
InternalIP: 2001:db8:10::5

Перевірка адресації Podʼів

Перевірте, що 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.

        env:
        - name: MY_POD_IPS
          valueFrom:
            fieldRef:
              fieldPath: status.podIPs

Наведена нижче команда виводить значення змінної середовища 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ʼа.

kubectl exec -it pod01 -- cat /etc/hosts
# Kubernetes-managed hosts file.
127.0.0.1    localhost
::1    localhost ip6-localhost ip6-loopback
fe00::0    ip6-localnet
fe00::0    ip6-mcastprefix
fe00::1    ip6-allnodes
fe00::2    ip6-allrouters
10.244.1.4    pod01
2001:db8::4    pod01

Перевірка Services

Створіть наведений нижче Service, який явно не визначає .spec.ipFamilyPolicy. Kubernetes призначить Service кластерний IP з першого налаштованого service-cluster-ip-range і встановить .spec.ipFamilyPolicy у SingleStack.

apiVersion: v1
kind: Service
metadata:
  name: my-service
  labels:
    app.kubernetes.io/name: MyApp
spec:
  selector:
    app.kubernetes.io/name: MyApp
  ports:
    - protocol: TCP
      port: 80

Використайте kubectl, щоб переглянути YAML цього Service.

kubectl get svc my-service -o yaml

Service має .spec.ipFamilyPolicy зі значенням SingleStack і .spec.clusterIP з адресою IPv4 із першого налаштованого діапазону, заданого прапорцем --service-cluster-ip-range у kube-controller-manager.

apiVersion: v1
kind: Service
metadata:
  name: my-service
  namespace: default
spec:
  clusterIP: 10.0.217.164
  clusterIPs:
  - 10.0.217.164
  ipFamilies:
  - IPv4
  ipFamilyPolicy: SingleStack
  ports:
  - port: 80
    protocol: TCP
    targetPort: 9376
  selector:
    app.kubernetes.io/name: MyApp
  sessionAffinity: None
  type: ClusterIP
status:
  loadBalancer: {}

Створіть наведений нижче Service, який явно визначає IPv6 як перший елемент масиву .spec.ipFamilies. Kubernetes призначить Service кластерний IP із діапазону IPv6, налаштованого в service-cluster-ip-range, і встановить .spec.ipFamilyPolicy у SingleStack.

apiVersion: v1
kind: Service
metadata:
  name: my-service
  labels:
    app.kubernetes.io/name: MyApp
spec:
  ipFamilies:
  - IPv6
  selector:
    app.kubernetes.io/name: MyApp
  ports:
    - protocol: TCP
      port: 80

Використайте 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.

apiVersion: v1
kind: Service
metadata:
  labels:
    app.kubernetes.io/name: MyApp
  name: my-service
spec:
  clusterIP: 2001:db8:fd00::5118
  clusterIPs:
  - 2001:db8:fd00::5118
  ipFamilies:
  - IPv6
  ipFamilyPolicy: SingleStack
  ports:
  - port: 80
    protocol: TCP
    targetPort: 80
  selector:
    app.kubernetes.io/name: MyApp
  sessionAffinity: None
  type: ClusterIP
status:
  loadBalancer: {}

Створіть наведений нижче Service, який явно визначає PreferDualStack у .spec.ipFamilyPolicy. Kubernetes призначить адреси IPv4 та IPv6 (оскільки в цьому кластері ввімкнено подвійний стек) і вибере .spec.ClusterIP зі списку .spec.ClusterIPs на основі сімейства адрес першого елемента масиву .spec.ipFamilies.

apiVersion: v1
kind: Service
metadata:
  name: my-service
  labels:
    app.kubernetes.io/name: MyApp
spec:
  ipFamilyPolicy: PreferDualStack
  selector:
    app.kubernetes.io/name: MyApp
  ports:
    - protocol: TCP
      port: 80

Примітка:

Команда 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-адреси й порти.

kubectl describe svc -l app.kubernetes.io/name=MyApp
Name:              my-service
Namespace:         default
Labels:            app.kubernetes.io/name=MyApp
Annotations:       <none>
Selector:          app.kubernetes.io/name=MyApp
Type:              ClusterIP
IP Family Policy:  PreferDualStack
IP Families:       IPv4,IPv6
IP:                10.0.216.242
IPs:               10.0.216.242,2001:db8:fd00::af55
Port:              <unset>  80/TCP
TargetPort:        9376/TCP
Endpoints:         <none>
Session Affinity:  None
Events:            <none>

Створення Service з подвійним стеком і балансуванням навантаження

Якщо хмарний провайдер підтримує надання зовнішніх балансувальників навантаження з підтримкою IPv6, створіть наведений нижче Service із PreferDualStack у .spec.ipFamilyPolicy, IPv6 як першим елементом масиву .spec.ipFamilies і полем type зі значенням LoadBalancer.

apiVersion: v1
kind: Service
metadata:
  name: my-service
  labels:
    app.kubernetes.io/name: MyApp
spec:
  ipFamilyPolicy: PreferDualStack
  ipFamilies:
  - IPv6
  type: LoadBalancer
  selector:
    app.kubernetes.io/name: MyApp
  ports:
    - protocol: TCP
      port: 80

Перевірте Service:

kubectl get svc -l app.kubernetes.io/name=MyApp

Перевірте, що 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 виглядатиме так:

kubectl exec nginx -- cat /etc/hosts
# Kubernetes-managed hosts file.
127.0.0.1	localhost
::1	localhost ip6-localhost ip6-loopback
fe00::0	ip6-localnet
fe00::0	ip6-mcastprefix
fe00::1	ip6-allnodes
fe00::2	ip6-allrouters
10.200.0.4	nginx

Стандартно файл 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:

apiVersion: v1
kind: Pod
metadata:
  name: hostaliases-pod
spec:
  restartPolicy: Never
  hostAliases:
  - ip: "127.0.0.1"
    hostnames:
    - "foo.local"
    - "bar.local"
  - ip: "10.1.2.3"
    hostnames:
    - "foo.remote"
    - "bar.remote"
  containers:
  - name: cat-hosts
    image: busybox:1.28
    command:
    - cat
    args:
    - "/etc/hosts"

Ви можете запустити Pod із такою конфігурацією, виконавши:

kubectl apply -f https://k8s.io/examples/service/networking/hostaliases-pod.yaml
pod/hostaliases-pod created

Перегляньте подробиці Podʼа, щоб побачити його адресу IPv4 і статус:

kubectl get pod --output=wide
NAME                           READY     STATUS      RESTARTS   AGE       IP              NODE
hostaliases-pod                0/1       Completed   0          6s        10.200.0.5      worker0

Вміст файлу hosts виглядає так:

kubectl logs hostaliases-pod
# Kubernetes-managed hosts file.
127.0.0.1	localhost
::1	localhost ip6-localhost ip6-loopback
fe00::0	ip6-localnet
fe00::0	ip6-mcastprefix
fe00::1	ip6-allnodes
fe00::2	ip6-allrouters
10.200.0.5	hostaliases-pod

# Entries added by HostAliases.
127.0.0.1	foo.local	bar.local
10.1.2.3	foo.remote	bar.remote

з додатковими записами, вказаними внизу.

Чому kubelet керує файлом hosts?

kubelet керує файлом hosts для кожного контейнера Podʼа, щоб середовище виконання контейнерів не змінювало цей файл після запуску контейнерів. Історично Kubernetes завжди використовував Docker Engine як середовище виконання контейнерів, а Docker Engine змінював файл /etc/hosts після запуску кожного контейнера.

Поточний Kubernetes може використовувати різні середовища виконання контейнерів; попри це, kubelet керує файлом hosts у кожному контейнері, щоб результат був очікуваним незалежно від середовища виконання контейнерів, яке ви використовуєте.

Увага:

Уникайте ручних змін файлу hosts усередині контейнера.

Якщо ви вносите ручні зміни до файлу hosts, ці зміни втрачаються, коли контейнер завершує роботу.

14.4 - Переналаштування стандартного ServiceCIDR Kubernetes

СТАН ФУНКЦІОНАЛУ: 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.33.

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

Переналаштування стандартного ServiceCIDR Kubernetes

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

  1. Оновлення конфігурації kube-apiserver: змініть прапорець --service-cluster-ip-range, указавши нові діапазони IP.
  2. Переналаштування мережевих компонентів: це критичний крок, і конкретна процедура залежить від мережевих компонентів, що використовуються. Він може охоплювати оновлення файлів конфігурації, перезапуск Podʼів агентів або оновлення компонентів для керування новими ServiceCIDR і бажаною конфігурацією сімейства IP для Podʼів. Такими компонентами можуть бути реалізація Services Kubernetes, наприклад kube-proxy, налаштований мережевий втулок і, можливо, інші мережеві компоненти, такі як контролери service mesh і сервери DNS, щоб вони могли правильно обробляти трафік і виконувати виявлення сервісів із новою конфігурацією сімейства IP.
  3. Керування наявними Services: Services з IP-адресами зі старого CIDR потрібно обробити, якщо вони не входять до нових налаштованих діапазонів. Варіанти: повторне створення (що призводить до простою і призначення нових IP-адрес) або потенційно складніші стратегії переналаштування.
  4. Повторне створення внутрішніх сервісів Kubernetes: Service kubernetes.default потрібно видалити й створити заново, щоб отримати IP-адресу з нового ServiceCIDR, якщо первинне сімейство IP змінено або замінено іншою мережею.

Приклад кроків переналаштування

Наведені нижче кроки описують контрольоване переналаштування з повною заміною стандартного ServiceCIDR і повторним створенням Service kubernetes.default:

  1. Запустіть kube-apiserver з початковим --service-cluster-ip-range.
  2. Створіть початкові Services, які отримують IP-адреси з цього діапазону.
  3. Створіть новий ServiceCIDR як тимчасову ціль переналаштування.
  4. Позначте стандартний ServiceCIDR kubernetes для видалення (він лишатиметься в очікуванні через наявні IP-адреси й завершувачі). Це запобігає новим виділенням зі старого діапазону.
  5. Повторно створіть наявні Services. Тепер вони мають отримати IP-адреси з нового тимчасового ServiceCIDR.
  6. Перезапустіть kube-apiserver із налаштованими новими ServiceCIDR і вимкніть старий екземпляр.
  7. Видаліть Service kubernetes.default. Новий kube-apiserver створить його заново в новому ServiceCIDR.

Що далі

15 - Розширення kubectl за допомогою втулків

Розширюйте 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" ]]
then
    echo "1.0.0"
    exit 0
fi

# необовʼязкова обробка аргументів
if [[ "$1" == "config" ]]
then
    echo "$KUBECONFIG"
    exit 0
fi

echo "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

Усі змінні середовища також передаються виконуваному файлу без змін:

export KUBECONFIG=~/.kube/config
kubectl foo config
/home/<user>/.kube/config
KUBECONFIG=/etc/kube/config kubectl foo config
/etc/kube/config

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

# встановимо ваш втулок, перемістивши його у теку з $PATH
sudo 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

# перемістимо втулок у теку з $PATH
sudo 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

Таке проєктне рішення гарантує, що підкоманди втулка можна за потреби реалізувати в кількох файлах і вкладати їх під «батьківську» команду втулка:

ls ./plugin_command_tree
kubectl-parent
kubectl-parent-subcommand
kubectl-parent-subcommand-subsubcommand

Перевірка на наявність попереджень втулків

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

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

Вузли Kubernetes мають заздалегідь виділити великі сторінки, щоб вузол міг повідомляти про свою місткість великих сторінок.

Вузол може заздалегідь виділяти великі сторінки кількох розмірів; наприклад, такий рядок у /etc/default/grub виділяє 2*1GiB сторінок розміром 1 GiB і 512*2 MiB сторінок розміром 2 MiB:

GRUB_CMDLINE_LINUX="hugepagesz=1G hugepages=2 hugepagesz=2M hugepages=512"

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

Коли ви переглянете опис вузла, ви маєте побачити щось подібне до наведеного нижче в розділах Capacity та Allocatable:

Capacity:
  cpu:                ...
  ephemeral-storage:  ...
  hugepages-1Gi:      2Gi
  hugepages-2Mi:      1Gi
  memory:             ...
  pods:               ...
Allocatable:
  cpu:                ...
  ephemeral-storage:  ...
  hugepages-1Gi:      2Gi
  hugepages-2Mi:      1Gi
  memory:             ...
  pods:               ...

Примітка:

Для динамічно виділених сторінок (після завантаження системи) kubelet потрібно перезапустити, щоб нові виділення відобразилися.

API

Великі сторінки можна використовувати через вимоги до ресурсів на рівні контейнера з назвою ресурсу hugepages-<size>, де <size> — найкомпактніше двійкове позначення з цілочисельними значеннями, підтримуваними на конкретному вузлі. Наприклад, якщо вузол підтримує розміри сторінок 2048KiB і 1048576KiB, він надаватиме ресурси, придатні для планування, hugepages-2Mi та hugepages-1Gi. На відміну від CPU або памʼяті, великі сторінки не підтримують надмірне виділення (overcommit). Зверніть увагу, що під час запиту ресурсів великих сторінок також потрібно запитувати ресурси памʼяті або CPU.

Pod може використовувати кілька розмірів великих сторінок в одній специфікації Podʼа. У цьому випадку для всіх монтувань томів потрібно використовувати нотацію medium: HugePages-<hugepagesize>.

apiVersion: v1
kind: Pod
metadata:
  name: huge-pages-example
spec:
  containers:
  - name: example
    image: fedora:latest
    command:
    - sleep
    - inf
    volumeMounts:
    - mountPath: /hugepages-2Mi
      name: hugepage-2mi
    - mountPath: /hugepages-1Gi
      name: hugepage-1gi
    resources:
      limits:
        hugepages-2Mi: 100Mi
        hugepages-1Gi: 2Gi
        memory: 100Mi
      requests:
        memory: 100Mi
  volumes:
  - name: hugepage-2mi
    emptyDir:
      medium: HugePages-2Mi
  - name: hugepage-1gi
    emptyDir:
      medium: HugePages-1Gi

Pod може використовувати medium: HugePages, лише якщо він запитує великі сторінки одного розміру.

apiVersion: v1
kind: Pod
metadata:
  name: huge-pages-example
spec:
  containers:
  - name: example
    image: fedora:latest
    command:
    - sleep
    - inf
    volumeMounts:
    - mountPath: /hugepages
      name: hugepage
    resources:
      limits:
        hugepages-2Mi: 100Mi
        memory: 100Mi
      requests:
        memory: 100Mi
  volumes:
  - name: hugepage
    emptyDir:
      medium: HugePages
  • Запити великих сторінок мають дорівнювати обмеженням. Так відбувається стандартно, якщо обмеження вказано, а запити — ні.
  • Великі сторінки ізольовані на рівні контейнера, тому кожен контейнер має власне обмеження у своїй пісочниці 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: v1
kind: Pod
metadata:
  name: example-vector-add
spec:
  restartPolicy: OnFailure
  containers:
    - name: example-vector-add
      image: "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: v1
kind: Pod
metadata:
  name: example-vector-add
spec:
  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" # мітка можливості NFD
            values: ["true"] # (необовʼязково) планувати лише на вузли з пристроєм PCI 10
  containers:
    - name: example-vector-add
      image: "registry.example/example-vector-add:v42"
      resources:
        limits:
          gpu-vendor.example/example-gpu: 1 # запит на 1 GPU

Реалізації постачальників GPU