✻ Урок 5.12 · Тема 5: Kubernetes и Helm
Безопасность кластера: RBAC, NetworkPolicy, PSS
Содержание урока
Как работать с кодом и когда идти дальше
Команды не нужно писать по памяти. Пользуйся примерами из урока и справкой. Ориентируйся на цель задания:
- Запусти готовое. Код приложения и вспомогательных скриптов можно скопировать. Пойми, зачем они нужны, что запускают или меняют и как проверить результат. Разбирать каждую функцию внутри готового инструмента не требуется.
- Измени по образцу. Разбери новые конструкции, объяснённые в уроке. Измени указанный параметр или часть кода, предскажи результат и проверь запуском.
- Напиши сам. Собери свой вариант под условия задания. Образцы и справка разрешены: важно объяснить своё решение и проверить его работу.
Можно идти дальше, если ты выполнил практику, получил ожидаемый результат и понимаешь, что проверил. Если задание просит изменить код, проверь и своё изменение.
Непонятные детали готового инструмента можно оставить на потом. При ошибке запуска вернись к разбору вывода и типичным ошибкам в уроке.
Зачем это нужно
Kubernetes из коробки открыт изнутри. Это три отдельные дыры (под это запущенный контейнер приложения, урок 5.2):
- Любой под ходит к любому. Сеть плоская: все подключены ко всем, как в офисе без внутренних дверей.
- Под работает от root. Это администратор внутри контейнера: он меняет любые файлы и ставит любые программы.
- Токен лежит в файловой системе. По нему можно обращаться к API кластера (API это «приёмная», через которую проходят все команды управления кластером), и любой процесс в поде может его прочитать.
Уязвимость это ошибка в программе, которой можно воспользоваться для атаки. Одна уязвимость в приложении даёт атакующему все три дыры сразу. Эти вопросы задают на аудитах и после инцидентов: «почему из пода фронтенда достучались до базы».
Вот как выглядит такая атака, если ничего не защищено:
flowchart LR
A["Атакующий<br>нашёл дыру во фронтенде"] --> F["Под frontend"]
F -->|"свободно ходит"| B["Под с базой<br>postgres"]
F -->|"свободно ходит"| O["Другие поды"]
Из одного взломанного пода открыты дороги ко всем остальным: между подами нет ни одного запрета. Помимо сети есть ещё две дыры (права внутри пода и токен для API), их покажу в теории; все три закрывает этот урок.
Три понятия закрывают основное:
- RBAC (Role-Based Access Control, доступ по ролям): кто и что может делать через API кластера;
- NetworkPolicy: кто с кем может разговаривать по сети;
- Pod Security Standards (PSS) и securityContext: с какими привилегиями вообще разрешено запускать под.
Шаги проекта в этом уроке:
- namespace
notesполучает уровень PSSrestricted; - чарт
helm/notesверсии 0.2.0 запускает приложение от uid 10001 с read-only файловой системой; - у приложения появляется свой ServiceAccount (учётная запись программы в кластере, а не человека; подробно разберём ниже) без токена;
- в
k8s/base/70-netpol-default-deny.yamlпоявляется запрет всего трафика по умолчанию, а в чарте политика для самого приложения.
Что нужно знать
- Урок 1.3: пользователи и права: uid (числовой номер пользователя) и gid (группы), права на файлы. Без них непонятны
runAsUserиfsGroup. - Урок 4.2: Dockerfile: пользователь 10001 в образе «Заметок».
- Урок 4.8: безопасность образов: идея минимальных привилегий контейнера.
- Урок 5.2: Pod и Deployment: структура манифеста пода, метки (labels).
- Урок 5.3: Service и DNS: DNS кластера (CoreDNS это «телефонная книга» кластера в namespace
kube-system: по имениdbона подсказывает адрес пода; порт 53 это стандартный порт DNS): без неё имена не разрешатся. - Урок 5.4: Ingress и Gateway API: откуда приходит трафик в
notes. Ingress (входная точка: «ворота», через которые внешний трафик попадает внутрь кластера) у нас реализован через Gateway API: прокси Envoy в namespaceenvoy-gateway-system. - Урок 5.5: PostgreSQL и StatefulSet: база
postgres, меткаapp.kubernetes.io/name: postgres. - Урок 5.6: ConfigMap и Secret: Secret это всего лишь base64 (способ записи, а не шифрование), поэтому доступ к нему надо ограничивать.
- Урок 5.8: Job и CronJob: бэкап
pg-backup, который тоже придётся подправить. - Урок 5.9: Helm: чарт
helm/notes, который мы дополняем.
Картина целиком
Три слоя защиты отвечают на три разных вопроса.
- RBAC: что этому субъекту разрешено делать через API кластера (читать поды, создавать Deployment, читать Secret).
- NetworkPolicy: какие поды могут подключаться к каким. По умолчанию разрешено всё, а политика оставляет только нужные соединения.
- Pod Security Standards (PSS, «стандарты безопасности подов»): три готовых набора требований, от «можно всё» до «максимально строго». Они определяют, с какими привилегиями поду разрешено запускаться (от root, с лишними capabilities, с доступом к узлу). Проверка идёт при создании пода.
- securityContext: блок настроек в манифесте самого пода: от какого пользователя запускать, что ему запрещено. PSS проверяет, что эти настройки выставлены правильно.
Слои работают вместе. Если взломали приложение, NetworkPolicy не даёт дойти до чужих подов, отсутствие токена и RBAC закрывают API, а PSS не позволяет запустить новый под с лишними привилегиями.
flowchart TD
subgraph API["запрос к API кластера (kubectl, контроллеры, код в поде)"]
A1["1. Кто ты?<br>аутентификация"] --> A2["2. Тебе можно?<br>RBAC"] --> A3["3. Объект допустим?<br>Pod Security"]
end
A3 --> POD["создан под: запущен под ограничениями securityContext<br>не root, read-only файловая система, без лишних привилегий"]
NET["трафик между подами (curl из пода в под)"] --> NP["NetworkPolicy: какие соединения разрешены<br>ingress (входящий), egress (исходящий)"]
Дальше: как устроена модель угроз, как запрос проходит проверки в API, потом каждый слой по отдельности.
Теория
Зачем защищать то, что «внутри»: модель угроз и защита в глубину
Обычно безопасность представляют как забор вокруг: внутрь чужих не пускаем, а «свои» доверяют друг другу. Так и устроен Kubernetes из коробки: если ты внутри кластера, ты почти всё можешь. Проблема в том, что «внутри» оказываются не только свои. Уязвимость в библиотеке, ошибка в коде, украденный токен, и злоумышленник уже внутри пода.
Атаку через уязвимость приложения называют RCE (Remote Code Execution, удалённое выполнение кода): атакующий заставляет твою программу выполнить его команды. Условный пример: так выглядит осмотр взломанного пода без защиты. Это иллюстрация, в твоём кластере такого пода пока нет, формат примерный. kubectl exec запускает команду внутри пода, id показывает, кто ты, nc -zv проверяет, открыт ли порт:
$ kubectl exec <под> -n notes -- id
uid=0(root) gid=0(root) groups=0(root)
$ kubectl exec <под> -n notes -- ls /var/run/secrets/kubernetes.io/serviceaccount
ca.crt namespace token
$ kubectl exec <под> -n notes -- nc -zv postgres 5432
postgres (10.96.88.14:5432) open
Из такого пода видно сразу три дыры: процесс работает от root, внутри лежит токен для API кластера, а порт базы 5432 открыт. Ровно эти три вещи и закрывает урок.
А вот цепочка шагов атакующего на «Заметках», если ничего не защищено:
1. В приложении нашли дыру, атакующий выполняет команды в поде notes.
2. Под работает от root -> он может менять файлы, ставить утилиты.
3. В поде лежит токен ServiceAccount -> с ним можно ходить в API кластера.
4. Сеть плоская -> из пода notes можно открыть соединение с любым другим подом.
5. Итог: читает Secret с паролем БД, подключается к postgres напрямую,
запускает свой под с майнером.
Защита строится так, чтобы каждый шаг цепочки упирался в отдельную преграду. Это называется защита в глубину (defense in depth): не полагаться на один замок. На шаг 2 отвечает securityContext и PSS (не root, минимум привилегий), на шаг 3 RBAC и отключённый токен (нет токена или права минимальны), на шаг 4 NetworkPolicy (сети между подами закрыты по умолчанию), на шаг 5 всё вместе.
Принцип, который стоит за всеми тремя слоями: наименьших привилегий (least privilege). Каждому процессу и человеку давать ровно то, что нужно для работы, и ни на копейку больше. Не «на всякий случай», а «доказал, что нужно».
Осторожно, путаница: «внутри кластера безопасно, потому что снаружи закрыт файрвол». Файрвол на входе защищает от внешних, но не от атакующего, который уже внутри пода.
Прикинь сам: атакующий получил контроль над одним подом. Какие три защиты ограничат ущерб и от чего каждая?
RBAC и отсутствие токена не дадут читать секреты и создавать поды, NetworkPolicy не даст подключиться к базе и другим подам, securityContext с PSS не даст действовать от root и менять файлы приложения.
Проверь понимание: почему «снаружи кластера стоит файрвол» не заменяет эти три слоя?
Ответ
Файрвол на входе останавливает внешних. Атака через уязвимость приложения начинается уже внутри пода, и дальше ей мешают только слои самого кластера: права API (RBAC и отсутствие токена), NetworkPolicy и securityContext с PSS. Каждый закрывает свою часть цепочки.
Главное: защита в глубину ставит на каждый шаг атаки свою преграду, а принцип наименьших привилегий даёт каждому ровно то, что нужно.
Начнём с API: каждый запрос проходит там три проверки.
Путь запроса к API: три проверки подряд
Любое действие с кластером (kubectl apply, создание пода контроллером, чтение секрета из пода) это запрос к API-серверу (kube-apiserver): единственной «двери» в управление кластером. Прежде чем запрос что-то изменит, он проходит три проверки по порядку:
flowchart TD
R["запрос: «создать под X в namespace notes от имени viewer»"] --> A1["1. Аутентификация: кто ты?<br>сертификат, токен, OIDC<br>«это ServiceAccount viewer»"]
A1 -->|"нет ответа: 401 Unauthorized"| X1["отказ"]
A1 --> A2["2. Авторизация (RBAC): можно ли?<br>«viewer может create pods?»"]
A2 -->|"нет права: 403 Forbidden"| X2["отказ"]
A2 --> A3["3. Допуск (admission): а сам объект подходит по правилам?"]
A3 -->|"под нарушает Pod Security:<br>Forbidden ... violates PodSecurity"| X3["отказ"]
A3 --> E["объект сохранён в etcd (базе кластера)"]
- Аутентификация (authentication, «кто ты») проверяет личность. Для людей это сертификат или вход через внешний сервис (OIDC), для программ внутри кластера токен ServiceAccount.
- Авторизация (authorization, «что тебе можно») проверяет права. В этом уроке её выполняет RBAC.
- Допуск (admission control) проверяет уже сам объект: даже если ты имеешь право создавать поды, под с опасными настройками может быть отвергнут. Pod Security Admission как раз здесь.
Обрати внимание на разницу в кодах. 401 значит «не знаю, кто ты», 403 Forbidden значит «знаю, но тебе нельзя». Слово forbidden ты будешь видеть чаще всего. NetworkPolicy в этой цепочке не участвует: она работает не с API, а с сетевым трафиком между подами.
Прикинь сам: у тебя права администратора, но под с
privileged: trueне создаётся. Какая проверка сработала?
Третья, допуск: RBAC пропустил, а сам объект нарушает профиль Pod Security namespace.
Осторожно: 401 значит «не знаю, кто ты», 403 значит «знаю, но нельзя»; путать эти коды нельзя.
Главное: порядок такой: аутентификация (
401), авторизация RBAC (403), допуск; NetworkPolicy в этой цепочке не участвует.
Первая из проверок, где ты задаёшь правила, это RBAC.
RBAC: кто что может делать с API
RBAC (Role-Based Access Control, управление доступом по ролям) отвечает на один вопрос: «может ли субъект (subject) выполнить глагол (verb) над ресурсом (resource)». Например: «может ли ServiceAccount viewer (субъект) прочитать (глагол get) поды (ресурс)».
В RBAC нельзя написать «запрети», можно только «разреши»: всё, что не перечислено, запрещено.
Объекта в RBAC четыре, и их нельзя путать: два описывают что разрешено, два кому выдано.
| Объект | Что это | Пример |
|---|---|---|
| Role | список разрешений в одном namespace | «читать поды в notes» |
| ClusterRole | список разрешений на весь кластер (или для ресурсов вне namespace, как узлы) | «читать узлы» |
| RoleBinding | выдаёт роль субъекту в одном namespace | «ServiceAccount viewer получает роль в notes» |
| ClusterRoleBinding | выдаёт роль субъекту на весь кластер | «получает роль во всех namespace» |
Субъект (кому выдаём) бывает трёх видов: пользователь (User), группа (Group) и ServiceAccount (SA, «учётка» для программы внутри пода). Пользователей и группы Kubernetes сам не хранит: их подтверждает внешний источник (сертификат, OIDC). ServiceAccount это настоящий объект внутри кластера, создаётся командой и принадлежит namespace.
Как выглядит Role. Вот что создаёт команда kubectl create role pod-reader --verb=get,list,watch --resource=pods,pods/log, записанное в YAML:
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
name: pod-reader # имя роли
namespace: notes # роль действует только здесь
rules:
- apiGroups: [""] # "" это основная группа API (поды, сервисы, секреты)
resources: [pods, pods/log] # какие ресурсы (pods/log это логи пода)
verbs: [get, list, watch] # какие действия разрешены
Каждое правило состоит из трёх полей:
apiGroups: к какому «разделу» API относится ресурс. Пустая строка это основной раздел (поды, сервисы, секреты, ConfigMap). Деплойменты живут вapps, роли вrbac.authorization.k8s.io.resources: с чем можно работать. У пода есть «подресурсы»:pods/log(логи),pods/exec(заход внутрь). Они выдаются отдельно, поэтому право читать поды не даёт читать логи и наоборот.verbs: что делать.get(прочитать один объект),list(получить список),watch(следить за изменениями),create,update,patch,delete.
Существенная тонкость: list и get разные. Если выдать только get, kubectl get pods (список) откажет, а kubectl get pod имя сработает.
RoleBinding соединяет роль с субъектом:
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
name: viewer-pod-reader
namespace: notes
roleRef: # какую роль выдаём
apiGroup: rbac.authorization.k8s.io
kind: Role
name: pod-reader
subjects: # кому выдаём
- kind: ServiceAccount
name: viewer
namespace: notes
Разобранный пример проверки. Команда kubectl auth can-i list pods --as=system:serviceaccount:notes:viewer -n notes спрашивает у API-сервера: «может ли этот субъект получить список подов в namespace notes». --as значит «представь, что запрос отправил такой-то субъект». Имя ServiceAccount пишется в форме system:serviceaccount:<namespace>:<имя>. Ответ: yes или no. Ту же проверку для secrets получишь no: роль про них ничего не говорит, а разрешено только перечисленное.
Права складываются: если субъекту выданы две роли, он может всё из обеих. Поэтому опасны ClusterRoleBinding на встроенную роль cluster-admin (полный доступ ко всему) и звёздочка * в verbs или resources: они выдают больше, чем ожидаешь.
Есть и «тихо опасные» права: они выглядят безобидно, но фактически дают путь к полному доступу. Запомни пять:
createнаpods: можно запустить под с любым образом и смонтировать в него чужие Secret (если PSS не мешает);createнаpods/exec: можно зайти в любой под и забрать его токен и переменные окружения;getилиlistнаsecrets: чтение всех паролей namespace (подробнее ниже);escalate,bindиimpersonate: можно выдать себе больше прав или действовать от чужого имени;createнаrolebindings: можно самому привязать себе любую роль.
Проверить, что реально разрешено субъекту, можно одной командой: kubectl auth can-i --list --as=system:serviceaccount:notes:viewer -n notes печатает все его права в namespace.
Прикинь сам: у SA есть RoleBinding на роль
pod-readerв namespacedev. Может ли он читать поды вprod?
Нет: RoleBinding действует только в своём namespace. В prod нужен отдельный RoleBinding, а ClusterRoleBinding дал бы права везде.
Осторожно: ClusterRole можно привязать через обычный RoleBinding, и тогда она действует только в его namespace (частый приём: одна общая роль, много привязок).
Проверь понимание: разработчику нужно читать логи подов в
notes, но не пароли. Какие ресурсы и глаголы ты выдашь и как проверишь результат?
Ответ
Роль в notes с ресурсами pods и pods/log и глаголами get, list, watch, без secrets и без *. Проверка: kubectl auth can-i get secrets --as=... -n notes должна ответить no, а kubectl auth can-i --list покажет полный набор прав.
Главное: RBAC отвечает «может ли субъект выполнить глагол над ресурсом»; Role и ClusterRole описывают права, RoleBinding и ClusterRoleBinding выдают их, а запретов нет, только разрешения.
Субъектом бывает и программа в поде, а у неё есть свой токен.
ServiceAccount и токен в поде
У программы внутри пода тоже бывает потребность ходить в API кластера: например, оператору нужно создавать поды. Для этого у каждого пода есть ServiceAccount. Если не указать свой, используется SA с именем default данного namespace.
Как программа доказывает, что она этот SA: в файловую систему пода автоматически монтируется токен (длинная строка-пропуск) в каталог /var/run/secrets/kubernetes.io/serviceaccount/. Любой процесс в контейнере, включая злоумышленника, может прочитать его и обращаться к API с правами этого SA.
Разбор рисков: «Заметки» ходят в PostgreSQL, а не в API кластера. Токен им не нужен, значит он только лишний ключ, который могут украсть. Отключается одним полем automountServiceAccountToken: false (на SA или на поде). А чтобы у каждого приложения была своя учётная запись (ServiceAccount) с минимальными правами, для «Заметок» создают отдельный SA, а не пользуются общим default.
Прикинь сам: зачем
automountServiceAccountToken: falseприложению, которое не ходит в API?
Токен даёт доступ к API с правами SA. Приложению он не нужен, а взломщику полезен: меньше ключей у процесса, меньше ущерб.
Осторожно: SA default общий для всех подов namespace: давать ему права опасно, у каждого приложения должен быть свой SA.
Главное: без своего SA под получает
default, а токен монтируется автоматически в/var/run/secrets/kubernetes.io/serviceaccount/; ненужный токен отключают.
Токен ограничивает доступ к API, а доступ к самой системе ограничивает securityContext.
Что процесс может в контейнере: root, capabilities, seccomp
Чтобы понять, что запрещает Pod Security, нужно знать, что вообще может процесс в Linux (урок 1.3).
- root это пользователь с uid 0, которому разрешено почти всё. По умолчанию процесс в контейнере работает от root, если образ не задал другого. Это тот же uid 0, что и на хосте, только процесс заперт в контейнере и получил урезанный набор прав (capabilities), поэтому при побеге из контейнера атакующий получает root на узле. Отделить root контейнера от root хоста можно user namespaces (
hostUsers: falseв спецификации пода), но по умолчанию так не делается. Поэтому приложение запускают от обычного пользователя, например uid 10001. - Linux capabilities (возможности): привилегии root, разложенные на отдельные кусочки. Вместо «всё или ничего» процесс может иметь, скажем, право менять сетевые настройки (
NET_ADMIN) и больше ничего. Обычному приложению они не нужны, поэтому все убирают командойdrop: [ALL]. - Повышение привилегий (privilege escalation): способ получить больше прав, чем у родителя, например запуск программы с битом setuid (программа работает от имени владельца, обычно root).
allowPrivilegeEscalation: falseего запрещает. - seccomp (secure computing): фильтр системных вызовов (обращений программы к ядру: открыть файл, создать процесс, сменить время).
RuntimeDefaultвключает стандартный список запретов из рантайма контейнеров: опасные и редко нужные вызовы блокируются. - read-only файловая система: корневая ФС контейнера доступна только для чтения. Атакующий не подменит код приложения и не положит скрипт в системные каталоги.
Все эти настройки задаются полем securityContext в манифесте. Оно бывает на двух уровнях: на уровне пода (общие для всех контейнеров: runAsUser, runAsNonRoot, fsGroup, seccompProfile) и на уровне контейнера (readOnlyRootFilesystem, allowPrivilegeEscalation, capabilities). Что означает каждое поле:
runAsNonRoot: trueиrunAsUser: 10001: процесс не root, и это тот uid, который мы задали в образе (урок 4.2).runAsNonRootэто страховка: Kubernetes откажется запускать, если образ всё же от root.fsGroup: группа, которой принадлежат смонтированные тома, чтобы процесс с этим gid мог в них писать (нужно Postgres).readOnlyRootFilesystem: true: корень только для чтения. Куда приложению всё же нужно писать, монтируютemptyDir(временный каталог, живущий, пока жив под), например в/tmp.allowPrivilegeEscalation: false,capabilities.drop: [ALL],seccompProfile: RuntimeDefault: как описано выше.
Осторожно, путаница: «read-only ФС ломает приложение». Не ломает, если знать, куда оно пишет: временные файлы и кэши выводят на emptyDir, а корень остаётся защищённым. Данные «Заметок» хранятся в PostgreSQL, а не в файлах, поэтому корневую файловую систему можно сделать read-only.
Прикинь сам: зачем
emptyDirв/tmp, если корневая файловая система только для чтения?
Многие программы пишут временные файлы. На read-only корне запись падает с Read-only file system, а emptyDir это отдельный записываемый том, и ограничение остаётся на остальном образе.
Главное: restricted-контейнер запускают не от root, с
allowPrivilegeEscalation: false,drop: [ALL],seccompProfile: RuntimeDefaultи read-only корнем.
Чтобы эти поля нельзя было забыть, их требует Pod Security Standards.
Pod Security Standards: три профиля и режимы проверки
Писать securityContext в каждом манифесте можно и забыть. Нужен способ заставить: «в этом namespace под без защитных настроек не создаётся». Для этого есть Pod Security Standards (PSS): три готовых профиля требований.
| Профиль | Что разрешает |
|---|---|
privileged |
всё, без ограничений (нужен системным компонентам вроде сетевого плагина) |
baseline |
запрещает заведомо опасное: privileged: true (контейнер с правами хоста), hostNetwork, hostPath (доступ к файлам узла), лишние capabilities |
restricted |
требует лучших практик: не root, allowPrivilegeEscalation: false, capabilities.drop: [ALL], seccompProfile: RuntimeDefault |
Применяет профили встроенный контроллер допуска Pod Security Admission (PSA): та самая «третья проверка» из схемы выше. Включается он меткой на namespace в одном из трёх режимов:
enforce: под, нарушающий профиль, не создаётся (жёсткий запрет);warn: под создаётся, ноkubectlпечатает предупреждение;audit: нарушение записывается в журнал аудита API-сервера, пользователь ничего не видит.
Метка выглядит так: pod-security.kubernetes.io/enforce: restricted. Первая часть до / это «домен» метки, вторая enforce режим, значение restricted профиль.
Вместе с меткой режима можно закрепить версию правил: pod-security.kubernetes.io/enforce-version: v1.36. Без неё действует latest, то есть правила текущей версии Kubernetes, и после обновления кластера требования профиля могут измениться. Закреплённая версия делает проверку предсказуемой (v1.36 соответствует кластеру kind из урока 5.1, для другой версии подставь свою). Эту метку мы поставим в задании 4.
Важная деталь: PSA проверяет только создание и изменение подов. Уже работающие поды не убиваются. Проблема вскроется при следующем создании пода (рестарт, выкатка, эвакуация узла). Отсюда безопасная последовательность для живого namespace:
- Включить
warnиaudit, ничего не ломая. - Посмотреть предупреждения, исправить манифесты (Deployment, StatefulSet, CronJob, всё, что создаёт поды).
- Только после этого включить
enforce.
Разобранный пример. Postgres из урока 5.5 запущен от root. Ты включаешь enforce: restricted. Сразу ничего не произойдёт, под продолжает работать. Ночью узел перезагрузили, StatefulSet пытается пересоздать под: допуск отвечает violates PodSecurity "restricted:latest", и база не поднимается. Именно для этого сначала warn.
Осторожно, путаница: PSS с устаревшей PodSecurityPolicy (её убрали в Kubernetes 1.25); PSS не заменяет securityContext, а проверяет, что он написан.
Прикинь сам: ты включил
enforce: restrictedна namespace с работающим Postgres от root. Что будет с подом сразу и при пересоздании?
Сразу ничего: работающий под остаётся. При пересоздании допуск ответит violates PodSecurity "restricted:latest", и база не поднимется. Поэтому сначала warn.
Проверь понимание: в чём разница между
warnиauditи в каком порядке включать режимы на живом namespace?
Ответ
warn показывает предупреждение тому, кто применяет манифест (kubectl печатает его сразу), а audit пишет нарушение в журнал аудита API-сервера, пользователь ничего не видит. На живом namespace сначала warn и audit, потом исправление манифестов, и только в конце enforce.
Главное: профили
privileged,baseline,restrictedвключаются меткой на namespace в режимеenforce,warnилиaudit; включайwarnиaudit, потомenforce.
От привилегий подов перейдём к сети между ними.
NetworkPolicy: сетевой фаервол между подами
В обычной сети кластера каждый под может открыть соединение с любым другим подом, в любом namespace (урок 5.3). NetworkPolicy это объект, который это ограничивает: описывает, какой трафик разрешён к подам (ingress, входящий) и от подов (egress, исходящий).
flowchart LR
subgraph B["без политик (плоская сеть): все со всеми"]
F1["frontend"] --- N1["notes"] --- P1["postgres"]
F1 --- P1
L1["любой под"] --- N1
L1 --- P1
end
subgraph C["с default deny и разрешениями: только нужные стрелки"]
F2["frontend"] -.-x N2["notes"]
G2["gateway"] --> N2 --> P2["postgres"]
end
Как читать политику. Политика состоит из трёх частей: кого защищаем (podSelector: выбор подов по меткам), в какую сторону (policyTypes: [Ingress, Egress]) и что разрешено (списки ingress и egress). Правила механики:
- Политика выбирает поды через
podSelector. ПустойpodSelector: {}выбирает все поды namespace. - Поды, которые не выбраны ни одной политикой, открыты для всего трафика.
- Как только под выбран политикой типа
Ingress, входящим разрешено только то, что перечислено. ДляEgressто же самое с исходящим. - Разрешения складываются: если две политики выбрали один под, разрешено объединение. Запретов внутри политики нет, «запрет» это отсутствие разрешения при выбранном поде.
- Источники и цели задаются тремя способами:
podSelector(по меткам подов),namespaceSelector(по меткам namespace),ipBlock(по диапазону адресов).
Стандартный приём: default deny (запретить всё по умолчанию) и потом явные разрешения. Политика с podSelector: {} и policyTypes: [Ingress, Egress] без единого правила выбирает все поды и ничего им не разрешает.
Не забудь DNS. После запрета egress под не сможет разрешить даже имя db, потому что запрос к CoreDNS (это DNS-сервер кластера в namespace kube-system, порт 53, UDP и TCP) тоже блокируется. Признак: по IP-адресу работает, по имени нет.
Что делает политику рабочей. Политики применяет не API-сервер, а сетевой плагин (CNI, Container Network Interface: компонент, который создаёт сеть между подами). Если плагин их не поддерживает, манифест примется без ошибок и ничего не изменится. Поэтому политику всегда проверяют тестом: запретил и убедился, что трафик реально пропал.
Ещё одно следствие: заблокированный пакет не отвергается, а молча отбрасывается. Клиент видит не «connection refused» (отказ соединения), а таймаут (тишина, пока не сдастся). Это отличает NetworkPolicy от закрытого порта.
Разобранный пример на «Заметках». Разрешаем в Postgres пускать только поды с метками notes и pg-backup:
spec:
podSelector: # кого защищаем: поды postgres
matchLabels:
app.kubernetes.io/name: postgres
policyTypes: [Ingress] # регулируем входящий трафик
ingress:
- from:
- podSelector: # откуда пускаем: поды с такими метками
matchExpressions:
- {key: app.kubernetes.io/name, operator: In, values: [notes, pg-backup]}
ports:
- {protocol: TCP, port: 5432} # и только на этот порт
Читается так: «поды postgres принимают входящие соединения только на порт 5432 и только от подов с меткой app.kubernetes.io/name равной notes или pg-backup». Под nettest с другой меткой упрётся в таймаут.
Прикинь сам: под выбран политикой
Ingress, которая разрешает трафик от подов с меткойnotes. Достучится ли под с меткойotherиз того же namespace?
Нет: как только под выбран политикой, разрешено только перечисленное. Остальное молча отбрасывается, клиент видит таймаут, а не отказ.
Осторожно: пакеты, закрытые NetworkPolicy, не отвергаются, а пропадают: клиент видит таймаут, а не «connection refused».
Главное: политика выбирает поды, а разрешения складываются; после default deny не забудь разрешить DNS, а работает политика только при поддержке сетевого плагина.
Политика находит свои поды по меткам, это надо понимать точно.
Метки и селекторы: как политика находит «свои» поды
Политика, правило или Service должны указывать на конкретные поды. Но поды создаются и умирают, их имена и адреса случайны и меняются (notes-7d9f8-x2k4p). Привязаться к имени нельзя. Нужен способ выбрать «всех, у кого такая-то бирка».
Метка работает как роль, а не как проверка личности: политика пускает всех, у кого есть нужная метка. Метку может поставить на свой под любой, у кого есть право создавать поды, поэтому метки не защищают от взломщика с такими правами, они защищают от случайных соединений.
Метка (label) это пара «ключ: значение» на объекте, например app.kubernetes.io/name: notes. Селектор (selector) это условие отбора по меткам. Самые частые формы:
matchLabels: «метка такая-то равна такому-то значению»;matchExpressionsс операторомIn: «значение метки входит в список»;- пустой
{}: «подходят все».
Политика, Service и Deployment используют одни и те же метки, поэтому во всём курсе подам «Заметок» приклеена одна и та же: app.kubernetes.io/name: notes.
Правило allow-db-from-app выбирает защищаемые поды так: podSelector.matchLabels: app.kubernetes.io/name: postgres. Значит, оно действует на поды с этой меткой и больше ни на чьи. А в блоке from стоит второй селектор: In [notes, pg-backup], то есть «пускать поды, у которых app.kubernetes.io/name равна notes или pg-backup». Под nettest без такой метки не подходит ни под одно условие и остаётся без доступа.
Прикинь сам: в политике
matchLabels: app.kubernetes.io/name: notes, а у подов меткаnotes-app. Что произойдёт?
Политика не выберет ни одного пода и не будет на них действовать. Ошибки не будет: пустой отбор не ошибка. Метки подов и политики сверяй глазами.
Осторожно: не думай, что политика привязана к имени Deployment. Нет, только к меткам подов. Поменяешь метку в шаблоне пода, а в политике оставишь старую: политика перестанет выбирать эти поды, и защита исчезнет без единой ошибки. Проверка простая: kubectl -n notes get pods --show-labels и сравнить с политикой глазами.
Главное: метка это пара «ключ: значение», селектор отбирает по меткам (
matchLabels,matchExpressions, пустой{}), а привязка идёт к меткам, а не к именам.
С тремя слоями понятно, теперь научимся различать, какой из них остановил запрос.
Какой слой остановил: быстрая диагностика
Три слоя (RBAC, Pod Security, NetworkPolicy) ломают работу по-разному. Без привычки различать их легко полчаса править не то.
Симптомы бывают смешанными: тогда проверяй слои по очереди, а не гадай.
Определяй слой по тексту ошибки и по тому, когда она появилась:
| Что видишь | Какой слой | Где смотреть |
|---|---|---|
Error from server (Forbidden): ... cannot list resource "pods" |
RBAC (авторизация) | kubectl auth can-i ... --as=..., Role и RoleBinding |
Forbidden: violates PodSecurity "restricted:latest" при создании пода или в events ReplicaSet |
Допуск (Pod Security) | kubectl describe replicaset, метки namespace, securityContext |
Таймаут (curl висит, код выхода 28) при том, что приложение живое |
NetworkPolicy | kubectl get networkpolicy, метки подов и политик |
Read-only file system в логе приложения |
readOnlyRootFilesystem (securityContext) |
куда пишет приложение, нужен emptyDir |
Unauthorized (401) |
Аутентификация | kubeconfig, срок токена |
После выкатки чарта 0.2.0 под не создаётся, kubectl rollout status ждёт. Подов в списке нет. Смотришь kubectl -n notes describe replicaset -l app.kubernetes.io/name=notes: в events строка violates PodSecurity. Значит, сработал допуск: в шаблоне пода не хватает поля из профиля restricted. RBAC и сеть здесь ни при чём, и править их бесполезно.
Осторожно, путаница: таймаут приписывают «сломанному приложению» или DNS. Отказ с текстом (Forbidden, Read-only file system) приходит от слоёв, которые его явно говорят. А NetworkPolicy ничего не говорит: пакеты тихо отбрасываются, клиент видит только тишину и таймаут.
Прикинь сам: запрос из соседнего пода висит 3 секунды и обрывается кодом 28, в логах приложения пусто. Какой слой подозреваешь первым?
NetworkPolicy: пакеты отброшены до приложения, поэтому в его логах ничего нет. Проверь kubectl get networkpolicy и совпадение меток.
Главное:
Forbidden ... cannot listэто RBAC,violates PodSecurityдопуск, таймаут NetworkPolicy,Read-only file systemsecurityContext,401аутентификация.
Отдельно стоит разобрать, почему секреты требуют особой осторожности.
Secret и RBAC: почему «читать секреты» опаснее, чем кажется
В уроке 5.6 ты узнал, что Secret это лишь base64, а не шифрование. Защищает его не сам формат, а то, кто имеет право его читать. Здесь RBAC и Secret встречаются.
Шифрование Secret в etcd включается отдельной настройкой, но оно не заменяет RBAC: значения читает тот, у кого есть право на get или list.
У Secret те же глаголы, что у любого ресурса: get (прочитать один по имени), list (получить список, и в списке значения тоже видны), watch. Поэтому право list на secrets в namespace равно праву прочитать все пароли этого namespace, хотя звучит безобидно. Роль для обычного разработчика в namespace не должна включать secrets, если только ему это не нужно по работе.
Роль viewer из задания 1 разрешает get, list, watch на pods. Если по ошибке добавить в resources слово secrets, то kubectl auth can-i get secrets --as=system:serviceaccount:notes:viewer -n notes ответит yes, и этот SA прочитает notes-db с паролем базы. Поэтому в ролях ресурсы перечисляют явно и по одному, а не *.
Прикинь сам: почему право
listнаsecretsопасно, хотяgetникто не давал?
list возвращает объекты Secret целиком со значениями: кто получил список, получил и все пароли, не зная их имён.
Осторожно: не думай, что «Secret зашифрован, значит можно дать доступ всем». Base64 снимается одной командой, и читающий получает пароль в открытом виде.
Главное: Secret защищён не форматом, а RBAC: ресурсы в ролях перечисляй явно, без
*, а правоlistнаsecretsравно праву читать все пароли namespace.
Права привязаны к namespace, и важно понимать, что граница namespace закрывает, а что нет.
Namespace как граница: что она ограничивает, а что нет
Один кластер обычно делят между командами и средами. Нужны «комнаты», внутри которых у каждого свои права и правила. Namespace (пространство имён, урок 5.2) и есть такая комната.
Namespace ограничивает права и имена, но не сеть: без NetworkPolicy поды разных namespace свободно ходят друг к другу.
Граница namespace работает по-разному для каждого слоя:
- RBAC:
RoleиRoleBindingдействуют только внутри своего namespace. Чтобы права действовали на весь кластер, нужныClusterRoleиClusterRoleBinding. - Pod Security: метка
pod-security.kubernetes.io/enforceставится на namespace и действует на все поды внутри него. В соседнем namespace без метки действуют другие правила. - NetworkPolicy: политика лежит в одном namespace и выбирает только его поды. А вот трафик она может разрешать и для других namespace (через
namespaceSelector). - Сеть без политик: никакой границы нет. Под из
defaultоткрывает соединение с подом изnotesпо имениnotes.notes.svc, как в уроке 5.3.
У тебя есть viewer с RoleBinding в namespace notes. Он читает поды в notes, но на kubectl -n default get pods --as=system:serviceaccount:notes:viewer получит Forbidden: в default ему ничего не выдавали. При этом из пода в default можно достучаться до notes.notes.svc:8080, пока не введена политика. Поэтому в задании 3 тест делается из default: так видно, что политика реально закрыла доступ.
Осторожно, путаница: «Раз у меня отдельный namespace, меня никто не трогает». Namespace изолирует имена и права, но не сеть. Изоляцию сети даёт только NetworkPolicy.
Прикинь сам: у SA в
notesесть RoleBinding на чтение подов. Сможет ли он читать поды вdefault?
Нет: RoleBinding действует только в своём namespace. Для default нужен отдельный RoleBinding или ClusterRoleBinding.
Главное: namespace ограничивает права RBAC, действует как область метки Pod Security, но сеть не изолирует: это делает только NetworkPolicy.
Теперь сложим всё вместе на примере одной атаки.
Все слои вместе: разбор одной атаки
Пока каждый слой описан по отдельности, трудно увидеть, зачем их три. Пройдём ту же цепочку из начала урока: дыра в приложении, и каждый шаг атакующего упирается в свою преграду.
Защита в глубину не делает взлом невозможным, она делает его дорогим и заметным.
Возьми пять шагов атаки из начала урока и сопоставь с защитой:
| Шаг атакующего | Что мешает в защищённой «Заметки» |
|---|---|
| 1. Выполнить команды в поде через дыру | Дыру не закрывает ни один из слоёв: её закрывают обновления и код |
| 2. Поменять файлы, поставить утилиты | readOnlyRootFilesystem и запуск не от root: писать некуда, прав нет |
| 3. Взять токен и ходить в API | automountServiceAccountToken: false: токена в поде нет |
| 4. Открыть соединение с другим подом | NetworkPolicy: из пода notes можно только в postgres:5432 |
| 5. Запустить свой под с майнером | Без токена нельзя обратиться к API, а при наличии токена PSS restricted отклонит под с лишними привилегиями |
Допустим, атакующий всё же добрался до пода и попробовал curl к API без токена: запрос пошёл как анонимный, и вместо данных он получил 403 (401 было бы при отключённой анонимной аутентификации). Попробовал подключиться к другому сервису в соседнем namespace: таймаут. Попробовал записать файл в /usr/bin: Read-only file system. Единственное, что ему осталось, это доступ к базе с правами приложения, то есть ровно то, что приложение и так делает. Ущерб ограничен тем, что было необходимо приложению.
Прикинь сам: атака дошла до шага 4 и упёрлась. Какой слой сработал и что видит атакующий?
NetworkPolicy: соединение с неразрешённым подом не устанавливается, атакующий видит таймаут, а не сообщение об отказе.
Осторожно: не думай, что одного слоя достаточно. Если убрать NetworkPolicy, атакующий пойдёт по сети. Если убрать отключение токена, пойдёт в API. Каждый слой закрывает свой шаг цепочки, поэтому нужны все.
Главное: слои закрывают разные шаги цепочки, поэтому нужны все; защита в глубину делает взлом дорогим и заметным, но не невозможным.
Остаётся честно понять, чего эти слои не решают.
Чего эти три слоя не решают
Чтобы не создавать ложное чувство безопасности, полезно знать границы:
- Secret это base64, а не шифрование. RBAC решает, кто может его прочитать, но в самой базе кластера (etcd) он по умолчанию хранится открыто, шифрование включается отдельно (тема 9).
- Уязвимости в образе (старая библиотека) эти слои не исправляют: за это отвечают сканирование и сборка образов (урок 4.8).
- NetworkPolicy не шифрует трафик, а лишь решает, кто может подключиться.
- Эти слои не проверяют, какой образ ты запускаешь и откуда он. Такие правила (только образы из своего реестра, запрет тега
latest, обязательные лимиты) пишут отдельными политиками допуска: для этого ставят Kyverno или Gatekeeper, в курсе мы их не разбираем.
Образы отдельно. Чтобы снизить риски, связанные с образами контейнеров, делают четыре вещи: сканируют образ на известные уязвимости (например, Trivy) до выкладки; закрепляют образ по digest (image@sha256:...), чтобы тег нельзя было подменить; берут образы только из доверенного реестра; запрещают остальные admission-политиками. Сборку и сканирование мы разбирали в уроке 4.8.
Прикинь сам: NetworkPolicy есть, а трафик между подами идёт открытым текстом. Это ошибка политики?
Нет: политика решает, кто может подключиться, а шифрованием не занимается. Для шифрования нужны TLS или сервисная сетка.
Осторожно: три слоя не заменяют закрытие дыр в коде и образах и не шифруют данные.
Главное: слои не исправляют уязвимости образов, не шифруют Secret в etcd и не шифруют трафик: у каждой из этих проблем свои инструменты.
Теперь пора применить всё на практике, начиная с RBAC.
Практика
Кластер kind notes из урока 5.1 запущен, контекст kind-notes, релиз notes из урока 5.9 работает в namespace notes, чарт helm/notes версии 0.1.1 (после урока 5.11). Версии Kubernetes и kind не закреплены курсом жёстко, проверь актуальные значения на страницах проектов.
Задание 1. RBAC: выдай минимум и проверь
Цель: создать ServiceAccount, выдать ему право только читать поды в notes и проверить границы командой can-i.
Предскажи:
- Сможет ли новый SA сразу после создания читать поды?
- После выдачи роли
get pods, сможет ли он читать секреты и удалять поды?
Ответ
- Нет, у нового SA нет прав кроме базовых (discovery). 2. Читать поды сможет, секреты и удаление нет: RBAC разрешает только перечисленное.
Шаги:
- Создай SA, Role и RoleBinding. Разбор:
create serviceaccount viewerсоздаёт учётку;create role pod-reader --verb=... --resource=...создаёт роль (--verbперечисляет глаголы,--resourceресурсы через запятую);create rolebindingпривязывает роль к субъекту:--roleкакую роль,--serviceaccount=notes:viewerкакого SA в формате<namespace>:<имя>. Флаг-n notesзадаёт namespace,\в конце строки переносит команду:
# ServiceAccount для «наблюдателя»
kubectl -n notes create serviceaccount viewer
# Роль: только чтение подов и их логов
kubectl -n notes create role pod-reader \
--verb=get,list,watch --resource=pods,pods/log
# Привязка роли к SA
kubectl -n notes create rolebinding viewer-pod-reader \
--role=pod-reader --serviceaccount=notes:viewer
- Проверь права до и после границы.
SA=...записывает полное имя субъекта в переменную оболочки,$SAподставляет её,--asговорит «выполни проверку от имени этого субъекта»:
SA=system:serviceaccount:notes:viewer
kubectl -n notes auth can-i list pods --as=$SA
kubectl -n notes auth can-i get secrets --as=$SA
kubectl -n notes auth can-i delete pods --as=$SA
kubectl -n default auth can-i list pods --as=$SA
Что должно получиться:
yes
no
no
no
Выводы команд к кластеру в этом уроке даны в «примерном формате»: кластер при подготовке урока не запускался, ориентируйся на смысл строк, а не на буквальное совпадение.
Как читать вывод: каждая команда даёт один ответ. Первая yes: право выдано. Вторая и третья no: роль не перечисляет secrets и глагол delete. Четвёртая no: RoleBinding действует только в notes, а проверка идёт в default.
Объясни себе:
- Почему четвёртая проверка (
default) вернулаno, хотя роль выдана? - Почему для
pods/logв роли отдельная запись ресурса? - Что опаснее:
get secretsна весь namespace илиdelete pods? Почему?
Типичные ошибки:
Error from server (Forbidden): pods is forbidden: User "..." cannot list resource "pods": нет привязки или она в другом namespace: проверьkubectl -n notes get rolebinding.error: serviceaccount must be <namespace>:<name>: в--serviceaccountзабыт namespace: пишиnotes:viewer.auth can-iдаётyesдля всего: ты запустил его от своего админа без--as.
Задание 2. Pod Security: warn, потом enforce
Цель: увидеть, что restricted требует от пода, и не сломать работающий namespace.
Предскажи: ты включаешь warn: restricted на notes с работающим релизом. Что напечатает kubectl и что случится с подами?
Ответ
kubectl напечатает предупреждения would violate PodSecurity "restricted:latest" со списком нарушенных полей. Поды продолжат работать: warn ничего не блокирует.
Шаги:
- Включи
warnиaudit(не блокирующие режимы).kubectl label namespace notes ключ=значениеставит метки на namespace,--overwriteразрешает заменить уже существующую:
kubectl label namespace notes \
pod-security.kubernetes.io/warn=restricted \
pod-security.kubernetes.io/audit=restricted --overwrite
- Проверь предупреждения без изменения кластера.
--dry-run=serverотправляет запрос на сервер, проходит настоящую проверку допуска, но объект не сохраняется.kubectl patchменяет объект частично:-pзадаёт изменение, здесь это безобидная аннотация в шаблоне пода. Патч нужен только для проверки: из-за--dry-run=serverничего не сохранится (уkubectl rollout restartфлага--dry-runнет, поэтому берёмpatch):
kubectl -n notes patch deployment notes --dry-run=server -p '{"spec":{"template":{"metadata":{"annotations":{"check":"psa"}}}}}'
Вывод заканчивается строкой deployment.apps/notes patched (server dry run), а перед ней идёт Warning: would violate PodSecurity .... Предупреждение появится, пока в шаблоне пода нет securityContext (до задания 4). Если ты уже добавил securityContext, предупреждения не будет: шаг 3 всё равно покажет полный список.
- Попробуй создать заведомо плохой под, чтобы увидеть полный список нарушений.
kubectl run bad --image=nginx:1.29создаёт одиночный под,--restart=Neverзначит «не перезапускай»:
kubectl -n notes run bad --image=nginx:1.29 --restart=Never --dry-run=server
Что должно получиться:
Warning: would violate PodSecurity "restricted:latest": allowPrivilegeEscalation != false (container "bad" must set securityContext.allowPrivilegeEscalation=false), unrestricted capabilities (container "bad" must set securityContext.capabilities.drop=["ALL"]), runAsNonRoot != true (pod or container "bad" must set securityContext.runAsNonRoot=true), seccompProfile (pod or container "bad" must set securityContext.seccompProfile.type to "RuntimeDefault" or "Localhost")
pod/bad created (server dry run)
Как читать вывод:
Warning: would violate ...это предупреждение (не ошибка): «нарушил бы профильrestricted».- После двоеточия четыре пункта, по одному на нарушенное требование:
allowPrivilegeEscalation,capabilities.drop,runAsNonRoot,seccompProfile. В скобках написано, какое именно поле и куда добавить. pod/bad created (server dry run): под «создался» только понарошку (dry run), потому что режимwarnне блокирует.
Объясни себе:
- Почему под
badсоздался, несмотря на нарушения? - Что в выводе подсказывает, какие четыре поля надо добавить?
- Какие поды в
notes(приложение, Postgres, CronJob) придётся править доenforce?
Типичные ошибки:
Error from server (Forbidden): ... violates PodSecurity "restricted:latest": у тебя уже стоитenforce, а под не соответствует: добавь недостающие поля или временно верниwarn.error: unknown flag: --dry-run: эта подкоманда kubectl не умеет dry-run (так отвечаетrollout restart). Используйpatch,applyилиrunс--dry-run=server.
Задание 3. NetworkPolicy: default deny и проверка, что CNI её выполняет
Цель: убедиться, что политики в твоём kind реально работают, и запретить весь трафик в notes, кроме нужного.
Предскажи: в namespace notes применена политика default-deny (ingress и egress для всех подов). Ответит ли приложение на curl из тестового пода? Разрешит ли тестовый под из default имя db.notes.svc?
Ответ
На curl нет: входящий трафик к подам notes закрыт default-deny, curl завершится по таймауту (000, код 28). Имя разрешится: тестовый под живёт в default, где политик нет, а CoreDNS в kube-system политиками notes не закрыт. DNS пропал бы у подов внутри notes, если бы в namespace не было allow-dns.
Перед шагами посмотри, какой сетевой плагин стоит в кластере: kubectl -n kube-system get pods -o name | grep -E 'kindnet|calico|cilium'. Если видишь kindnet, проверка curl после применения политики покажет, выполняет ли он политики; если calico или cilium, выполняет точно.
Шаги:
- Создай тестовый под вне
notes(вdefaultполитик нет) и убедись, что связь есть. Разбор:--command -- sleep 3600запускает в поде командуsleep 3600(спать час), чтобы под не завершился;wait --for=condition=Readyждёт готовности;exec nettest -- curl ...выполняет команду внутри пода; вcurl-sбез прогресс-бара,-m 3не дольше 3 секунд,-o /dev/nullвыбросить тело ответа,-w '%{http_code}\n'напечатать только код ответа:
kubectl -n default run nettest --image=curlimages/curl:8.14.1 --restart=Never \
--command -- sleep 3600
kubectl -n default wait --for=condition=Ready pod/nettest --timeout=60s
kubectl -n default exec nettest -- curl -s -m 3 -o /dev/null -w '%{http_code}\n' http://notes.notes.svc:8080/healthz
- Файл
k8s/base/70-netpol-default-deny.yaml: запрет всего плюс минимум разрешений (DNS, приложение и бэкап к базе, в базу только они):
# Запрещаем весь входящий и исходящий трафик в namespace notes
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: default-deny
namespace: notes
spec:
podSelector: {} # пустой селектор: все поды namespace
policyTypes: [Ingress, Egress] # ни одного правила: не разрешено ничего
---
# Разрешаем всем подам ходить в DNS кластера
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: allow-dns
namespace: notes
spec:
podSelector: {}
policyTypes: [Egress]
egress:
- to:
- namespaceSelector: # куда: в namespace с такой меткой (kube-system, там CoreDNS)
matchLabels:
kubernetes.io/metadata.name: kube-system
ports:
- {protocol: UDP, port: 53} # DNS чаще идёт по UDP,
- {protocol: TCP, port: 53} # а длинные ответы по TCP
---
# В Postgres пускаем только приложение и бэкап (входящий)
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: allow-db-from-app
namespace: notes
spec:
podSelector:
matchLabels:
app.kubernetes.io/name: postgres
policyTypes: [Ingress]
ingress:
- from:
- podSelector:
matchExpressions:
- {key: app.kubernetes.io/name, operator: In, values: [notes, pg-backup]}
ports:
- {protocol: TCP, port: 5432}
---
# Бэкапу разрешаем исходящие соединения только к Postgres
# (политику для самого приложения отдаём чарту в задании 4)
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: allow-backup-to-db
namespace: notes
spec:
podSelector:
matchLabels:
app.kubernetes.io/name: pg-backup
policyTypes: [Egress]
egress:
- to:
- podSelector:
matchLabels:
app.kubernetes.io/name: postgres
ports:
- {protocol: TCP, port: 5432}
Обрати внимание: нужны обе стороны. Чтобы клиент поговорил с базой, ему нужно разрешение на исходящее, а базе на входящее (allow-db-from-app). Для бэкапа исходящее разрешает allow-backup-to-db, для приложения его даст политика чарта в задании 4. Поэтому здесь в base только то, что не зависит от чарта, и пересечений между base и чартом нет: до выката чарта приложение ходить в базу не сможет. Метки app.kubernetes.io/name: notes и app.kubernetes.io/name: postgres заданы в уроках 5.3 и 5.5, для pg-backup метку мы добавим в задании 4. Если у тебя метки другие, подставь свои.
- Применяй и проверь снова:
kubectl apply -f k8s/base/70-netpol-default-deny.yaml
kubectl -n default exec nettest -- curl -s -m 3 -o /dev/null -w '%{http_code}\n' http://notes.notes.svc:8080/healthz
Что должно получиться: до политики код 200, после таймаут:
200
000
command terminated with exit code 28
Как читать вывод:
200: приложение ответило (до политики).000:curlне получил ответа вовсе, поэтому код HTTP «нулевой».command terminated with exit code 28:kubectl execсообщает, чтоcurlзавершился с кодом 28, это его код «превышено время ожидания» (тот самый-m 3). НеConnection refused, а именно тишина: пакеты отброшены.
Пока действует default-deny, входящий трафик к «Заметкам» закрыт для всех, включая Gateway: сайт notes.lab на время задания перестанет отвечать. В задании 4 чарт вернёт нужные проходы.
Эта проверка и есть главный результат задания: она показывает, режет ли твой кластер трафик по политике. Если и после политики пришло 200, сначала проверь, что политика применилась (kubectl -n notes get networkpolicy), что она в namespace notes и что метки подов совпадают. Если всё совпадает, значит сетевой плагин не выполняет NetworkPolicy. CNI (Container Network Interface) это сетевой плагин кластера: он даёт подам адреса и применяет политики. Стандартный плагин kind, kindnet, в новых версиях kind политики выполняет, но я это не проверял на твоей версии: поэтому в задании есть проверка curl до и после политики. Её результат важнее моих слов.
Запасной путь на случай, если плагин политики не выполняет (для опытных пользователей kind): пересоздай кластер с отключённым kindnet и поставь Calico. Все объекты из уроков 5.1-5.11 придётся применить заново, это примерно тот же путь, что в уроке 5.1. Сначала добавь на верхний уровень kind/kind.yaml блок:
networking:
disableDefaultCNI: true # не ставить kindnet, сеть поставим сами
Затем пересоздай кластер и поставь Calico закреплённой версии (узлы будут NotReady, пока Calico не запустится, это нормально):
kind delete cluster --name notes
kind create cluster --config kind/kind.yaml
kubectl apply -f https://raw.githubusercontent.com/projectcalico/calico/v3.30.0/manifests/calico.yaml
kubectl -n kube-system rollout status daemonset/calico-node --timeout=180s
После этого повтори проверку из шага 3.
Объясни себе:
- Почему таймаут, а не «connection refused»?
- Что случится с Postgres, если убрать
allow-db-from-appи оставитьdefault-deny? - Почему
allow-dnsнужен именно как egress и на namespacekube-system?
Типичные ошибки:
curl: (28) Resolving timed out after 3000 milliseconds: для пода внутриnotesбезallow-dnsDNS заблокирован egress-политикой: добавьallow-dns. Тестовый под изdefaultтак не ответит.error validating data: ... unknown field "namespaceSelectors": опечатка в имени поля: правильноnamespaceSelector.- Политика применилась, но трафик проходит: политика не выбрала поды (метки, namespace) или CNI не поддерживает NetworkPolicy (для kindnet в новом kind это редкость, но проверь результатом
curl), см. запасной путь выше.
Задание 4. Шаг проекта: чарт 0.2.0 с безопасностью
Шаблоны политик собери по образцу, но разрешения проверь для своей схемы связей. Для каждого правила назови, кто к кому получает доступ и зачем; это нужно подтвердить разрешённым и запрещённым запросом из практики. Запоминать все поля API не требуется, а просто получить успешный helm upgrade для проверки безопасности недостаточно.
Цель: привести чарт helm/notes к профилю restricted, отдать приложению собственный ServiceAccount без токена и разрешить только нужный входящий трафик.
Предскажи: после включения enforce: restricted и обновления чарта под будет создан без /tmp-тома. Что упадёт: сам под или запрос?
Ответ
Скорее всего ничего: «Заметки» с PostgreSQL на диск не пишут, поэтому под создастся и заработает. Допуск (PSA) не проверяет, куда пишет процесс, он проверяет только поля манифеста. Если бы приложение писало в /tmp, ошибка Read-only file system появилась бы позже, в рантайме. emptyDir в /tmp мы добавляем заранее, как страховку.
Шаги:
- Обнови
k8s/base/00-namespace.yaml:
apiVersion: v1
kind: Namespace
metadata:
name: notes
labels:
# Пода, нарушающего профиль restricted, в namespace не будет
pod-security.kubernetes.io/enforce: restricted
pod-security.kubernetes.io/enforce-version: v1.36 # правила профиля версии 1.36, как в кластере kind из 5.1
pod-security.kubernetes.io/warn: restricted
- Postgres от root под
restrictedне пройдёт. Вk8s/base/40-postgres.yamlдобавь в шаблон пода (вspec.template.spec, образpostgres:18умеет работать от uid 999). Разбор:runAsUser: 999запуск от пользователяpostgres(uid 999 в образе),fsGroup: 999делает том с данными доступным для группы 999, остальное требования профиля:
securityContext:
runAsNonRoot: true
runAsUser: 999
runAsGroup: 999
fsGroup: 999
seccompProfile: {type: RuntimeDefault}
containers:
- name: postgres
securityContext:
allowPrivilegeEscalation: false
capabilities: {drop: [ALL]}
Так же поправь CronJob pg-backup в 60-pg-backup-cronjob.yaml: без этого следующий запуск бэкапа упрётся в violates PodSecurity. В шаблон пода (jobTemplate.spec.template) добавь метку (по ней её пускает allow-db-from-app) и те же поля, а контейнеру pg-dump ограничения:
template:
metadata:
labels:
app.kubernetes.io/name: pg-backup # по этой метке пускает NetworkPolicy
spec:
securityContext:
runAsNonRoot: true
runAsUser: 999
runAsGroup: 999
fsGroup: 999 # том pg-backups станет доступен на запись
seccompProfile: {type: RuntimeDefault}
containers:
- name: pg-dump
securityContext:
allowPrivilegeEscalation: false
capabilities: {drop: [ALL]}
- Файл
helm/notes/templates/serviceaccount.yaml. Разбор:{{ .Release.Name }}подставляет имя релиза (notes), аautomountServiceAccountToken: falseотключает монтирование токена:
# ServiceAccount приложения: токен API «Заметкам» не нужен
apiVersion: v1
kind: ServiceAccount
metadata:
name: {{ .Release.Name }}
automountServiceAccountToken: false
- Файл
helm/notes/templates/networkpolicy.yaml. Он разрешает внутрь приложения только прокси Gateway и порт 8080, а наружу только Postgres:
{{- if .Values.networkPolicy.enabled }}
# Внутрь приложения пускаем только прокси Gateway, наружу только в БД
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: {{ .Release.Name }}
spec:
podSelector:
matchLabels:
{{- include "notes.selectorLabels" . | nindent 6 }}
policyTypes: [Ingress, Egress]
ingress:
- from:
- namespaceSelector:
matchLabels:
kubernetes.io/metadata.name: envoy-gateway-system
ports:
- {protocol: TCP, port: 8080}
egress:
- to:
- podSelector:
matchLabels:
app.kubernetes.io/name: postgres
ports:
- {protocol: TCP, port: 5432}
{{- end }}
Эта политика выбирает поды по метке: хелпер notes.selectorLabels из урока 5.9 выдаёт ровно app.kubernetes.io/name: notes, то есть ту же метку, что стоит на подах и в selector Service notes. Если метка в подах и в политике разойдётся, политика молча не выберет ни одного пода и перестанет действовать. DNS для этого пода уже разрешён политикой allow-dns из задания 3 (разрешения складываются).
- В
helm/notes/templates/deployment.yamlв шаблон пода добавь (хелперnotes.selectorLabelsиз урока 5.9):
spec:
serviceAccountName: {{ .Release.Name }}
automountServiceAccountToken: false
securityContext:
runAsNonRoot: true
runAsUser: 10001
runAsGroup: 10001
seccompProfile:
type: RuntimeDefault
containers:
- name: notes
securityContext:
allowPrivilegeEscalation: false
readOnlyRootFilesystem: true
capabilities:
drop: [ALL]
volumeMounts:
- {name: tmp, mountPath: /tmp}
volumes:
- name: tmp
emptyDir: {}
Остальные поля контейнера (image, env, пробы) остаются как в 0.1.1. Если в твоём deployment.yaml уже есть volumes или volumeMounts, дописывай элементы в существующие списки, а не создавай второй ключ.
- В
values.yamlдобавьnetworkPolicy.enabled: true(блокnetworkPolicy:с ключомenabled: trueвнутри), вChart.yamlподнимиversion: 0.2.0. Проверь и выкати.kubectl apply -fпринимает несколько файлов сразу;helm upgrade ... --waitждёт готовности подов:
helm lint helm/notes
helm template notes helm/notes | grep -c 'kind: NetworkPolicy'
kubectl apply -f k8s/base/00-namespace.yaml -f k8s/base/40-postgres.yaml -f k8s/base/60-pg-backup-cronjob.yaml
helm upgrade notes helm/notes -n notes --wait --timeout 3m
Что должно получиться:
==> Linting helm/notes
[INFO] Chart.yaml: icon is recommended
1 chart(s) linted, 0 chart(s) failed
1
Release "notes" has been upgraded. Happy Helming!
NAME: notes
LAST DEPLOYED: Mon Oct 26 12:00:00 2026
NAMESPACE: notes
STATUS: deployed
REVISION: 3
DESCRIPTION: Upgrade complete
Формат примерный: номер ревизии, время и строки NOTES: в конце у тебя будут свои, а кластер в этой редакции урока не запускался. Главное, что должно совпасть: STATUS: deployed и ровно одна политика в helm template.
kubectl apply для namespace, созданного раньше командой, может добавить предупреждение missing the kubectl.kubernetes.io/last-applied-configuration annotation: это нормально, метки применятся. Postgres при этом перезапустится с новыми настройками.
- Проверь итог: трафик через Gateway идёт, из чужого пода нет, права контейнера ограничены. Разбор:
exec deploy/notes -- idпечатает uid процесса;touch /xпытается создать файл в корне (должно упасть),touch /tmp/x && echo tmp-okсоздаёт в/tmp(должно получиться),2>&1направляет ошибки в общий вывод:
curl -s -o /dev/null -w '%{http_code}\n' http://notes.lab/healthz
kubectl -n default exec nettest -- curl -s -m 3 -o /dev/null -w '%{http_code}\n' http://notes.notes.svc:8080/healthz
kubectl -n notes exec deploy/notes -- id
kubectl -n notes exec deploy/notes -- sh -c 'touch /x 2>&1; touch /tmp/x && echo tmp-ok'
200
000
uid=10001(notes) gid=10001(notes) groups=10001(notes)
touch: cannot touch '/x': Read-only file system
tmp-ok
Формат примерный. Имя notes в скобках берётся из образа: пользователя создаёт Dockerfile из урока 4.2. Если в твоём образе пользователя с таким именем нет, будет uid=10001 gid=10001 groups=10001 без скобок, и это тоже верно: важен номер, а не имя.
Как читать вывод: 200 через notes.lab значит, что Gateway (namespace envoy-gateway-system) прошёл через политику. 000 из nettest: чужой под отсечён. uid=10001: приложение не root. Read-only file system в корне и tmp-ok в /tmp: read-only корень работает, а emptyDir доступен для записи.
Тестовый под nettest больше не нужен, удали его: kubectl -n default delete pod nettest.
Закоммить: git add k8s helm && git commit -m "5.12: PSS restricted, RBAC, NetworkPolicy, chart 0.2.0". Эталон: project/notes.
Объясни себе:
- Почему разрешён только namespace
envoy-gateway-system, а не вся сеть? - Зачем
automountServiceAccountToken: falseи на SA, и на поде? - Что изменится для атакующего, получившего RCE (remote code execution, выполнение кода) в поде?
Типичные ошибки:
Error creating: pods "notes-..." is forbidden: violates PodSecurity "restricted:v1.36": ...(приenforce-versionв тексте версия правил, без неёlatest): в шаблоне не хватает одного из полей: читай список в тексте ошибки и добавь.Error: UPGRADE FAILED: ...с упоминанием поляseccompProfile: оно вложено не туда (напрямую в контейнер, а не в егоsecurityContext). Helm 4 применяет манифесты через server-side apply и пишет что-то вродеfield not declared in schema, более старый Helm илиkubectl applyпишутunknown field "spec.template.spec.containers[0].seccompProfile". Точный текст зависит от версий, ищи в нём имя поля и проверь отступы.PermissionError: [Errno 30] Read-only file system: '/app/...': приложение пишет вне/tmp: смонтируйemptyDirи туда или найди, что пишет.curl: (28) Connection timed outчерезnotes.lab: политика не пускает Gateway: проверь имя namespace прокси (kubectl get pods -A | grep envoy).
Нейросеть не знает твои метки и пространства имён: любой её YAML проверяй через
auth can-iи тест трафика, а не принимай на веру.
Сломай и почини
Скачай скрипт, сверь контрольную сумму и запусти сценарий. Сумма защищает только от обрыва загрузки, но не от подмены файла в репозитории: на работе чужие скрипты сначала читают и только потом запускают. Здесь скрипт короткий, его можно прочесть сразу, но интереснее сначала найти причину сам, а прочесть после решения. Нужны все четыре задания урока (namespace с enforce: restricted, чарт 0.2.0). Запускай без sudo:
curl -fsSL -o /tmp/break-5.12.sh https://raw.githubusercontent.com/distinguished-sre/learning/main/devops/project/notes/break/5.12/break.sh
echo "a97a6afd3d53440e61562d93a90cd09694a663fb5fe9c646120796e39470d0e4 /tmp/break-5.12.sh" | sha256sum -c -
bash /tmp/break-5.12.sh 1
Если sha256sum -c печатает не OK, скрипт не запускай. На macOS вместо sha256sum используй shasum -a 256 -c -. Номера сценариев 1-4. Вернуть как было: bash /tmp/break-5.12.sh fix.
Симптом
Сценарий 1: приложение отвечает 500 или не может подключиться к базе, в логах ошибки разрешения имён. Сценарий 2: после выката новый под не появляется, rollout status висит. Сценарий 3: под запущен, но не Ready (0/1), записать заметку нельзя. Сценарий 4: служебной учётке report-bot команда kubectl ... get pods возвращает Forbidden.
Для сценариев 1-3 после запуска сделай выкатку (kubectl -n notes rollout restart deploy/notes) или удали под, чтобы изменения проявились в новых подах.
Гипотезы
Для каждого симптома назови минимум две причины: что изменилось последним (kubectl get events, helm history) и на каком уровне проблема: допуск пода, сеть или права API.
Проверки
kubectl -n notes get events --sort-by=.metadata.creationTimestamp | tail -15
kubectl -n notes describe replicaset -l app.kubernetes.io/name=notes | tail -15
kubectl -n notes logs deploy/notes --tail=30
kubectl -n notes get networkpolicy
kubectl auth can-i '<глагол>' '<ресурс>' --as='<субъект>' -n notes
Исправление
Разбор всех сценариев
- Нет разрешения на DNS при
default-deny. Скрипт удаляет политикуallow-dnsиз задания 3. Симптом:Temporary failure in name resolutionилиcould not translate host name "db". Проверка:kubectl -n notes get networkpolicyне показываетallow-dns,kubectl -n notes exec deploy/notes -- getent hosts dbне отвечает (илиnslookupвиснет). Исправление:kubectl apply -f k8s/base/70-netpol-default-deny.yaml(вернётallow-dns) илиbash /tmp/break-5.12.sh fix. Урок:default-denyбезallow-dnsломает любое обращение по имени. violates PodSecurity. В Deployment включилиallowPrivilegeEscalation: true. Симптом:rollout statusждёт, новых подов нет. Проверка:describe replicasetпоказываетError creating: pods ... is forbidden: violates PodSecurity "restricted:latest"со списком полей. Исправление: вернутьallowPrivilegeEscalation: false,helm upgrade. Ошибка видна в ReplicaSet, а не в Deployment.readOnlyRootFilesystemи запись падает. В Deployment задана переменнаяSTORE=file: приложение хочет писать заметки в файл/var/lib/notes, а корень только для чтения. Симптом: под не Ready (проба/readyzдаёт 503), заметки не сохраняются. Проверка:kubectl -n notes exec deploy/notes -- env | grep STORE,kubectl -n notes exec deploy/notes -- touch /xдаётRead-only file system. Исправление: убрать лишнюю переменную (вернутьSTORE=postgres), а если приложению правда нужна запись, смонтироватьemptyDirв этот путь (не отключать read-only).- RBAC forbidden. У Role
report-readerтолько глаголget, аkubectl get podsтребуетlist. Симптом:Error from server (Forbidden): pods is forbidden: User "system:serviceaccount:notes:report-bot" cannot list resource "pods". Проверка:kubectl auth can-i list pods --as=system:serviceaccount:notes:report-bot -n notes,kubectl -n notes get role report-reader -o yaml. Исправление: добавить глаголыlistиwatchв нужную роль, а не выдаватьcluster-admin.
ИИ в помощь
Нейросеть быстро объясняет ошибки Forbidden и пишет заготовки политик, но не знает твои метки и пространства имён. Общие правила: ИИ-помощник.
Задача: понять, какой слой остановил запрос.
Я учу безопасность Kubernetes. Вот ошибка и контекст: <вставь текст ошибки, команду и namespace>.
Скажи, какой слой её дал: аутентификация, RBAC, Pod Security или NetworkPolicy, и как это проверить командой.
Проверь ответ: сверь с таблицей слоёв из урока: Forbidden ... cannot list это RBAC, violates PodSecurity допуск, таймаут NetworkPolicy. Типичная ошибка: совет «выдай cluster-admin» для устранения Forbidden.
Задача: написать минимальную Role.
Нужна Role для ServiceAccount <имя> в namespace <namespace>, которая читает поды и их логи и больше ничего.
Выдай YAML Role и RoleBinding и объясни каждое поле.
Проверь ответ: проверь kubectl auth can-i ... --as=system:serviceaccount:<namespace>:<имя> для разрешённых и запрещённых действий. Типичная ошибка: звёздочка в verbs или resources.
Задача: составить NetworkPolicy.
Нужна NetworkPolicy: в под с меткой <метка базы> пускать только поды с метками <метки> на порт <порт>.
Выдай default deny и разрешающую политику. Что ещё нужно открыть для DNS?
Проверь ответ: убедись, что метки в политике совпадают с kubectl get pods --show-labels, а DNS разрешён. Типичная ошибка: политика без egress к CoreDNS и непроверенный сетевой плагин.
Словарик урока
| Термин | Простыми словами |
|---|---|
| API-сервер (kube-apiserver) | точка входа управления кластером, через неё идут все запросы |
| Capabilities | привилегии root, разложенные на отдельные кусочки |
| CNI | сетевой плагин, который создаёт сеть подов и выполняет NetworkPolicy |
| CoreDNS | DNS-сервер кластера в namespace kube-system |
| Default deny | запретить всё по умолчанию и разрешать только нужное |
emptyDir |
временный записываемый каталог, живущий, пока жив под |
enforce / warn / audit |
режимы PSA: запретить / предупредить / записать в журнал |
forbidden (403) |
«знаю, кто ты, но тебе нельзя» |
| Ingress (объект) | правила входа внешнего трафика в кластер; в курсе вместо него Gateway API (урок 5.4) |
| Ingress и Egress в NetworkPolicy | входящий и исходящий трафик пода; не путай с объектом Ingress выше |
| NetworkPolicy | объект, описывающий, какой трафик разрешён к подам и от них |
| Pod Security Admission (PSA) | встроенный контроллер, применяющий профили по меткам namespace |
| Pod Security Standards (PSS) | три готовых профиля требований к подам: privileged, baseline, restricted |
| RBAC | управление доступом по ролям: кому какие действия над какими ресурсами |
| RCE (Remote Code Execution) | ситуация, когда атакующий заставляет твою программу выполнить его команды |
| Role / ClusterRole | список разрешений в одном namespace / на весь кластер |
| RoleBinding / ClusterRoleBinding | выдача роли субъекту в namespace / на весь кластер |
| root, uid 0 | администратор в Linux, процесс с почти неограниченными правами |
| seccomp | фильтр системных вызовов, которые процессу разрешено делать |
| securityContext | блок манифеста с настройками безопасности пода и контейнера |
| ServiceAccount (SA) | учётка программы внутри пода |
| Verb (глагол) | действие: get, list, watch, create, delete и т. д. |
| Авторизация | проверка «что тебе можно» |
| Аутентификация | проверка «кто ты» |
| Допуск (admission) | проверка самого объекта по правилам перед сохранением |
| Защита в глубину | несколько независимых преград на пути атаки, а не один замок |
| Метка (label) | пара «ключ: значение» на объекте, по ней объекты выбирают селекторами |
| Принцип наименьших привилегий | давать ровно те права, которые нужны для работы |
| Селектор (selector) | условие отбора объектов по меткам: matchLabels, matchExpressions, пустой {} (все) |
| Уязвимость | ошибка в программе, которой можно воспользоваться для атаки |
Вопросы с собеседований
Раздел для повторения: ответь вслух, потом открой ответ. Короткие вопросы с пометкой [на скорость] тренируй на время: ответ за 30 секунд.
1. [junior] [часто] Что такое RBAC и из каких объектов он состоит?
Ответ
Role описывает, какие глаголы допустимы над какими ресурсами в namespace, RoleBinding привязывает роль к пользователю, группе или ServiceAccount. ClusterRole и ClusterRoleBinding то же на весь кластер. Права только разрешаются, запретов нет.
Что хотят услышать: четыре объекта, принцип минимальных прав, kubectl auth can-i, отличие namespace от cluster.
Красный флаг: «RBAC это логины и пароли» или выдача cluster-admin «чтобы работало».
2. [middle] [часто] Применил NetworkPolicy, а трафик по-прежнему ходит. Почему?
Ответ
Первое: CNI не поддерживает политики (манифест принимается, но не работает). Второе: под не выбран podSelector (метки не совпали) или политика в другом namespace. Третье: есть другая политика, которая разрешает (разрешения складываются). Проверяю тестовым curl изнутри и describe networkpolicy.
Что хотят услышать: CNI (Calico, Cilium), метки, аддитивность, проверка тестом, а не «применил и поверил».
Красный флаг: «политики всегда работают, раз kubectl не выдал ошибку».
3. [junior] [часто] Чем отличаются профили PSS privileged, baseline и restricted?
Ответ
privileged без ограничений, baseline блокирует явно опасное (privileged, hostPath, hostNetwork), restricted требует лучших практик: не root, drop ALL, seccomp, без privilege escalation.
Что хотят услышать: режимы enforce, warn, audit, метки на namespace.
Красный флаг: путает PSS с PodSecurityPolicy (её убрали в 1.25).
4. [middle] [на скорость] Разработчик жалуется: cannot list resource "pods" ... forbidden. Как разбираешься?
Ответ
Смотрю точный текст: субъект, глагол, ресурс, namespace. Проверяю kubectl auth can-i list pods --as=<субъект> -n <ns>, потом get rolebinding,clusterrolebinding и роль на нужные verbs и resources. Чиню минимально: правлю роль или привязку в нужном namespace.
Что хотят услышать: --as, разница Role и ClusterRole, subject в нужном namespace, не давать wildcard.
Красный флаг: сразу выдаёт cluster-admin.
5. [middle] После default deny egress сервис перестал ходить в БД по имени, а по IP ходит. В чём дело?
Ответ
Заблокирован DNS: запрос к CoreDNS (DNS-серверу кластера) в kube-system на порт 53 (UDP и TCP) не проходит. Добавляю egress-разрешение на DNS через namespaceSelector на kube-system.
Что хотят услышать: порт 53, оба протокола, признак «по IP работает, по имени нет».
Красный флаг: отключает политику целиком вместо точечного разрешения.
6. [middle] [на скорость] Деплой завис: kubectl rollout status ждёт, подов нет. В events violates PodSecurity. Что делаешь?
Ответ
Смотрю ошибку в describe replicaset: она перечисляет нарушенные поля. Добавляю в securityContext runAsNonRoot, allowPrivilegeEscalation: false, drop: [ALL], seccompProfile: RuntimeDefault. Ослаблять метку namespace не стану без причины.
Что хотят услышать: ошибка в ReplicaSet, а не в Deployment; поля по списку; что PSA проверяет только создание.
Красный флаг: «снимаю label с namespace, чтобы деплой прошёл».
7. [middle] [на скорость] Как безопасно включить restricted на живом namespace?
Ответ
Сначала warn и audit, смотрю нарушения на --dry-run=server и в аудите, исправляю манифесты (в том числе StatefulSet и CronJob), потом enforce. Работающие поды не убиваются, но при рестарте нарушители не поднимутся.
Что хотят услышать: поэтапность, что PSA действует при создании, проверка всех воркладов.
Красный флаг: сразу enforce в проде в пятницу.
8. [middle] Контейнер падает с Read-only file system после включения readOnlyRootFilesystem. Что делаешь?
Ответ
Нахожу, куда пишет процесс (логи, документация), и монтирую в эти пути emptyDir (временный записываемый том). Корень оставляю read-only, флаг не отключаю.
Что хотят услышать: emptyDir для /tmp и кэшей, зачем read-only.
Красный флаг: отключает флаг, чтобы «заработало».
9. [junior] Зачем automountServiceAccountToken: false?
Ответ
Токен в поде даёт доступ к API по правам SA. Если приложение API не использует, токен только расширяет ущерб при взломе. Отключаю на SA или на поде.
Что хотят услышать: default SA, токен в /var/run/secrets/..., минимальные права.
Красный флаг: «токен нужен всегда для работы пода».
10. [junior] Чем отличаются ошибки 401 и 403 от API-сервера?
Ответ
401 Unauthorized: сервер не смог определить, кто ты (нет или неверные учётные данные). 403 Forbidden: сервер знает, кто ты, но действие не разрешено (чаще всего RBAC; если в тексте есть PodSecurity, отказал допуск, а не RBAC). Отсюда разный разбор: при 401 смотрю kubeconfig и токен, при 403 роли и привязки.
Что хотят услышать: аутентификация против авторизации, порядок проверок.
Красный флаг: путает и «лечит» любую ошибку выдачей админских прав.
11. [junior] Какие настройки securityContext нужны, чтобы под проходил профиль restricted?
Ответ
Профиль restricted требует: runAsNonRoot: true, allowPrivilegeEscalation: false, сброс всех capabilities (capabilities.drop: ["ALL"]) и seccompProfile типа RuntimeDefault (или Localhost). Также запрещены привилегированные контейнеры и hostPath. Если образ запускается от root, меняю образ или задаю runAsUser. Результат проверяю kubectl apply --dry-run=server в namespace с метками PSS.
Что хотят услышать: runAsNonRoot, запрет эскалации, drop ALL, seccomp RuntimeDefault, dry-run на namespace.
Красный флаг: Включить privileged, чтобы всё заработало.
12. [junior] Почему нельзя выдавать cluster-admin всем и что такое принцип наименьших привилегий?
Ответ
cluster-admin даёт любые действия над любыми ресурсами, включая чтение всех Secret и создание привилегированных подов, поэтому ошибка или утёкший токен ведут к компрометации кластера. Принцип наименьших привилегий: давать ровно те verbs и resources, которые нужны, и в нужном namespace через Role и RoleBinding. Избегаю * в правилах. Проверяю права командой kubectl auth can-i и kubectl auth can-i --list.
Что хотят услышать: cluster-admin слишком широк, Role в namespace, без wildcard, can-i, токены ServiceAccount.
Красный флаг: «Так проще, чтобы ничего не ломалось».
Проверено на версиях
- Проверено командами:
helm lint,helm template(Helm v4.3.0) на учебном чарте сdeployment.yaml,serviceaccount.yaml,networkpolicy.yamlиз урока (1 NetworkPolicy приnetworkPolicy.enabled: true),kubeconform -strict -summary(v0.8.0) для RBAC, NetworkPolicy, namespace, фрагментов Postgres и отрисованного чарта: без замечаний;shellcheckдляbreak.shбез замечаний. - Не прогонялось: кластер kind не запускался. Вывод
kubectl auth can-i, предупреждения PSA, поведение NetworkPolicy и результатыcurlнаписаны по документации Kubernetes, на кластере не воспроизводились; числа и тексты примерные.break.shпроверен толькоshellcheckи чтением, на кластере не запускался. - Kubernetes, kind: версии из урока 5.1 (kind v0.33.0). Calico v3.30.0 в запасном пути указан как закреплённая версия и запуском не проверялся. Правила PSA с
enforce-versionсверь с документацией своей версии Kubernetes. - Envoy Gateway: v1.9.2, PostgreSQL: 18
- curlimages/curl: 8.14.1
Итог урока: ты умеешь
- умею объяснить, почему в кластере нужна защита в глубину, и назвать три слоя и цепочку проверок API
- умею создать ServiceAccount, Role и RoleBinding и проверить границы через
kubectl auth can-i --as - умею читать ошибку
forbiddenи находить, какого права не хватает - умею включить Pod Security
restrictedпоэтапно (warn, audit, enforce) - умею настроить
securityContext: не root, read-only корень, drop ALL, seccomp,emptyDirдля/tmp - умею написать default deny и разрешения для DNS, БД и Gateway
- умею проверить, что NetworkPolicy реально применяется CNI, а не только принята API
- умею починить
violates PodSecurityиRead-only file system - умею выпустить чарт 0.2.0 с ServiceAccount без токена и NetworkPolicy
Дальше: Урок 5.13: Диагностика Kubernetes: разбор поломок
Проверь себя
Короткий тест по уроку: 5 вопросов из банка в 30. Засчитывается только полностью правильный ответ, порог 60%. Каждая новая попытка даёт другие вопросы, пока банк не закончится. Ответы видны после проверки.
Тест работает с включённым JavaScript.