Skip to content

Kubernetes Шпаргалка

Платформа оркестрации контейнеров для автоматизации развёртывания и масштабирования.

01

Начало работы

Основы kubectl

kubectl — CLI для Kubernetes. get перечисляет ресурсы, create создаёт новые, expose создаёт сервисы, scale меняет число реплик. describe даёт подробную информацию о ресурсе.

kubernetes
# cluster info
kubectl cluster-info

# list nodes
kubectl get nodes

# list pods (all namespaces)
kubectl get pods --all-namespaces

# create a deployment
kubectl create deployment nginx --image=nginx

# expose deployment as service
kubectl expose deployment nginx --port=80 --type=LoadBalancer

# scale deployment
kubectl scale deployment nginx --replicas=3

# get detailed info
kubectl describe pod <pod-name>

# view logs
kubectl logs <pod-name>

Форматирование вывода

Флаг -o управляет выводом. yaml/json показывают полную спецификацию ресурса. jsonpath и custom-columns извлекают отдельные поля для скриптов. -w следит за изменениями в реальном времени. В скриптах используйте --no-headers, чтобы убрать заголовки колонок.

kubernetes
# wide format (more columns)
kubectl get pods -o wide

# YAML output
kubectl get pod nginx -o yaml

# JSON output
kubectl get pod nginx -o json

# jsonpath (extract specific fields)
kubectl get pods -o jsonpath='{.items[*].metadata.name}'

# custom columns
kubectl get pods -o custom-columns=NAME:.metadata.name,STATUS:.status.phase

# show labels
kubectl get pods --show-labels

# watch for changes
kubectl get pods -w

Контекст и конфигурация

Контекст объединяет адрес кластера, учётные данные пользователя и пространство имён. Файлы kubeconfig (по умолчанию ~/.kube/config) хранят это. Несколько файлов можно объединить через переменную окружения KUBECONFIG для управления многими кластерами.

kubernetes
# view current config
kubectl config view

# list contexts
kubectl config get-contexts

# switch context
kubectl config use-context my-cluster

# set default namespace for current context
kubectl config set-context --current --namespace=dev

# show current context
kubectl config current-context

# KUBECONFIG with multiple files
export KUBECONFIG=~/.kube/config:~/.kube/prod-config

Explain и API-ресурсы

api-resources перечисляет, что поддерживает кластер. explain показывает схему OpenAPI любого ресурса — бесценно для написания YAML, не выходя из терминала. Используйте --recursive, чтобы вывести всю вложенную структуру.

kubernetes
# list all resource types
kubectl api-resources

# list namespaced vs cluster-scoped
kubectl api-resources --namespaced=true
kubectl api-resources --namespaced=false

# explain a resource's fields
kubectl explain pod
kubectl explain pod.spec.containers
kubectl explain deployment.spec.strategy

# explain with recursion (all nested fields)
kubectl explain pod --recursive

# include description
kubectl explain pod.spec.containers.resources --api-version=apps/v1

Dry run и генерация YAML

--dry-run=client -o yaml — стандартный способ создать манифесты из императивных команд. --dry-run=server проверяет по настоящему apiserver (admission webhooks, схема), не сохраняя. Отлично для создания заготовок декларативного YAML.

kubernetes
# generate YAML without applying
kubectl create deployment nginx --image=nginx --dry-run=client -o yaml

# pipe generated YAML straight to a file
kubectl create deployment nginx --image=nginx --dry-run=client -o yaml > nginx.yaml

# apply the generated manifest
kubectl apply -f nginx.yaml

# dry-run against the server (validates with apiserver)
kubectl apply -f nginx.yaml --dry-run=server

# generate a service from a deployment
kubectl create service clusterip my-svc --tcp=80:80 --dry-run=client -o yaml

Справка и автодополнение

Каждая команда kubectl поддерживает --help с примерами. Автодополнение в shell экономит массу набора и показывает подкоманды. Алиас k=kubectl почти универсален среди практиков — сочетайте его с автодополнением для лучшего опыта.

kubernetes
# top-level help
kubectl --help

# subcommand help
kubectl create --help
kubectl explain --help

# generate bash completion
kubectl completion bash > /etc/bash_completion.d/kubectl

# zsh completion
source <(kubectl completion zsh)

# alias k=kubectl with completion
alias k=kubectl
complete -o default -F __start_kubectl k

# shorthand: kubectl -> k
echo 'alias k=kubectl' >> ~/.bashrc
02

Pod

Манифест Pod

Pod — минимальная единица развёртывания, содержащая один или несколько контейнеров с общей сетью и хранилищем. Контейнеры в pod всегда размещаются на одном узле. Напрямую pod создают редко — используйте Deployment или Job.

kubernetes
apiVersion: v1
kind: Pod
metadata:
  name: nginx
  labels:
    app: nginx
spec:
  containers:
    - name: nginx
      image: nginx:1.25
      ports:
        - containerPort: 80
      resources:
        requests:
          cpu: 100m
          memory: 128Mi
        limits:
          cpu: 200m
          memory: 256Mi
  restartPolicy: Always

Многоконтейнерный Pod (sidecar)

Многоконтейнерные pod делят сеть (тот же IP и порты) и тома. Частые паттерны: sidecar (помощник), adapter (преобразует вывод), ambassador (прокси). Общий том emptyDir позволяет sidecar читать логи, которые пишет основной контейнер.

kubernetes
apiVersion: v1
kind: Pod
metadata:
  name: web-with-logs
spec:
  containers:
    - name: app
      image: nginx
      volumeMounts:
        - name: shared-logs
          mountPath: /var/log/nginx
    - name: log-shipper
      image: busybox
      command: ["sh", "-c", "tail -f /var/log/nginx/access.log"]
      volumeMounts:
        - name: shared-logs
          mountPath: /var/log/nginx
          readOnly: true
  volumes:
    - name: shared-logs
      emptyDir: {}

Жизненный цикл и фазы Pod

Фаза pod верхнеуровневая (Pending, Running, Succeeded, Failed). Состояния контейнера (Waiting/Running/Terminated) дают реальные детали: например, CrashLoopBackOff означает, что контейнер постоянно завершается. Проверяйте число перезапусков и события для диагностики.

kubernetes
# pod phases: Pending | Running | Succeeded | Failed | Unknown
kubectl get pod nginx

# show status including container states
kubectl get pod nginx -o jsonpath='{.status}'

# container states: Waiting | Running | Terminated
kubectl describe pod nginx

# common Waiting reasons: ImagePullBackOff, CrashLoopBackOff, CreateContainerConfigError
kubectl get pods --field-selector=status.phase=Pending

# restart count reveals crash loops
kubectl get pods -o jsonpath='{.items[*].status.containerStatuses[*].restartCount}'

Статус Pod и события

События — журнал аудита кластера для ресурса: планирование, загрузка образа, ошибки загрузки, сбои liveness. Они истекают (по умолчанию около часа), поэтому фиксируйте их при отладке. describe объединяет события со спецификацией ресурса для быстрой диагностики.

kubernetes
# full describe (includes Events at the bottom)
kubectl describe pod nginx

# list cluster events sorted by time
kubectl get events --sort-by=.lastTimestamp

# events for a specific namespace
kubectl get events -n default

# watch events live
kubectl get events -w

# filter events by type
kubectl get events --field-selector type=Warning

# events for a specific pod
kubectl get events --field-selector involvedObject.name=nginx

Exec и port-forward

exec выполняет команды внутри контейнера; -it выделяет TTY для shell. port-forward туннелирует локальный порт к pod или сервису, не публикуя его наружу, — необходимо для отладки баз данных и веб-интерфейсов с ноутбука.

kubernetes
# open an interactive shell
kubectl exec -it nginx -- sh

# run a one-off command
kubectl exec nginx -- ls /etc/nginx

# specify container in a multi-container pod
kubectl exec -it web-with-logs -c log-shipper -- sh

# forward a local port to a pod port
kubectl port-forward pod/nginx 8080:80

# forward to a service / deployment
kubectl port-forward svc/nginx 8080:80
kubectl port-forward deployment/nginx 8080:80

# forward to a random local port
kubectl port-forward pod/nginx :80

Удаление и force

Удаление pod, управляемого Deployment/StatefulSet, вызывает немедленную замену. --force --grace-period=0 пропускает период ожидания сигнала TERM и может оставить устаревшие ресурсы — используйте редко. Застрявшим в Terminating pod часто нужно убрать finalizer.

kubernetes
# delete a pod (controller will recreate it)
kubectl delete pod nginx

# force delete immediately (bypasses graceful shutdown)
kubectl delete pod nginx --grace-period=0 --force

# delete by label
kubectl delete pods -l app=nginx

# delete all pods in a namespace
kubectl delete pods --all -n default

# delete a pod and wait for it to be gone
kubectl delete pod nginx --wait

# delete with a timeout
kubectl delete pod nginx --timeout=30s
03

Deployment

Манифест Deployment

Deployment управляет ReplicaSet и даёт декларативные rolling update и rollback. spec.selector должен совпадать с spec.template.metadata.labels. Шаблон задаёт спецификацию pod, которая выкатывается.

kubernetes
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx
  labels:
    app: nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
        - name: nginx
          image: nginx:1.25
          ports:
            - containerPort: 80

Стратегия rolling update

RollingUpdate (по умолчанию) постепенно заменяет pod без простоя. maxSurge/maxUnavailable управляют скоростью выката и доступностью. Recreate убивает все pod перед созданием новых — используется, когда приложение не может работать в двух версиях одновременно (например, писатели в один том).

kubernetes
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx
spec:
  replicas: 10
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 25%        # extra pods above replicas during update
      maxUnavailable: 25%  # pods allowed down during update
  # alternative: recreate (kills all, then starts new)
  # strategy:
  #   type: Recreate
  selector:
    matchLabels:
      app: nginx
  template:

Откат

Каждое изменение шаблона pod создаёт ревизию ReplicaSet. undo переключает трафик обратно на предыдущий ReplicaSet. pause позволяет сделать несколько исправлений между шагами канареечного выката. Используйте --record (устарел) или аннотации для отслеживания причин изменений.

kubernetes
# view rollout history
kubectl rollout history deployment/nginx

# see details of a specific revision
kubectl rollout history deployment/nginx --revision=2

# undo to the previous revision
kubectl rollout undo deployment/nginx

# undo to a specific revision
kubectl rollout undo deployment/nginx --to-revision=2

# pause/resume a rollout (for canary pauses)
kubectl rollout pause deployment/nginx
kubectl rollout resume deployment/nginx

# check rollout status
kubectl rollout status deployment/nginx

Масштабирование и HPA

HPA масштабирует реплики по CPU/памяти или своим метрикам. Для CPU/памяти нужен metrics-server. minReplicas и maxReplicas ограничивают масштабирование. API v2 поддерживает несколько метрик и поведение (стабилизацию при снижении).

kubernetes
# scale manually
kubectl scale deployment/nginx --replicas=5

# horizontal pod autoscaler (CPU target)
kubectl autoscale deployment nginx --min=2 --max=10 --cpu-percent=80

# list HPA
kubectl get hpa

# HPA manifest (v2 with custom metrics)
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: nginx
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: nginx
  minReplicas: 2
  maxReplicas: 10
  metrics:
    - type: Resource
      resource:
        name: cpu
        target:
          type: Utilization
          averageUtilization: 80

Обновление образа и перезапуск

set image запускает новый ReplicaSet и rolling update. rollout restart — самый чистый способ подтянуть свежий образ или обновить конфигурацию: создаётся новый ReplicaSet с той же спецификацией. edit открывает $EDITOR для разовых исправлений.

kubernetes
# update container image
kubectl set image deployment/nginx nginx=nginx:1.26

# update from a specific container
kubectl set image deployment/nginx container=nginx:1.26 --record

# trigger a rollout restart (same image, recreate pods)
kubectl rollout restart deployment/nginx

# edit a deployment in editor
kubectl edit deployment/nginx

# patch a single field
kubectl patch deployment/nginx -p '{"spec":{"replicas":5}}'

# apply a manifest change
kubectl apply -f nginx-deployment.yaml

Статус Deployment

Deployment владеет ReplicaSet; активен только один (replicas>0). Старые ReplicaSet масштабируются в ноль для отката. Метка pod-template-hash помечает каждый pod его ревизией. Проверяйте status.conditions на сигналы Available, Progressing и ReplicaFailure.

kubernetes
# deployment status
kubectl get deployment nginx

# watch rollout
kubectl rollout status deployment/nginx

# show ReplicaSets owned by the deployment
kubectl get rs -l app=nginx

# show pods across all revisions
kubectl get pods -l app=nginx --show-labels

# pod-template-hash label distinguishes revisions
# kubectl get pods -l app=nginx,pod-template-hash=xxxx

# conditions: Available, Progressing, ReplicaFailure
kubectl get deployment nginx -o jsonpath='{.status.conditions}'
04

Service

Типы Service

Service даёт стабильный IP/DNS, балансирующий нагрузку по набору pod. ClusterIP — по умолчанию (только внутри кластера). NodePort и LoadBalancer публикуют наружу. ExternalName — DNS-псевдоним, а не прокси.

kubernetes
# four service types:
# - ClusterIP (default): reachable inside the cluster
# - NodePort: exposed on each node's IP at a static port
# - LoadBalancer: cloud-provisioned external LB
# - ExternalName: DNS CNAME to an external host

# quick create
kubectl expose deployment nginx --port=80 --type=ClusterIP
kubectl expose deployment nginx --port=80 --type=NodePort
kubectl expose deployment nginx --port=80 --type=LoadBalancer

# external name (no proxying, pure DNS)
kubectl create service externalname my-svc --external-name=db.example.com

Service ClusterIP

ClusterIP даёт стабильный виртуальный IP и DNS-имя внутри кластера. Селектор совпадает с метками pod; kube-proxy настраивает iptables/IPVS для балансировки по endpoint. Разрешается через <svc>.<ns>.svc.cluster.local или просто <svc>.

kubernetes
apiVersion: v1
kind: Service
metadata:
  name: nginx
spec:
  type: ClusterIP
  selector:
    app: nginx
  ports:
    - name: http
      port: 80          # service port
      targetPort: 80    # container port
      protocol: TCP
# DNS: nginx.default.svc.cluster.local
# short names also work: nginx, nginx.default
# kube-dns / CoreDNS resolves the service VIP

Service NodePort

NodePort открывает один и тот же статический порт (30000-32767) на каждом узле. Трафик на любой node:nodePort доходит до pod (kube-proxy может перенаправить на pod на другом узле). Полезно, когда нельзя выделить облачный LB; сочетайте с внешним LB для отказоустойчивости.

kubernetes
apiVersion: v1
kind: Service
metadata:
  name: nginx
spec:
  type: NodePort
  selector:
    app: nginx
  ports:
    - port: 80
      targetPort: 80
      nodePort: 30080   # optional, 30000-32767 range
# reachable at <any-node-ip>:30080
# also still reachable via clusterIP:80

# get assigned nodePort
kubectl get svc nginx -o jsonpath='{.spec.ports[*].nodePort}'

Service LoadBalancer

LoadBalancer просит облачного провайдера выделить внешний балансировщик, указывающий на узлы. externalTrafficPolicy: Local сохраняет исходный IP клиента (без SNAT), но отключает межнодовую балансировку. STATUS показывает назначенный внешний IP, когда он готов.

kubernetes
apiVersion: v1
kind: Service
metadata:
  name: nginx
spec:
  type: LoadBalancer
  selector:
    app: nginx
  ports:
    - port: 80
      targetPort: 80
  # cloud-specific annotations
  # annotations:
  #   service.beta.kubernetes.io/aws-load-balancer-type: nlb
  #   service.beta.kubernetes.io/azure-load-balancer-internal: "true"
  # externalTrafficPolicy: Local preserves client IP
  externalTrafficPolicy: Local
# status.ingress shows the external IP/hostname

Headless Service

Headless-сервис (clusterIP: None) не имеет VIP: DNS возвращает IP pod напрямую. Нужен StatefulSet, чтобы каждый pod получал стабильное DNS-имя (pod-0.svc, pod-1.svc). Также используется клиентами, которые сами хотят обнаружить все backend'ы.

kubernetes
apiVersion: v1
kind: Service
metadata:
  name: nginx-headless
spec:
  clusterIP: None       # makes it headless
  selector:
    app: nginx
  ports:
    - port: 80
      targetPort: 80
# DNS returns pod IPs directly (not a VIP)
# A records: nginx-headless.default.svc.cluster.local
#   -> 10.1.0.5, 10.1.0.6, 10.1.0.7
# used by StatefulSet for stable pod DNS:
#   <pod-name>.<svc-name>.default.svc.cluster.local

Endpoints и EndpointSlices

Endpoints/EndpointSlices перечисляют IP pod, которые реально получают трафик, — попадают только Ready pod. Если у сервиса нет endpoint, pod не совпадают с селектором или не Ready. EndpointSlices (v1) лучше масштабируются для больших сервисов и используются по умолчанию.

kubernetes
# view endpoints backing a service
kubectl get endpoints nginx

# endpoint slices (newer, more scalable)
kubectl get endpointslices -l kubernetes.io/service-name=nginx

# endpoints track pods that match the selector
# AND pass readiness checks
kubectl describe endpoints nginx

# a service with no ready pods has no endpoints
# - check pod readiness if traffic is refused
# - EndpointSlices are grouped by address type (IPv4/IPv6)

# manually managed endpoints (selector-less service)
05

ConfigMap

Создание ConfigMap

ConfigMap хранит несекретную конфигурацию парами ключ-значение. --from-literal для значений на месте, --from-file встраивает целые файлы (имя файла становится ключом). Полезно для отделения конфигурации от образов без пересборки.

kubernetes
# from literal values
kubectl create configmap app-config \
  --from-literal=LOG_LEVEL=debug \
  --from-literal=ENABLE_FEATURE=true

# from a file (key = filename, value = contents)
kubectl create configmap app-config --from-file=app.properties

# from a directory (one key per file)
kubectl create configmap app-config --from-file=configs/

# from an env file
kubectl create configmap app-config --from-env-file=app.env

# from a file with a custom key
kubectl create configmap app-config --from-file=custom-key=app.properties

Манифест ConfigMap

data хранит строковые значения (каждый ключ становится либо переменной окружения, либо файлом при монтировании). Многострочные строки используют блочные скаляры YAML (|). binaryData принимает base64 для бинарных данных. Общий лимит размера — 1 МиБ на ConfigMap.

kubernetes
apiVersion: v1
kind: ConfigMap
metadata:
  name: app-config
data:
  LOG_LEVEL: "debug"
  ENABLE_FEATURE: "true"
  application.yml: |
    server:
      port: 8080
    logging:
      level: debug
binaryData:
  # base64-encoded binary values
  logo.png: iVBORw0KGgoAAAANSUhEUg...

Использование как переменные окружения

envFrom внедряет все ключи ConfigMap как переменные окружения за один раз. env с configMapKeyRef выбирает отдельные ключи. optional: true позволяет pod запуститься, даже если ConfigMap не существует. Обновления ConfigMap НЕ обновляют переменные окружения в работающих pod.

kubernetes
apiVersion: v1
kind: Pod
metadata:
  name: app
spec:
  containers:
    - name: app
      image: myapp:1.0
      env:
        - name: LOG_LEVEL
          valueFrom:
            configMapKeyRef:
              name: app-config
              key: LOG_LEVEL
      envFrom:
        - configMapRef:
            name: app-config      # injects all keys as env vars
              optional: true      # pod starts even if CM missing

Использование как том

Монтирование ConfigMap как тома проецирует каждый ключ в файл. Обновления ConfigMap в конечном счёте отражаются в смонтированных файлах (период синхронизации kubelet), но приложение должно перечитать их. Монтирование через subPath фиксирует один ключ и НЕ обновляется.

kubernetes
apiVersion: v1
kind: Pod
metadata:
  name: app
spec:
  containers:
    - name: app
      image: myapp:1.0
      volumeMounts:
        - name: config
          mountPath: /etc/config
          readOnly: true
  volumes:
    - name: config
      configMap:
        name: app-config
        items:                       # optional: pick subset
          - key: application.yml
            path: app.yml            # rename file
        defaultMode: 0644
# each ConfigMap key becomes a file under /etc/config

Обновление и перезагрузка

Смонтированные файлы ConfigMap обновляются автоматически (после синхронизации kubelet), но переменные окружения неизменны в течение жизни pod: перезапустите pod, чтобы подхватить изменения. rollout restart — самый чистый способ распространить обновления конфигурации на Deployment.

kubernetes
# edit the configmap
kubectl edit configmap app-config

# patch a single key
kubectl patch configmap app-config \
  --type merge -p '{"data":{"LOG_LEVEL":"info"}}'

# mounted files update within ~kubelet sync period (default 60s)
# but env vars do NOT update in running pods

# force pods to pick up new config by rolling them
kubectl rollout restart deployment/app

# verify the new value on a pod
kubectl exec app -- printenv LOG_LEVEL

Неизменяемый ConfigMap

immutable: true замораживает ConfigMap: любое изменение требует удаления и пересоздания. Это резко снижает трафик watch между kubelet и apiserver для больших стабильных конфигураций (большой выигрыш при масштабе). Обычно в production для конфигураций приложений, версионируемых вместе с образом.

kubernetes
apiVersion: v1
kind: ConfigMap
metadata:
  name: app-config
immutable: true
data:
  LOG_LEVEL: "debug"
# once immutable, the only change allowed is delete + recreate
# benefits: kubelet does not watch it, lower apiserver load
# useful for large, stable configs in production

# make it mutable again
kubectl patch configmap app-config -p '{"immutable":false}'
# (this fails if currently immutable — must delete instead)
06

Secret

Создание Secret

Secret хранит чувствительные данные в base64 (НЕ шифруется при хранении по умолчанию: включите шифрование для production). Используйте generic/Opaque для произвольных данных, docker-registry для загрузки образов, tls для Ingress TLS. Никогда не коммитьте YAML Secret в git.

kubernetes
# generic (opaque) from literals
kubectl create secret generic db-creds \
  --from-literal=username=admin \
  --from-literal=password='S3cur3!'

# from a file (e.g. SSH key, certificate)
kubectl create secret generic ssh-key --from-file=ssh-privatekey=~/.ssh/id_rsa

# docker registry secret (for private image registries)
kubectl create secret docker-registry regcred \
  --docker-server=registry.example.com \
  --docker-username=user \
  --docker-password=pass \
  [email protected]

# TLS secret from cert/key files
kubectl create secret tls my-tls \
  --cert=fullchain.pem \
  --key=privkey.pem

Манифест Secret

Значения data должны быть в base64 (echo -n 'value' | base64). stringData — удобство: принимает открытый текст и сливается в data при apply. type Opaque по умолчанию; специальные типы (kubernetes.io/tls, kubernetes.io/dockerconfigjson) проверяют ключи.

kubernetes
apiVersion: v1
kind: Secret
metadata:
  name: db-creds
type: Opaque
data:
  username: YWRtaW4=         # base64 of "admin"
  password: UzNjdXIzIQ==     # base64 of "S3cur3!"
# stringData accepts plaintext (auto-encoded on apply)
stringData:
  api-key: "live-key-xyz"
# encode on the command line:
# echo -n 'admin' | base64
# decode:
# echo 'YWRtaW4=' | base64 -d

Secret как переменная окружения

Использование секретов как переменных окружения идентично ConfigMap, но через secretKeyRef/secretRef. Учтите: переменные окружения видны через /proc/1/environ и любому процессу в контейнере — для особо чувствительных данных предпочитайте монтирование томов.

kubernetes
apiVersion: v1
kind: Pod
metadata:
  name: app
spec:
  containers:
    - name: app
      image: myapp:1.0
      env:
        - name: DB_PASSWORD
          valueFrom:
            secretKeyRef:
              name: db-creds
              key: password
      envFrom:
        - secretRef:
            name: db-creds      # injects all keys
              optional: true

Secret как том

Смонтированные секреты проецируются в файлы на томе tmpfs (в памяти) и никогда не пишутся на диск узла. defaultMode 0400 ограничивает доступ. Смонтированные секреты ОБНОВЛЯЮТСЯ при изменении Secret (после синхронизации kubelet), в отличие от секретов-переменных.

kubernetes
apiVersion: v1
kind: Pod
metadata:
  name: app
spec:
  containers:
    - name: app
      image: myapp:1.0
      volumeMounts:
        - name: secrets
          mountPath: /etc/secrets
          readOnly: true
  volumes:
    - name: secrets
      secret:
        secretName: db-creds
        defaultMode: 0400       # restrict permissions
        items:
          - key: password
            path: db-password   # written to /etc/secrets/db-password
# memory-backed tmpfs, never written to disk on the node

ImagePullSecret

imagePullSecrets аутентифицируются в приватных registry при загрузке образов. Привязка к ServiceAccount применяет его ко всем pod, использующим этот SA, — предпочтительный паттерн. Тип секрета docker-registry автоматически формирует правильный payload .dockerconfigjson.

kubernetes
# attach to a pod
apiVersion: v1
kind: Pod
metadata:
  name: private-app
spec:
  imagePullSecrets:
    - name: regcred
  containers:
    - name: app
      image: registry.example.com/myapp:1.0

# attach to a service account (auto-applied to all pods using it)
kubectl patch serviceaccount default \
  -p '{"imagePullSecrets":[{"name":"regcred"}]}'

# verify
kubectl get sa default -o jsonpath='{.imagePullSecrets}'

Типы Secret

Специальные типы секретов включают валидацию и интеграцию: tls для Ingress, dockerconfigjson для загрузки образов, service-account-token автоматически монтируется в pod. Правильный тип гарантирует проверку ключей и их использование нужными контроллерами.

kubernetes
# Opaque (default) — arbitrary key-value
type: Opaque

# kubernetes.io/service-account-token — auto for SAs
type: kubernetes.io/service-account-token

# kubernetes.io/dockerconfigjson — registry auth
type: kubernetes.io/dockerconfigjson
data:
  .dockerconfigjson: <base64>

# kubernetes.io/tls — for Ingress TLS
type: kubernetes.io/tls
data:
  tls.crt: <base64>
  tls.key: <base64>

# kubernetes.io/basic-auth
type: kubernetes.io/basic-auth
stringData:
  username: admin
  password: pass
07

Namespace

Создание Namespace

Namespace делит кластер между командами или окружениями (dev/stage/prod). Имена ресурсов уникальны внутри namespace. Некоторые ресурсы (Nodes, PV, StorageClass) относятся к кластеру и не имеют namespace.

kubernetes
# imperative
kubectl create namespace dev

# declarative
apiVersion: v1
kind: Namespace
metadata:
  name: dev
  labels:
    environment: development
    team: platform

# apply
kubectl apply -f namespace.yaml

# list namespaces
kubectl get namespaces

# set default namespace for current context
kubectl config set-context --current --namespace=dev

ResourceQuota

ResourceQuota ограничивает суммарное использование ресурсов в namespace: общие requests/limits CPU и памяти, число объектов (pod, PVC, сервисы, deployment). Необходимо для многопользовательских кластеров, чтобы одна команда не съедала ресурсы других. Pod без явных requests отклоняются, как только квота задана.

kubernetes
apiVersion: v1
kind: ResourceQuota
metadata:
  name: compute-quota
  namespace: dev
spec:
  hard:
    requests.cpu: "10"
    requests.memory: 20Gi
    limits.cpu: "20"
    limits.memory: 40Gi
    pods: "50"
    services.loadbalancers: "2"
    persistentvolumeclaims: "10"
    count/deployments.apps: "5"
# limits total aggregate resource use in the namespace

LimitRange

LimitRange задаёт значения по умолчанию и границы на ресурс: default requests/limits для pod без них, а также min/max для ограничения неразумных значений. Сочетается с ResourceQuota: без default requests квота отклоняла бы каждый pod, забывший их указать.

kubernetes
apiVersion: v1
kind: LimitRange
metadata:
  name: default-limits
  namespace: dev
spec:
  limits:
    - type: Container
      default:               # default limits (if unset)
        cpu: 500m
        memory: 512Mi
      defaultRequest:        # default requests (if unset)
        cpu: 100m
        memory: 128Mi
      max:                   # max allowed limits
        cpu: "2"
        memory: 2Gi
      min:                   # min allowed requests
        cpu: 50m
        memory: 64Mi
    - type: PersistentVolumeClaim
      max:
        storage: 100Gi
      min:
        storage: 1Gi

Удаление Namespace и finalizer

Удаление namespace каскадно удаляет все его ресурсы. Namespace, застрявший в Terminating, обычно имеет finalizer, который не может завершиться: недоступный APIService (например, metrics-server) или CRD, чей контроллер исчез. Удаление finalizer принудительно завершает, но может оставить внешние ресурсы.

kubernetes
# delete a namespace (cascades all resources in it)
kubectl delete namespace dev

# if stuck in Terminating, inspect finalizers
kubectl get namespace dev -o yaml

# remove finalizer to force completion (DANGEROUS)
kubectl patch namespace dev -p '{"metadata":{"finalizers":null}}'

# resources that block deletion:
# - APIService unavailable (metrics-server removed)
# - custom resources whose CRD is gone
# - PVCs with attached PVs

# check what's still in the namespace
kubectl api-resources --verbs=list --namespaced -o name \
  | xargs -n 1 kubectl get -n dev --ignore-not-found

Стандартные Namespace

kube-system запускает control plane и дополнения (DNS, kube-proxy, CNI). kube-public хранит данные начальной загрузки, читаемые неаутентифицированными пользователями. kube-node-lease хранит heartbeats узлов как объекты Lease ради производительности. В default попадают нагрузки, если namespace не указан.

kubernetes
# built-in namespaces
kubectl get namespaces
# NAME              STATUS   AGE
# default           Active   30d   <- user workloads land here
# kube-system       Active   30d   <- control plane / addons
# kube-public       Active   30d   <- publicly readable (bootstrap)
# kube-node-lease   Active   30d   <- node heartbeats (leases)

# kube-system holds:
# - kube-dns / CoreDNS
# - kube-proxy
# - metrics-server
# - CNI, CSI, cloud provider controllers

# kube-public is readable by all (used for cluster info discovery)

Namespace и кластерная область

Большинство рабочих ресурсов имеют namespace; инфраструктура (nodes, PV, StorageClass, ClusterRoles) относится к кластеру. Service может нацеливаться только на pod в своём namespace. -A — сокращение для --all-namespaces, необходимо для видимости по всему кластеру.

kubernetes
# which resources are namespaced?
kubectl api-resources --namespaced=true
kubectl api-resources --namespaced=false

# namespaced: pods, services, deployments, configmaps, secrets
# cluster-scoped: nodes, namespaces, PVs, StorageClasses, ClusterRoles

# access across namespaces:
# - a Service selector only matches pods in the SAME namespace
# - cross-namespace refs require special controllers (e.g. external-dns)

# list resources across all namespaces
kubectl get pods --all-namespaces
kubectl get pods -A   # shorthand
08

Метки и селекторы

Синтаксис меток

Метки — пары ключ-значение для идентификации и группировки ресурсов. У ключей может быть необязательный префикс (DNS-поддомен, например app.kubernetes.io/). Метки предназначены для запросов и фильтрации, в отличие от аннотаций — произвольных неидентифицирующих метаданных.

kubernetes
# labels are key=value pairs
# key: prefix (optional DNS subdomain) + name
# value: string, up to 63 chars

metadata:
  labels:
    app: nginx
    tier: frontend
    env: prod
    app.kubernetes.io/name: nginx
    app.kubernetes.io/version: "1.25"

# view labels
kubectl get pods --show-labels

# add/overwrite a label
kubectl label pod nginx env=prod
kubectl label pod nginx env=staging --overwrite

# remove a label (trailing dash)
kubectl label pod nginx env-

Селекторы равенства и множеств

Два вида селекторов: по равенству (=, ==, !=) и по множествам (in, notin, exists, !exists). Несколько условий через запятую объединяются по И. Сервисы и Deployment в YAML используют селекторы равенства; kubectl -l поддерживает оба.

kubernetes
# equality-based: = == !=
kubectl get pods -l app=nginx
kubectl get pods -l env!=dev
kubectl get pods -l 'app=nginx,env=prod'   # AND of conditions

# set-based: in, notin, exists
kubectl get pods -l 'env in (prod,staging)'
kubectl get pods -l 'env notin (dev)'
kubectl get pods -l 'tier'                 # key exists
kubectl get pods -l '!canary'              # key does not exist

# combine equality and set-based
kubectl get pods -l 'app=nginx,env in (prod,staging)'

Навешивание меток

label меняет идентифицирующие метаданные — используйте для всего, на что должны совпадать селекторы. annotate — для неидентифицирующих метаданных (владелец, тикет, описание, подсказки инструментов). Узлы часто помечают метками топологии или оборудования для планирования.

kubernetes
# label a pod
kubectl label pod nginx app=nginx tier=web

# label all pods matching a selector
kubectl label pods -l app=oldapp app=newapp --overwrite

# label a node (for scheduling hints)
kubectl label node node-1 disktype=ssd

# remove a node label
kubectl label node node-1 disktype-

# list nodes by label
kubectl get nodes -l disktype=ssd

# annotate (non-identifying metadata)
kubectl annotate pod nginx owner=alice
kubectl annotate pod nginx description="web server"

Селекторы в манифестах

В YAML селекторы используют matchLabels (равенство) и matchExpressions (множества с In/NotIn/Exists/DoesNotExist). У Deployment селектор неизменяем после создания, а метки шаблона pod должны ему соответствовать. Сервисы поддерживают только matchLabels.

kubernetes
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx
spec:
  selector:
    matchLabels:            # equality-based
      app: nginx
    matchExpressions:       # set-based (optional)
      - key: env
        operator: In
        values: [prod, staging]
      - key: tier
        operator: Exists
  template:
    metadata:
      labels:
        app: nginx          # MUST match selector
        env: prod
        tier: web

Аннотации

Аннотации хранят неидентифицирующие метаданные для инструментов: kubectl apply сохраняет last-applied конфигурацию, cert-manager читает подсказки issuer, Prometheus — конфигурацию scrape, контроллеры — состояние выката. В отличие от меток, значения аннотаций могут быть большими JSON-блоками.

kubernetes
metadata:
  annotations:
    kubernetes.io/change-cause: "bump nginx to 1.26"
    prometheus.io/scrape: "true"
    prometheus.io/port: "9090"
    kubectl.kubernetes.io/last-applied-configuration: |
      {"apiVersion":"apps/v1",...}
    cert-manager.io/cluster-issuer: "letsencrypt-prod"

# view annotations
kubectl get pod nginx -o jsonpath='{.metadata.annotations}'

# annotate
kubectl annotate pod nginx owner=team-platform

# remove an annotation (trailing dash)
kubectl annotate pod nginx owner-

Рекомендуемые метки

Метки app.kubernetes.io/* — общий словарь, чтобы инструменты (Helm, операторы, дашборды) могли группировать все ресурсы приложения. name+instance однозначно идентифицируют релиз; component/part-of описывают иерархию; managed-by/created-by указывают владельца.

kubernetes
# shared recommended labels (app.kubernetes.io/*)
metadata:
  labels:
    app.kubernetes.io/name: nginx
    app.kubernetes.io/instance: nginx-prod
    app.kubernetes.io/version: "1.25"
    app.kubernetes.io/component: web
    app.kubernetes.io/part-of: storefront
    app.kubernetes.io/managed-by: helm
    app.kubernetes.io/created-by: controller-manager

# Helm applies these automatically; kubectl doesn't.
# They unify how tooling identifies an application's resources
# across Deployments, Services, Ingresses, ConfigMaps, etc.
09

ReplicaSet

Манифест ReplicaSet

ReplicaSet поддерживает стабильный набор pod-реплик, совпадающих с селектором, — он пересоздаёт pod при удалении или сбое. Почти всегда вместо него используют Deployment, который оборачивает ReplicaSet и добавляет rolling update и rollback.

kubernetes
apiVersion: apps/v1
kind: ReplicaSet
metadata:
  name: nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
        - name: nginx
          image: nginx:1.25
# kubectl get rs
# kubectl describe rs nginx

Как работает ReplicaSet

Контроллер ReplicaSet приводит фактическое число pod к желаемому по селектору. Каждый pod получает ownerReference на RS — поэтому kubectl get pod показывает 'Owned by ReplicaSet/nginx'. Масштабирование просто меняет желаемое число.

kubernetes
# the controller loop:
# 1. count pods matching selector
# 2. if fewer than replicas -> create from template
# 3. if more than replicas -> delete excess (arbitrary order)

# owned-by reference on each pod
kubectl get pod -l app=nginx -o jsonpath='{.items[*].metadata.ownerReferences}'

# if you delete a pod, the RS creates a new one immediately
kubectl delete pod <pod-name>
kubectl get pods -l app=nginx

# scale by editing replicas
kubectl scale rs nginx --replicas=5

ReplicaSet против ReplicationController

ReplicationController (исходный примитив v1) поддерживает только селекторы равенства и устарел. ReplicaSet (apps/v1) добавляет селекторы по множествам. На практике используйте Deployment: он управляет ReplicaSet за вас и даёт rolling update и rollback.

kubernetes
# ReplicationController (v1, legacy): equality-only selectors
# ReplicaSet (apps/v1, modern): set-based selectors (in, notin, exists)

# ReplicationController is deprecated; do not use.
apiVersion: v1
kind: ReplicationController      # legacy
# ...
# ReplicaSet is the successor:
apiVersion: apps/v1
kind: ReplicaSet                 # modern
# ...
# Deployment wraps ReplicaSet and is the recommended primitive:
apiVersion: apps/v1
kind: Deployment                 # use this in practice

Ручное масштабирование

kubectl scale меняет поле replicas. Если на тот же ресурс нацелен HPA, он переопределит ручное масштабирование при следующей сверке. Предпочитайте kubectl scale для разовых действий, а HPA — для постоянных эластичных нагрузок.

kubernetes
# scale a replicaset directly
kubectl scale rs nginx --replicas=5

# scale via patch
kubectl patch rs nginx -p '{"spec":{"replicas":5}}'

# scale multiple resources at once
kubectl scale deployment nginx deployment web --replicas=3

# scale by referencing a file
kubectl scale --replicas=5 -f nginx.yaml

# the autoscaler (HPA) will override manual scaling
# if it targets the same resource

Изменения шаблона и adoption

В отличие от Deployment, «голый» ReplicaSet не выкатывает изменения шаблона pod: новую спецификацию получают только новые pod (после удаления или масштабирования вверх). ReplicaSet «усыновит» любой осиротевший pod, совпадающий с его селектором, что может удивлять.

kubernetes
# changing the pod template does NOT update existing pods
# (unlike a Deployment, a bare ReplicaSet won't roll out)
kubectl edit rs nginx   # change image -> new pods use it, old ones don't

# delete old pods to force them onto the new template
kubectl delete pods -l app=nginx

# a ReplicaSet will ADOPT existing pods that match its selector
# even pods created independently — useful (and dangerous)

# orphaned pods (no owner) matching the selector are taken over
kubectl get pods -l app=nginx --show-kind

Удаление pod из ReplicaSet

Чтобы удалить pod без пересоздания ReplicaSet, либо сначала масштабируйте RS в 0, либо уберите ownerReferences у pod, чтобы RS им больше не владел. Полезно для отладки конкретного экземпляра или вытаскивания логов перед очисткой.

kubernetes
# detaching a pod from its ReplicaSet (so it isn't replaced)
kubectl patch pod <pod-name> \
  -p '{"metadata":{"ownerReferences":[]}}'

# now deleting this pod won't trigger a replacement,
# because the RS no longer owns it

# or scale the RS to 0 first, then delete
kubectl scale rs nginx --replicas=0
kubectl delete pod <pod-name>

# useful for debugging a specific failing pod instance
# without the RS immediately recreating it
10

StatefulSet

Манифест StatefulSet

StatefulSet даёт pod стабильную идентичность (имя, hostname, хранилище) и упорядоченный деплой и масштабирование. Требует headless serviceName. volumeClaimTemplates создаёт отдельный PVC на pod: даже если pod-0 перепланируется, он переподключает тот же том.

kubernetes
apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: mysql
spec:
  serviceName: mysql          # required: headless service
  replicas: 3
  selector:
    matchLabels:
      app: mysql
  template:
    metadata:
      labels:
        app: mysql
    spec:
      containers:
        - name: mysql
          image: mysql:8
          ports:
            - containerPort: 3306
          volumeMounts:
            - name: data
              mountPath: /var/lib/mysql
  volumeClaimTemplates:       # one PVC per pod
    - metadata:
        name: data
      spec:
        accessModes: ["ReadWriteOnce"]
        resources:
          requests:
            storage: 10Gi

Стабильная идентичность

Каждый pod получает стабильное порядковое имя (mysql-0, mysql-1, …) и стабильное DNS-имя через headless-сервис. При отказе узла pod-0 перепланируется в другое место, но сохраняет имя и переподключает свой том — критично для кластерных баз, зависящих от стабильного состава.

kubernetes
# pods are named <statefulset-name>-<ordinal>
# mysql-0, mysql-1, mysql-2
kubectl get pods -l app=mysql

# each pod has stable DNS (via the headless service):
#   mysql-0.mysql.default.svc.cluster.local
#   mysql-1.mysql.default.svc.cluster.local

# stable hostname inside the pod:
kubectl exec mysql-0 -- hostname
# -> mysql-0

# ordinal index also exposed:
kubectl exec mysql-0 -- sh -c 'echo $HOSTNAME'
# -> mysql-0

# pod identity persists across reschedules

Стабильное хранилище

volumeClaimTemplates создаёт по одному PVC на pod с предсказуемым именем (data-mysql-0, …). PVC переживают удаление pod и StatefulSet: это предотвращает потерю данных, но означает, что для освобождения хранилища PVC нужно удалить явно. Один и тот же том всегда переподключается к тому же порядковому pod.

kubernetes
# one PVC per pod, named <volumeClaimTemplate-name>-<pod-name>
kubectl get pvc
# NAME        STATUS   VOLUME       CAPACITY   ...
# data-mysql-0   Bound   pvc-aaa      10Gi
# data-mysql-1   Bound   pvc-bbb      10Gi
# data-mysql-2   Bound   pvc-ccc      10Gi

# when pod-0 is rescheduled, it re-binds data-mysql-0
# deleting the StatefulSet does NOT delete PVCs by default
# (protects from accidental data loss)

# to actually delete the data:
kubectl delete pvc data-mysql-0 data-mysql-1 data-mysql-2

Упорядоченный деплой и управление pod

OrderedReady (по умолчанию) создаёт pod строго по порядку 0→1→2 и удаляет в обратном, — нужно системам, где primary должен подняться раньше реплик. Parallel создаёт и удаляет все pod одновременно — быстрее для симметричных шардированных хранилищ (Cassandra, Elasticsearch).

kubernetes
spec:
  podManagementPolicy: OrderedReady   # default: strict order
  # podManagementPolicy: Parallel      # create/delete all at once

  replicas: 3
  # OrderedReady: create pod-0, then pod-1, then pod-2 (each waits for Ready)
  # deletion is reverse: pod-2, pod-1, pod-0

  # Parallel: all pods created/deleted simultaneously
  # identity and storage remain stable either way

# check policy
kubectl get statefulset mysql -o jsonpath='{.spec.podManagementPolicy}'

# parallel is great for sharded stores that don't need bootstrap order

Rolling update

Rolling update StatefulSet идёт в обратном порядке (от N-1 к 0). partition позволяет сначала выкатить канарейкой pod с наибольшим номером. OnDelete приостанавливает обновления, пока вы вручную не удалите pod, — полезно для контролируемых миграций. Выкаты медленнее, чем у Deployment, из-за порядка.

kubernetes
spec:
  updateStrategy:
    type: RollingUpdate
    rollingUpdate:
      partition: 2          # only pods with ordinal >= 2 update
      maxUnavailable: 1     # (default 1) allowed down
  # type: OnDelete  -> only update when pod is manually deleted

# partition enables canaries: set partition=N to update
# only the top N pods; lower to 0 to roll out to all.

kubectl rollout status statefulset/mysql
# waits for all pods to be updated

# StatefulSets also support rollout history/undo,
# but only when the change is in the pod template

Связь с headless-сервисом

Именно headless-сервис (clusterIP: None), указанный в spec.serviceName, обеспечивает стабильный DNS для каждого pod. Без него StatefulSet не создаст pod. Клиенты разрешают имя сервиса для round-robin или pod-0.svc, чтобы закрепиться на primary. Не забудьте создать Service.

kubernetes
apiVersion: v1
kind: Service
metadata:
  name: mysql
spec:
  clusterIP: None         # headless
  selector:
    app: mysql
  ports:
    - port: 3306
---
# StatefulSet references this service via spec.serviceName
# this gives each pod a stable DNS:
#   mysql-0.mysql.default.svc.cluster.local

# clients can:
# - resolve mysql -> any pod IP (load-balanced by DNS round-robin)
# - resolve mysql-0.mysql -> pod-0's IP (pin to a specific replica)

# required: serviceName MUST match the headless service name
11

DaemonSet

Манифест DaemonSet

DaemonSet запускает ровно один pod на каждом узле (с учётом ограничений планирования). Идеален для агентов уровня узла: сборщиков логов, мониторинга, хранилища, CNI, ingress-контроллеров. Новые узлы автоматически получают pod; у удалённых pod собирается сборщиком мусора.

kubernetes
apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: log-agent
  namespace: kube-system
  labels:
    app: log-agent
spec:
  selector:
    matchLabels:
      app: log-agent
  template:
    metadata:
      labels:
        app: log-agent
    spec:
      containers:
        - name: agent
          image: fluent-bit:2.2
          resources:
            requests:
              cpu: 100m
              memory: 128Mi
      # one pod per (matching) node automatically

Планирование на узлы

nodeSelector — простейшее ограничение (все пары key=value должны совпасть). nodeAffinity добавляет операторы In/NotIn/Exists и правила preferred/required. DaemonSet учитывает их как любой pod: вместе с tolerations можно запускать агентов и на tainted-узлах control plane.

kubernetes
spec:
  template:
    spec:
      nodeSelector:                # simplest: must match all
        disktype: ssd

      # more flexible affinity
      affinity:
        nodeAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
            nodeSelectorTerms:
              - matchExpressions:
                  - key: kubernetes.io/os
                    operator: In
                    values: [linux]

      # only run on nodes labeled role=logging
      nodeSelector:
        role: logging

      tolerations:                 # tolerate tainted nodes
        - key: node-role.kubernetes.io/control-plane
          operator: Exists

Стратегия обновления

RollingUpdate (по умолчанию) обновляет pod узел за узлом, ограничиваясь maxUnavailable (число или %). OnDelete приостанавливает обновления, пока вы вручную не удалите каждый pod, — полезно, когда нужен контроль по узлам. maxSurge по умолчанию 0 (DaemonSet редко хочет лишние pod).

kubernetes
spec:
  updateStrategy:
    type: RollingUpdate           # default
    rollingUpdate:
      maxUnavailable: 1           # how many nodes update at once
      maxSurge: 0                 # (default 0) no extra pods
  # type: OnDelete               # only update when old pod is deleted

# trigger an update (e.g. new image)
kubectl set image daemonset/log-agent agent=fluent-bit:2.3

# watch rollout
kubectl rollout status daemonset/log-agent -n kube-system

# rollout restart (recreate pods on every node)
kubectl rollout restart daemonset/log-agent -n kube-system

Taints и tolerations

Taints отталкивают pod; tolerations позволяют конкретным pod игнорировать taint. Узлы control plane помечены NoSchedule, чтобы рабочие нагрузки туда не попадали, — агенты уровня узла терпят это, чтобы работать везде. NoExecute ещё и выселяет уже работающие не-терпящие pod.

kubernetes
# inspect a node's taints
kubectl describe node node-1 | grep Taints
# Taints: node-role.kubernetes.io/control-plane:NoSchedule

# tolerate control-plane so the agent runs there too
spec:
  template:
    spec:
      tolerations:
        - key: node-role.kubernetes.io/control-plane
          operator: Exists
          effect: NoSchedule
        - key: node.kubernetes.io/disk-pressure
          operator: Exists
          effect: NoExecute

# taint effects: NoSchedule | NoExecute | PreferNoSchedule

Сценарии использования DaemonSet

DaemonSet — стандартная форма развёртывания инфраструктуры уровня узла. Им часто нужен привилегированный доступ (hostNetwork, hostPID, hostPath) для работы: выдавайте его осознанно и только доверенным образам. Никогда не используйте DaemonSet для прикладных нагрузок, которые должны масштабироваться горизонтально.

kubernetes
# classic DaemonSet workloads (node-level agents):
# - log collection:        fluent-bit, filebeat, promtail
# - monitoring:            node-exporter, datadog-agent
# - networking:            kube-proxy, CNI plugins, ingress controllers
# - storage:               CSI node plugins, Rook/Ceph
# - security:              Falco, Tetragon, runtime security
# - GPU/FPGA drivers:      nvidia-device-plugin

# storage / device plugins often need:
spec:
  template:
    spec:
      hostNetwork: true        # use node network namespace
      hostPID: true            # see node processes
      hostPath:                # mount node paths
        - path: /var/log
        - path: /var/lib/docker/containers

Статус DaemonSet

DESIRED равно числу узлов, подходящих под ограничения планирования; CURRENT/READY показывают, сколько pod существует и проходит readiness. -o wide — самый простой способ увидеть, на какой узел попал каждый pod. DaemonSet поддерживает rollout history/undo как Deployment.

kubernetes
# desired = number of matching nodes
kubectl get daemonset log-agent -n kube-system
# NAME         DESIRED   CURRENT   READY   UP-TO-DATE   AVAILABLE
# log-agent    5         5         5       5            5

# show which nodes a DaemonSet pod landed on
kubectl get pods -n kube-system -l app=log-agent -o wide

# rollout history
kubectl rollout history daemonset/log-agent -n kube-system

# rollback
kubectl rollout undo daemonset/log-agent -n kube-system

# check a per-node pod's logs
kubectl logs -n kube-system log-agent-abcde
12

Job и CronJob

Манифест Job

Job запускает pod, пока заданное число из них не завершится успешно (completions). restartPolicy должен быть Never или OnFailure (не Always: это для долгоживущих нагрузок). backoffLimit ограничивает повторы; activeDeadlineSeconds ограничивает общее время выполнения.

kubernetes
apiVersion: batch/v1
kind: Job
metadata:
  name: pi
spec:
  completions: 1              # how many successful pods needed
  parallelism: 1              # how many run concurrently
  backoffLimit: 6             # retries before marking Failed
  activeDeadlineSeconds: 600  # hard timeout
  template:
    spec:
      restartPolicy: Never    # OnFailure | Never
      containers:
        - name: pi
          image: perl
          command: ["perl", "-Mbignum=bpi", "-wle", "print bpi(2000)"]
# kubectl get jobs
# kubectl logs job/pi

Completions и parallelism

completions — сколько успешных pod нужно Job; parallelism — сколько работает одновременно. Indexed Jobs дают каждому pod порядковый номер (переменная JOB_COMPLETION_INDEX) — отлично для шардированной пакетной обработки, где каждый pod берёт свой фрагмент. NonIndexed (по умолчанию) просто требует N успехов откуда угодно.

kubernetes
spec:
  completions: 5         # 5 successful pods total
  parallelism: 2         # 2 pods run at a time
  backoffLimit: 4
  # default completionMode: NonIndexed (any 5 successes)
  completionMode: Indexed
  # Indexed: pods get 0..N-1 in JOB_COMPLETION_INDEX env,
  # useful for sharded work (each pod handles one shard)

  template:
    spec:
      restartPolicy: OnFailure
      containers:
        - name: worker
          image: worker:1.0

# set via kubectl
kubectl create job pi --image=perl -- perl -Mbignum=bpi -wle "print bpi(2000)"

Backoff и таймауты Job

backoffLimit повторяет неудачные pod (с экспоненциальной задержкой). activeDeadlineSeconds — жёсткий потолок: при достижении Job помечается Failed даже с оставшимися попытками. ttlSecondsAfterFinished автоматически очищает завершённые Job. podFailurePolicy (1.31+) позволяет быстро падать на определённых кодах возврата или игнорировать добровольные выселения.

kubernetes
spec:
  backoffLimit: 6            # default 6, retries on failure
  activeDeadlineSeconds: 3600  # hard wall, even if retries remain
  ttlSecondsAfterFinished: 86400  # auto-delete Job 1 day after done
  startingDeadlineSeconds: 300  # (CronJob only) miss window

  # pod failure handling (v1.31+):
  podFailurePolicy:
    rules:
      - action: FailJob
        onExitCodes:
          operator: In
          values: [42]      # exit 42 -> don't retry, fail fast
      - action: Count
        onPodConditions:
          - type: DisruptionTarget   # don't count voluntary evictions

  template:

Манифест CronJob

CronJob создаёт Job по расписанию cron (5 полей: минута час день месяц день_недели). concurrencyPolicy управляет пересечением запусков: Forbid пропускает новый запуск, если предыдущий ещё идёт; Replace убивает старый и запускает новый. timeZone (1.27+) избавляет от арифметики UTC.

kubernetes
apiVersion: batch/v1
kind: CronJob
metadata:
  name: backup
spec:
  schedule: "0 2 * * *"          # 5-field cron: 02:00 daily
  timeZone: "Asia/Shanghai"
  concurrencyPolicy: Forbid      # Allow | Forbid | Replace
  successfulJobsHistoryLimit: 3
  failedJobsHistoryLimit: 1
  startingDeadlineSeconds: 200
  jobTemplate:
    spec:
      backoffLimit: 2
      template:
        spec:
          restartPolicy: OnFailure
          containers:
            - name: backup
              image: backup:1.0
# kubectl get cronjob
# kubectl get jobs

Suspend и история CronJob

suspend: true приостанавливает CronJob, не удаляя его, — удобно во время инцидентов. Лимиты истории держат список Job управляемым (по умолчанию 3 успеха / 1 ошибка). kubectl create job --from=cronjob/X немедленно запускает шаблон — идеально для ручных триггеров и дозапуска пропущенных прогонов.

kubernetes
spec:
  schedule: "*/5 * * * *"
  suspend: true                # pause without deleting the CronJob
  successfulJobsHistoryLimit: 3   # default 3
  failedJobsHistoryLimit: 1       # default 1

# toggle suspend
kubectl patch cronjob backup -p '{"spec":{"suspend":true}}'
kubectl patch cronjob backup -p '{"spec":{"suspend":false}}'

# trigger a one-off run immediately
kubectl create job --from=cronjob/backup manual-backup

# clean up old jobs manually
kubectl delete jobs -l job-name=backup

Расписание CronJob и крайние случаи

Стандартный cron из 5 полей. Когда ограничены и день месяца, и день недели, cron срабатывает при совпадении ЛЮБОГО из них (семантика ИЛИ) — классическая ловушка. Если запланированное время CronJob пропущено сверх startingDeadlineSeconds, прогон пропускается, а не дозапускается.

kubernetes
# cron syntax (5 fields):
# ┌───────────── minute (0-59)
# │ ┌───────────── hour (0-23)
# │ │ ┌───────────── day of month (1-31)
# │ │ │ ┌───────────── month (1-12)
# │ │ │ │ ┌───────────── day of week (0-6, Sun=0)
# "*/5 * * * *"      every 5 minutes
# "0 2 * * *"        daily at 02:00
# "0 0 * * 0"        weekly Sunday midnight
# "0 0 1 * *"        monthly on the 1st
# "30 3-5 * * *"     03:30, 04:30, 05:30

# gotchas:
# - day-of-month AND day-of-week both set => OR (not AND)
# - if startingDeadlineSeconds is missed, the run is skipped
# - control-plane restart can skip a tick if the schedule is missed
# - cron interprets literal fields; prefer timeZone over UTC math
13

Ingress

Манифест Ingress

Ingress публикует HTTP/HTTPS-маршруты извне кластера к Сервисам; управляется Ingress-контроллером (nginx, traefik, ALB, …). ingressClassName выбирает, какой контроллер его обрабатывает. Каждое правило сопоставляет хост + путь с backend'ом service+port.

kubernetes
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: web
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
spec:
  ingressClassName: nginx
  rules:
    - host: app.example.com
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: web
                port:
                  number: 80
          - path: /api
            pathType: Prefix
            backend:
              service:
                name: api
                port:
                  number: 8080

Ingress с TLS

Записи tls привязывают TLS-секрет (тип kubernetes.io/tls с tls.crt + tls.key) к одному или нескольким хостам. Ingress-контроллер завершает TLS и проксирует открытый HTTP к backend. cert-manager может автоматически выпускать и ротировать сертификаты Let's Encrypt по аннотации cluster-issuer.

kubernetes
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: web-tls
spec:
  ingressClassName: nginx
  tls:
    - hosts:
        - app.example.com
        - www.example.com
      secretName: web-tls-secret   # kubernetes.io/tls secret
  rules:
    - host: app.example.com
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: web
                port:
                  number: 80

# auto-issue certs with cert-manager:
# annotations:
#   cert-manager.io/cluster-issuer: letsencrypt-prod

Правила Ingress и default backend

defaultBackend обрабатывает трафик, не подошедший ни под одно правило (без хоста или с несовпавшим путём). Несколько правил позволяют одному Ingress маршрутизировать много виртуальных хостов. У каждого правила может быть несколько path-backend'ов: один Ingress может обслуживать всю топологию маршрутизации приложения.

kubernetes
spec:
  ingressClassName: nginx
  defaultBackend:                # catch-all for unmatched traffic
    service:
      name: default-svc
      port:
        number: 80
  rules:
    - host: app.example.com
      http:
        paths:
          - path: /api
            pathType: Prefix
            backend:
              service: { name: api, port: { number: 8080 } }
    - host: blog.example.com     # different host -> different svc
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service: { name: blog, port: { number: 80 } }

IngressClass

IngressClass объявляет контроллер (например, k8s.io/ingress-nginx). Ingress ссылаются на неё через spec.ingressClassName, чтобы несколько контроллеров сосуществовали. Ровно один класс может быть помечен как default аннотацией is-default-class: новые Ingress без явного класса используют его.

kubernetes
apiVersion: networking.k8s.io/v1
kind: IngressClass
metadata:
  name: nginx
  annotations:
    ingressclass.kubernetes.io/is-default-class: "true"
spec:
  controller: k8s.io/ingress-nginx

# an Ingress picks a class via spec.ingressClassName
# (replaces the deprecated kubernetes.io/ingress.class annotation)

# multiple IngressClasses in one cluster:
# - nginx    (community ingress-nginx)
# - traefik  (Traefik controller)
# - alb      (AWS ALB)
# only one IngressClass can be marked default

Типы путей

Exact совпадает с путём буквально; Prefix совпадает по целым сегментам пути (/api совпадает с /api и /api/foo, но не с /apix). ImplementationSpecific отдаёт решение контроллеру, например regex в nginx. Для переносимого поведения предпочитайте Prefix или Exact: ImplementationSpecific привязывает вас к одному контроллеру.

kubernetes
spec:
  rules:
    - host: app.example.com
      http:
        paths:
          - path: /api/v1
            pathType: Exact        # only /api/v1 (exact match)
            backend: ...
          - path: /api
            pathType: Prefix       # /api, /api/, /api/x (prefix match)
            backend: ...
          - path: /old
            pathType: ImplementationSpecific  # controller decides
            backend: ...

# Prefix matches path segments, not raw string prefix:
# /api   matches /api, /api/, /api/x  but NOT /apix
# Exact  matches the path verbatim
# ImplementationSpecific defers to the controller

Аннотации (контроллер nginx)

Аннотации, специфичные для контроллера, настраивают поведение сверх стандартной спецификации Ingress. У ingress-nginx их десятки: rewrite-target, ssl-redirect, body-size, таймауты, CORS, basic auth, фрагменты конфигурации. Они привязаны к контроллеру: перенос на другой контроллер означает их переписывание.

kubernetes
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: web
  annotations:
    kubernetes.io/ingress.class: nginx          # legacy form
    nginx.ingress.kubernetes.io/rewrite-target: /$2
    nginx.ingress.kubernetes.io/ssl-redirect: "true"
    nginx.ingress.kubernetes.io/proxy-body-size: "50m"
    nginx.ingress.kubernetes.io/proxy-read-timeout: "3600"
    nginx.ingress.kubernetes.io/cors-allow-origin: "https://app.example.com"
    nginx.ingress.kubernetes.io/auth-type: basic
    nginx.ingress.kubernetes.io/auth-secret: basic-auth
    nginx.ingress.kubernetes.io/configuration-snippet: |
      more_set_headers "X-Frame-Options: DENY";
spec:
  rules:
    - host: app.example.com
      http:
        paths:
          - path: /v1(/|$)(.*)
            pathType: ImplementationSpecific
            backend:
              service: { name: api, port: { number: 8080 } }
14

Тома (PV/PVC)

Манифест PersistentVolume

PersistentVolume (PV) — кластерный фрагмент хранилища, выделенный администратором или динамически через StorageClass. accessModes описывают, как его можно монтировать. reclaimPolicy управляет судьбой хранилища, когда PVC освобождается.

kubernetes
apiVersion: v1
kind: PersistentVolume
metadata:
  name: pv-1
spec:
  capacity:
    storage: 10Gi
  accessModes:
    - ReadWriteOnce        # RWO: one node R/W
  persistentVolumeReclaimPolicy: Retain   # Retain | Delete | Recycle
  storageClassName: manual
  hostPath:                # for dev only (single node)
    path: /mnt/data
  # nfs:
  #   server: 10.0.0.1
  #   path: /export/data
  # csi:
  #   driver: ebs.csi.aws.com
  #   volumeHandle: vol-xxxx

Манифест PersistentVolumeClaim

PersistentVolumeClaim (PVC) — запрос на хранилище в namespace. Контроллер связывает его с подходящим PV (accessModes, достаточная ёмкость, тот же StorageClass). При наличии StorageClass по умолчанию пустой storageClassName запускает динамическое выделение.

kubernetes
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: data-claim
spec:
  accessModes:
    - ReadWriteOnce
  storageClassName: manual
  resources:
    requests:
      storage: 5Gi
  volumeMode: Filesystem     # Filesystem | Block
  selector:                  # optional: filter PVs by labels
    matchLabels:
      disktype: ssd
# kubectl get pvc
# STATUS: Pending -> Bound once a matching PV is found

Режимы доступа

AccessModes описывают семантику монтирования, но фактическая поддержка зависит от хранилища. EBS/GCE PD/Azure Disk поддерживают только RWO. RWX (чтение/запись с нескольких узлов) требует NFS, CephFS или распределённой файловой системы. RWOP (1.27+) ограничивает одним pod даже на одном узле.

kubernetes
# four access modes (support is driver-specific):
# - ReadWriteOnce  (RWO):  mounted R/W by ONE node
# - ReadOnlyMany   (ROX):  mounted R/O by MANY nodes
# - ReadWriteMany  (RWX):  mounted R/W by MANY nodes
# - ReadWriteOncePod (RWOP): mounted R/W by ONE pod (1.27+)

# examples by backend:
# AWS EBS, GCE PD, Azure Disk:  RWO only
# NFS:                          RWO, ROX, RWX
# CephFS, Portworx:             RWO, RWX
# Block volumes:                RWO

# RWX is required for pods on different nodes
# to share the same volume (e.g. read-only assets)

Политика освобождения

Retain сохраняет данные ради безопасности: PV нужно вручную очистить и перепривязать. Delete (по умолчанию для динамического выделения) уничтожает и PV, и нижележащее хранилище при удалении PVC. Recycle устарел. У Released PV с Retain нужно очистить claimRef перед перепривязкой.

kubernetes
# what happens when a PVC is deleted:
# - Retain:   PV stays, data preserved; PV must be manually
#             reclaimed (delete data, then delete PV) before reuse
# - Delete:   PV and the underlying storage are deleted (dynamic only)
# - Recycle:  deprecated; ran scrub on the volume

# change policy on an existing PV
kubectl patch pv pv-1 -p '{"spec":{"persistentVolumeReclaimPolicy":"Retain"}}'

# a released PV (PVC deleted, policy Retain) is stuck:
#   phase=Released, claimRef still set
# to reuse: clear claimRef
kubectl patch pv pv-1 --type json -p '[{"op":"remove","path":"/spec/claimRef"}]'

PVC в Pod

Монтируйте PVC как любой том через persistentVolumeClaim.claimName. subPath монтирует подкаталог — удобно для совместного использования одного тома несколькими pod и путями. Тома RWO могут монтировать несколько pod, но только на одном узле; межнодовое монтирование даёт ошибки multi-attach.

kubernetes
apiVersion: v1
kind: Pod
metadata:
  name: db
spec:
  volumes:
    - name: data
      persistentVolumeClaim:
        claimName: data-claim
  containers:
    - name: db
      image: postgres:16
      volumeMounts:
        - name: data
          mountPath: /var/lib/postgresql/data
          subPath: pgdata       # mount a subdirectory of the volume

# a PVC is namespaced and bound to ONE PV
# RWO PVCs can be mounted by multiple pods on the SAME node
# (e.g. one writer, several readers on that node)

Статическое и динамическое выделение

Статическое выделение требует, чтобы админ заранее создал PV: нормально для NFS, но мучительно в масштабе. Динамическое выделение позволяет PVC запускать создание тома по требованию через provisioner StorageClass. Современные кластеры почти всегда используют динамическое выделение; статическое — для общих и устаревших хранилищ.

kubernetes
# STATIC: admin pre-creates PVs; PVCs bind to them.
#   Good for: pre-existing NFS exports, manual capacity planning.

# DYNAMIC: PVC requests storage; StorageClass provisions a PV
#   automatically (AWS EBS, GCE PD, Ceph, local-path, etc.)

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: dynamic-claim
spec:
  storageClassName: ebs-sc      # triggers dynamic provisioning
  accessModes: ["ReadWriteOnce"]
  resources:
    requests:
      storage: 20Gi

# no PV exists -> provisioner creates one -> binds to PVC
# kubectl get pvc dynamic-claim -> Bound
# kubectl get pv -> shows the dynamically-created PV
15

StorageClass

Манифест StorageClass

StorageClass описывает «вариант» динамически выделяемого хранилища: provisioner (CSI-драйвер), параметры (тип диска, шифрование, fsType) и политики. PVC ссылаются на него через spec.storageClassName. В кластере обычно несколько классов (быстрый SSD, массовый HDD, NFS, …).

kubernetes
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: ebs-sc
provisioner: ebs.csi.aws.com
parameters:
  type: gp3
  fsType: ext4
  encrypted: "true"
reclaimPolicy: Delete            # Retain | Delete
volumeBindingMode: WaitForFirstConsumer
allowVolumeExpansion: true
mountOptions:
  - noatime
# kubectl get storageclass

StorageClass по умолчанию

Ровно один StorageClass может быть по умолчанию (аннотация is-default-class: true). PVC без storageClassName автоматически его используют — удобно для пользователей, которым всё равно, какой backend получат. kubectl get sc показывает, какой класс помечен (default).

kubernetes
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: standard
  annotations:
    storageclass.kubernetes.io/is-default-class: "true"
provisioner: kubernetes.io/no-provisioner
volumeBindingMode: WaitForFirstConsumer

# a PVC with no storageClassName uses the default
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: auto
spec:
  accessModes: ["ReadWriteOnce"]
  resources:
    requests:
      storage: 5Gi
# (no storageClassName set -> uses 'standard')

Provisioner

kubernetes.io/no-provisioner означает только статическую привязку (без динамического создания). Всё реальное динамическое выделение использует CSI-драйверы: облачные провайдеры поставляют свои (ebs.csi.aws.com и т. д.), а варианты для bare metal (Longhorn, Rook/Ceph, local-path) закрывают остальное. Параметры полностью зависят от provisioner.

kubernetes
# built-in (no external driver): only static binding
provisioner: kubernetes.io/no-provisioner

# cloud CSI drivers (dynamic):
provisioner: ebs.csi.aws.com          # AWS EBS
provisioner: pd.csi.storage.gke.io    # GCE PD
provisioner: disk.csi.azure.com       # Azure Disk
provisioner: nfs.csi.k8s.io           # NFS

# popular self-hosted:
provisioner: driver.longhorn.io       # Longhorn
provisioner: rook-ceph.ceph.com       # Rook/Ceph
provisioner: rancher.io/local-path    # local-path (dev)

# parameters are provisioner-specific
# (e.g. AWS: type=gp3|iops=3000|encrypted=true)

Режим привязки тома

Immediate привязывает PVC сразу при создании — рискованно для зональных дисков, так как pod может оказаться в другой зоне. WaitForFirstConsumer откладывает привязку до момента, когда pod реально использует PVC, поэтому том попадает в нужную зону. Всегда используйте WaitForFirstConsumer для зональных облачных дисков.

kubernetes
spec:
  volumeBindingMode: WaitForFirstConsumer
  # ^ default for many CSI drivers
  # alternatives:
  # volumeBindingMode: Immediate

# Immediate: PVC binds/provisions as soon as created
#   risk: volume created in zone A, pod scheduled in zone B
#   -> multi-attach / cross-zone latency issues

# WaitForFirstConsumer: delays binding until a pod using the PVC
#   is scheduled. The PV is then created in the pod's zone.
#   REQUIRED for topology-constrained backends (EBS, etc.)

# topology constraints come from the CSI driver via
# AllowedTopologies

ReclaimPolicy в StorageClass

reclaimPolicy в StorageClass задаёт политику для каждого динамически выделенного PV. Delete (по умолчанию) уничтожает том при удалении PVC: эффективно, но опасно для production-данных. Чтобы сохранить данные, переключите PV на Retain до удаления PVC или сразу используйте класс с Retain.

kubernetes
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: ebs-temp
provisioner: ebs.csi.aws.com
reclaimPolicy: Delete            # default for dynamic volumes
# reclaimPolicy: Retain          # keep data after PVC delete

# the StorageClass policy becomes the PV's policy
# when a PV is dynamically provisioned

# to preserve data, either:
# 1. use a Retain StorageClass
# 2. patch the dynamically-created PV to Retain before deleting PVC:
kubectl patch pv pvc-xxxx -p '{"spec":{"persistentVolumeReclaimPolicy":"Retain"}}'

# then delete PVC safely; data survives

Расширение тома

allowVolumeExpansion: true позволяет пользователю увеличить PVC, изменив spec.resources.requests.storage. CSI-драйвер расширяет нижележащий том, затем kubelet расширяет файловую систему при следующем монтировании. Уменьшение не поддерживается никогда. Большинство облачных CSI-драйверов поддерживают онлайн-расширение (без размонтирования).

kubernetes
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: ebs-sc
provisioner: ebs.csi.aws.com
allowVolumeExpansion: true       # must be true to resize

# then resize by editing the PVC's requested size
kubectl patch pvc data-claim -p '{"spec":{"resources":{"requests":{"storage":"50Gi"}}}}'

# status.conditions shows Resizing / FileSystemResizePending
kubectl describe pvc data-claim

# requirements:
# - StorageClass.allowVolumeExpansion = true
# - driver supports online expansion (most CSI drivers do)
# - shrinking is NOT supported (only grow)
# - FilesystemResize happens after the PV is expanded
16

Helm

Установка и релизы Helm

Helm упаковывает манифесты Kubernetes в «чарт» и управляет ими как «релизом». install создаёт релиз; upgrade применяет изменения; upgrade --install идемпотентен. Релизы отслеживаются Secret/ConfigMap в namespace — так работает rollback.

kubernetes
# add and update a chart repo
helm repo add bitnami https://charts.bitnami.com/bitnami
helm repo update

# search for charts
helm search repo nginx
helm search hub wordpress   # searches Artifact Hub

# install a chart (creates a release)
helm install my-nginx bitnami/nginx --namespace web --create-namespace

# upgrade an existing release
helm upgrade my-nginx bitnami/nginx --set replicaCount=3

# upgrade + install in one idempotent command
helm upgrade --install my-nginx bitnami/nginx -f values.yaml

# uninstall
helm uninstall my-nginx -n web

# list releases
helm list -n web
helm list --all-namespaces

Структура чарта

Чарт — каталог шаблонизированного YAML плюс значения по умолчанию. Chart.yaml хранит метаданные; values.yaml — значения по умолчанию; templates/ — Go-шаблоны, рендерящиеся с этими значениями. helm create создаёт рабочий чарт. helm lint ловит ошибки схемы и шаблонов до публикации.

kubernetes
my-chart/
├── Chart.yaml          # chart metadata (name, version, apiVersion)
├── values.yaml         # default values (overridable)
├── charts/             # chart dependencies (subcharts)
├── templates/          # Go-templated YAML
│   ├── deployment.yaml
│   ├── service.yaml
│   ├── _helpers.tpl    # named templates (partials)
│   └── NOTES.txt       # post-install notes
├── templates.yaml      # (optional) CRDs to install before templates
└── README.md

# create a new chart skeleton
helm create my-chart

# lint a chart
helm lint my-chart

# package into a .tgz
helm package my-chart

Значения и переопределения

values.yaml хранит значения чарта по умолчанию. Переопределяйте через --set (для скаляров) или -f (для целых файлов). helm show values перечисляет все ключи, которые принимает чарт. helm template рендерит манифесты, не трогая кластер, — необходимо для диффа того, что реально применит релиз.

kubernetes
# values.yaml (chart defaults)
image:
  repository: nginx
  tag: "1.25"
replicaCount: 2
service:
  type: ClusterIP
  port: 80

# override on the command line
helm upgrade --install web my-chart \
  --set replicaCount=5 \
  --set image.tag=1.26 \
  --set service.type=LoadBalancer

# override from a file
helm upgrade --install web my-chart -f prod-values.yaml

# see all values a chart supports
helm show values bitnami/nginx

# rendered output (debug, no install)
helm template web my-chart -f prod-values.yaml

Шаблоны и встроенные объекты

Шаблоны используют синтаксис Go templates с функциями Sprig. .Release.Name делает каждую установку уникальной; .Values даёт значения чарта; .Chart берёт данные из Chart.yaml. Функция default подставляет запасные значения. Безопасные имена через .Release.Name позволяют одному чарту запускать много релизов в одном namespace.

kubernetes
# built-in template objects:
#   .Values         chart values (after overrides)
#   .Release        release metadata (Name, Namespace, Service, Revision, IsInstall, IsUpgrade)
#   .Chart          Chart.yaml contents
#   .Files          files in the chart
#   .Capabilities   cluster capabilities (KubeVersion, APIVersions)
#   .Template       current template info

apiVersion: apps/v1
kind: Deployment
metadata:
  name: {{ .Release.Name }}-app
  labels:
    app.kubernetes.io/instance: {{ .Release.Name }}
    app.kubernetes.io/managed-by: {{ .Release.Service }}
spec:
  replicas: {{ .Values.replicaCount | default 1 }}
  selector:
    matchLabels:
      app: {{ .Release.Name }}
  template:
    metadata:
      labels:
        app: {{ .Release.Name }}

Репозиторий Helm

Helm 3 поддерживает и классические HTTP-репозитории чартов, и OCI-registry (helm push/pull oci://…). OCI — современный путь, дружелюбный к подписи. helm repo update обновляет индексы: всегда запускайте перед upgrade, чтобы получить свежие версии чартов. Artifact Hub (helm search hub) индексирует публичные чарты.

kubernetes
# add a chart repository
helm repo add bitnami https://charts.bitnami.com/bitnami
helm repo add jetstack https://charts.jetstack.io

# list configured repos
helm repo list

# update repo indexes
helm repo update

# remove a repo
helm repo remove bitnami

# push to OCI registry (Helm 3+)
helm registry login registry.example.com
helm package my-chart
helm push my-chart-0.1.0.tgz oci://registry.example.com/charts

# pull an OCI chart
helm pull oci://registry.example.com/charts/my-chart --version 0.1.0

Rollback и история

Каждая установка и обновление создаёт нумерованную ревизию, хранимую как Secret. helm rollback мгновенно переключает на предыдущую ревизию — главная фича Helm по сравнению с обычным kubectl apply. helm get values показывает, что реально развёрнуто, — бесценно для отладки расхождений состояния.

kubernetes
# view release history
helm history my-nginx -n web

# rollback to a previous revision
helm rollback my-nginx 1 -n web

# get rendered manifests of a deployed release
helm get manifest my-nginx -n web

# get the values used at install/upgrade
helm get values my-nginx -n web
helm get values my-nginx -n web --all   # incl. chart defaults

# get all info (hooks, manifest, values, notes)
helm get all my-nginx -n web

# wait for resources to be ready on install/upgrade
helm upgrade --install my-nginx bitnami/nginx --wait --timeout 5m
17

NetworkPolicy

Манифест NetworkPolicy

NetworkPolicy — правило firewall для pod. Пустой podSelector выбирает все pod в namespace; пустой список правил запрещает весь трафик этого типа. Политики аддитивны: pod разрешён, если разрешает ЛЮБАЯ политика. Нужен поддерживающий CNI; обычный flannel их игнорирует.

kubernetes
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: default-deny
  namespace: prod
spec:
  podSelector: {}             # selects ALL pods in the namespace
  policyTypes:
    - Ingress
    - Egress
  # no ingress/egress rules => deny all traffic of that type
# effect: pods in 'prod' can't send or receive ANY traffic
# until another policy explicitly allows it

# REQUIRES a CNI that supports NetworkPolicy
# (Calico, Cilium, Weave, kube-router; NOT flannel alone)

Правила ingress

Правила ingress разрешают трафик В выбранные pod. Записи from объединяются по ИЛИ; ports — по ИЛИ. podSelector совпадает с pod в том же namespace; namespaceSelector — с целыми namespace (используйте автоматически добавляемую метку kubernetes.io/metadata.name). Оба в одном элементе объединяются по И.

kubernetes
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-web
  namespace: prod
spec:
  podSelector:
    matchLabels:
      app: web
  policyTypes:
    - Ingress
  ingress:
    - from:
        - podSelector:               # pods in same namespace
            matchLabels:
              app: gateway
        - namespaceSelector:         # whole other namespace
            matchLabels:
              kubernetes.io/metadata.name: monitoring
        - ipBlock:                   # external CIDR
            cidr: 10.0.0.0/8
      ports:
        - protocol: TCP
          port: 8080

Правила egress

Правила egress управляют тем, КУДА выбранные pod могут обращаться. Частая ловушка: default-deny egress ломает разрешение DNS, и pod не могут достучаться до kube-dns. Всегда разрешайте UDP/TCP 53 в namespace kube-system, прежде чем запрещать всё остальное. ipBlock.except задаёт исключения.

kubernetes
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-egress-dns
  namespace: prod
spec:
  podSelector:
    matchLabels:
      app: web
  policyTypes:
    - Egress
  egress:
    - to:
        - namespaceSelector: {}     # any namespace (kube-dns)
      ports:
        - protocol: UDP
          port: 53
    - to:
        - ipBlock:
            cidr: 0.0.0.0/0
            except:
              - 10.0.0.0/8          # allow internet, deny internal
      ports:
        - protocol: TCP
          port: 443

# WARNING: egress deny-all blocks DNS and breaks pods.
# Always allow kube-dns first.

Селекторы и выбор namespace

Одиночный podSelector совпадает с pod в namespace самой политики. namespaceSelector совпадает с целыми namespace. Указание И podSelector, И namespaceSelector в одном элементе объединяет их по И (pod с меткой X в namespace Y); как отдельные элементы — по ИЛИ. ipBlock совпадает с внешними IP.

kubernetes
spec:
  podSelector:                       # selects pods in THIS namespace
    matchLabels:
      app: web
  ingress:
    - from:
        # SAME namespace, matching pods
        - podSelector:
            matchLabels:
              app: gateway

        # DIFFERENT namespace (whole namespace)
        - namespaceSelector:
            matchLabels:
              kubernetes.io/metadata.name: monitoring

        # BOTH: pods in another namespace with specific labels
        - namespaceSelector:
            matchLabels:
              kubernetes.io/metadata.name: backend
          podSelector:
            matchLabels:
              app: api

        # external IP range
        - ipBlock:
            cidr: 192.168.1.0/24

Политики по умолчанию (запретить/разрешить всё)

Политики default-deny (пустые правила) запирают namespace так, что дыры открывают только явные allow-списки. Применяйте deny-all для ingress и egress как базу, затем добавляйте точечные разрешения. Пустая запись ingress: [{}] разрешает весь ingress — лазейка для отказа от политики.

kubernetes
# --- DEFAULT DENY INGRESS (in a namespace) ---
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: default-deny-ingress
  namespace: prod
spec:
  podSelector: {}
  policyTypes: [Ingress]
---
# --- DEFAULT DENY EGRESS ---
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: default-deny-egress
  namespace: prod
spec:
  podSelector: {}
  policyTypes: [Egress]
---
# --- ALLOW ALL INGRESS (whitelist opt-out) ---
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-all-ingress
  namespace: prod
spec:
  podSelector: {}
  policyTypes: [Ingress]
  ingress:
    - {}      # allow from anywhere

Типы политик и поведение по умолчанию

NetworkPolicy аддитивны: как только любая политика выбирает pod, этот тип трафика для pod становится default-deny, если явное правило его не разрешает. Без политик всё открыто. Смотрите политики, совпадающие с метками pod, чтобы понять, что управляет его трафиком.

kubernetes
spec:
  policyTypes:
    - Ingress
    - Egress
  # if omitted, defaults are inferred:
  #   - Ingress is always present (a policy always affects ingress)
  #   - Egress is implied if any egress rule exists

# key behaviors:
# - policies are ADDITIVE: a pod is allowed if ANY matching
#   policy permits the traffic
# - if NO policy selects a pod => all traffic allowed (default open)
# - if at least one policy selects a pod => default deny for that type
#   unless an explicit rule allows it

# inspect effective policies for a pod
kubectl get networkpolicy -n prod -l app=web
18

RBAC

Role (в namespace)

Role даёт права на ресурсы в namespace в пределах одного namespace. rules перечисляют apiGroups, resources и verbs. pods/log — подресурс; pods/exec требует verb create (потому что exec создаёт подресурс). '*' заменяет любое значение.

kubernetes
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  name: pod-reader
  namespace: dev
rules:
  - apiGroups: [""]
    resources: ["pods", "pods/log"]
    verbs: ["get", "list", "watch"]
  - apiGroups: [""]
    resources: ["pods/exec"]
    verbs: ["create"]
# a Role grants permissions WITHIN one namespace
# verbs: get, list, watch, create, update, patch, delete, deletecollection, "*"
# apiGroups: "" (core), "apps", "batch", "rbac.authorization.k8s.io", ...

RoleBinding

RoleBinding даёт Role (или ClusterRole, ограниченную одним namespace) субъектам: Users, Groups или ServiceAccounts. Binding живёт в namespace, где применяются права. roleRef неизменяем: чтобы изменить связанную Role, удалите и создайте binding заново.

kubernetes
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: read-pods
  namespace: dev
subjects:
  - kind: User
    name: alice
    apiGroup: rbac.authorization.k8s.io
  - kind: ServiceAccount
    name: my-sa
    namespace: dev
  - kind: Group
    name: dev-team
    apiGroup: rbac.authorization.k8s.io
roleRef:
  kind: Role
  name: pod-reader
  apiGroup: rbac.authorization.k8s.io
# binds the Role to users, groups, or service accounts
# RoleBinding can also reference a ClusterRole (scoped to its namespace)

ClusterRole и ClusterRoleBinding

ClusterRole даёт права на кластерные ресурсы (nodes, namespaces, PV) — Role до них не достаёт. ClusterRole также можно привязать в любом namespace через RoleBinding для переиспользования (определить один раз, привязать много раз). ClusterRoleBinding даёт ClusterRole на весь кластер.

kubernetes
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: node-reader
rules:
  - apiGroups: [""]
    resources: ["nodes"]
    verbs: ["get", "list", "watch"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: read-nodes
subjects:
  - kind: ServiceAccount
    name: monitor
    namespace: kube-system
roleRef:
  kind: ClusterRole
  name: node-reader
  apiGroup: rbac.authorization.k8s.io
# ClusterRole grants cluster-scoped resources (nodes, PVs, namespaces)
# or can be reused across namespaces via a RoleBinding

Verbs, resources и apiGroups

apiGroups группируют ресурсы: core — '' (пустая строка); apps содержит Deployment/StatefulSet; batch — Job/CronJob. Подресурсы (pods/log, pods/exec, pods/portforward) — отдельные права. resourceNames ограничивает правило конкретными экземплярами. nonResourceURLs покрывает /healthz, /metrics и т. п.

kubernetes
rules:
  - apiGroups: [""]                        # core API group
    resources: ["pods", "services", "configmaps", "secrets"]
    verbs: ["get", "list", "watch"]
  - apiGroups: ["apps"]
    resources: ["deployments", "replicasets", "statefulsets"]
    verbs: ["*"]
  - apiGroups: ["batch"]
    resources: ["jobs", "cronjobs"]
    verbs: ["create", "delete", "get"]
  - apiGroups: [""]
    resources: ["pods/log", "pods/exec", "pods/portforward"]
    verbs: ["get", "create"]
  - nonResourceURLs: ["/healthz", "/healthz/*"]   # non-resource URLs
    verbs: ["get"]

# resourceNames: restrict to specific instances
  - apiGroups: [""]
    resources: ["configmaps"]
    resourceNames: ["my-config"]
    verbs: ["get"]

ServiceAccount

ServiceAccount — идентичность для pod. Назначайте через serviceAccountName; токен автоматически монтируется в /var/run/secrets/kubernetes.io/serviceaccount. С 1.24 у SA нет постоянных токенов в Secret — используйте kubectl create token для короткоживущих токенов. automountServiceAccountToken: false отключает монтирование.

kubernetes
# create a service account
kubectl create serviceaccount my-sa -n dev

# assign a RoleBinding (see RoleBinding example)
# mount the SA in a pod
apiVersion: v1
kind: Pod
metadata:
  name: app
spec:
  serviceAccountName: my-sa
  automountServiceAccountToken: false   # opt out of token mount
  containers:
    - name: app
      image: myapp:1.0

# short-lived tokens (1.24+) - no permanent secret
kubectl create token my-sa -n dev --duration=1h

# list SAs
kubectl get sa -n dev

kubectl auth can-i

kubectl auth can-i проверяет права RBAC для текущего (или имперсонированного) пользователя — необходимо для отладки ошибок forbidden. --list показывает все разрешённые verbs и resources. --as имперсонирует пользователя или SA для теста. Встроенные роли (view, edit, admin, cluster-admin) покрывают частые нужды.

kubernetes
# check if you can do something
kubectl auth can-i create pods -n dev
kubectl auth can-i delete deployments -n prod

# check on behalf of another user/SA
kubectl auth can-i list secrets --as=system:serviceaccount:dev:my-sa -n dev

# check all allowed verbs on a resource
kubectl auth can-i --list --as=alice -n dev

# whoami (1.25+)
kubectl auth whoami

# reconcile: detect over-privileged bindings
kubectl get rolebindings,clusterrolebindings --all-namespaces -o wide

# common built-in cluster roles:
#   view, edit, admin, cluster-admin
19

Пробы (liveness/readiness/startup)

Liveness-проба

Liveness-проба говорит kubelet, когда перезапускать контейнер. Если она падает failureThreshold раз подряд, kubelet убивает контейнер и применяется политика перезапуска. Используйте её для выхода из дедлоков и невосстановимых состояний, а не для проверки зависимостей (это readiness).

kubernetes
apiVersion: v1
kind: Pod
metadata:
  name: app
spec:
  containers:
    - name: app
      image: myapp:1.0
      livenessProbe:
        httpGet:
          path: /healthz
          port: 8080
        initialDelaySeconds: 15
        periodSeconds: 10
        timeoutSeconds: 2
        failureThreshold: 3
        successThreshold: 1
# if the probe fails failureThreshold times in a row,
# kubelet kills and restarts the container (per restartPolicy)

Readiness-проба

Readiness-проба управляет тем, получает ли pod трафик от Сервисов. Падающая readiness убирает IP pod из endpoints, но НЕ перезапускает его. Используйте для прогрева (не маршрутизировать, пока не готов) и для слива трафика при временных сбоях и корректной остановке.

kubernetes
apiVersion: v1
kind: Pod
metadata:
  name: app
spec:
  containers:
    - name: app
      image: myapp:1.0
      readinessProbe:
        httpGet:
          path: /ready
          port: 8080
        initialDelaySeconds: 5
        periodSeconds: 5
        failureThreshold: 3
# a failing readiness probe REMOVES the pod from service endpoints,
# but does NOT restart the container.
# use to drain traffic during deploys, warm-up, or transient outages.

Startup-проба

Startup-проба (1.18+) для медленно стартующих приложений (Java, устаревшие серверы). Пока она выполняется, liveness и readiness отключены, поэтому медленный старт не убивается liveness. После успешного старта liveness/readiness активируются. Для загрузки задайте длинное окно failureThreshold × periodSeconds.

kubernetes
apiVersion: v1
kind: Pod
metadata:
  name: slow-app
spec:
  containers:
    - name: app
      image: myapp:1.0
      startupProbe:
        httpGet:
          path: /startup
          port: 8080
        failureThreshold: 30
        periodSeconds: 10      # up to 300s to start
      livenessProbe:
        httpGet:
          path: /healthz
          port: 8080
        periodSeconds: 10
# while the startup probe runs, liveness/readiness are disabled.
# once startup succeeds, liveness/readiness take over.

Обработчики проб

Три типа обработчиков: httpGet (успех = HTTP 2xx/3xx), tcpSocket (успех = TCP-соединение), exec (успех = код выхода 0). gRPC-проба (GA с 1.27) — чистый вариант для gRPC-сервисов. Предпочитайте httpGet: он позволяет приложению сообщить «здоров, но занят» (503) без перезапуска. exec хрупок (нужны shell и бинарники в образе).

kubernetes
# three handler types:

# 1. HTTP GET (most common) - success = 200-399
livenessProbe:
  httpGet:
    path: /healthz
    port: 8080
    httpHeaders:
      - name: X-Custom
        value: probe
    scheme: HTTP

# 2. TCP socket - success = port open
livenessProbe:
  tcpSocket:
    port: 3306

# 3. Exec - success = exit code 0
livenessProbe:
  exec:
    command:
      - /bin/sh
      - -c
      - "pg_isready -h localhost"

# gRPC (1.24+, alpha -> GA): use grpc probe
livenessProbe:
  grpc:
    port: 9090
    service: my.package.Health

Параметры проб

initialDelaySeconds откладывает первую пробу, но startup-проба — более чистый способ обработать медленный старт. periodSeconds — частота; failureThreshold × periodSeconds — сколько pod может быть нездоров до действий. Уменьшайте для быстрого failover, увеличивайте для терпимости. terminationGracePeriodSeconds ограничивает остановку.

kubernetes
livenessProbe:
  httpGet:
    path: /healthz
    port: 8080
  initialDelaySeconds: 15   # wait before first probe (after start)
  periodSeconds: 10         # probe every 10s
  timeoutSeconds: 2         # max time per probe
  successThreshold: 1       # consecutive successes to mark OK
  failureThreshold: 3       # consecutive failures to mark failed
  terminationGracePeriodSeconds: 30  # (liveness) grace before SIGKILL

# tuning tips:
# - set initialDelaySeconds > typical startup time
# - OR use a startup probe instead (cleaner)
# - shorter period = faster reaction, more load
# - higher failureThreshold = more tolerant of blips

Поведение при сбое проб

Сбой liveness убивает и перезапускает контейнер на месте (без перепланирования). Сбой readiness лишь убирает pod из Сервисов, без перезапуска. Сбой startup ведёт себя как liveness. Мигающая liveness часто следствие проб, зависящих от медленных внешних сервисов, — держите проверки здоровья локальными и дешёвыми.

kubernetes
# --- LIVENESS FAIL ---
#   container killed -> restarted (per restartPolicy: Always/OnFailure)
#   pod stays on the same node (NOT rescheduled)
#   CrashLoopBackOff if it keeps failing

# --- READINESS FAIL ---
#   pod stays running, but is REMOVED from Service endpoints
#   no traffic until it succeeds again
#   NOT restarted by kubelet

# --- STARTUP FAIL ---
#   container killed and restarted (like liveness)
#   liveness/readiness never activate
#   after failureThreshold × periodSeconds, pod is stuck restarting

# check probe results:
kubectl describe pod app | grep -A5 "Last State"
kubectl get pod app -o jsonpath='{.status.containerStatuses[*].state}'

# common cause of flapping: liveness probe hitting a slow dependency
20

Ресурсы и продвинутый kubectl

Requests и limits

requests — то, что резервирует планировщик (pod планируется, только если у узла есть свободные requests): задавайте их по своим стабильным потребностям. limits — жёсткие потолки: CPU троттлится, память вызывает OOMKill. cpu в ядрах (500m = 0.5), память в байтах (Mi/Gi). В production задавайте оба.

kubernetes
spec:
  containers:
    - name: app
      image: myapp:1.0
      resources:
        requests:           # what the scheduler guarantees (reservation)
          cpu: 250m          # 250 millicores = 0.25 core
          memory: 256Mi      # 256 mebibytes
          ephemeral-storage: 1Gi
        limits:             # hard ceiling (enforced)
          cpu: "1"           # 1 core
          memory: 512Mi
          ephemeral-storage: 2Gi

# cpu limit: throttled (cfs quota)
# memory limit: OOMKilled if exceeded
# ephemeral-storage limit: evicted if exceeded
# request only (no limit): best-effort burst

Значения по умолчанию LimitRange

LimitRange применяет default requests/limits к pod, которые их не указали, — критично, когда ResourceQuota требует requests. max/min ограничивают, насколько большим или малым может быть один контейнер. maxLimitRequestRatio ограничивает, насколько контейнер может превышать свой request, защищая от «шумных соседей».

kubernetes
apiVersion: v1
kind: LimitRange
metadata:
  name: defaults
  namespace: prod
spec:
  limits:
    - type: Container
      default:               # applied as LIMITS when not set
        cpu: 500m
        memory: 512Mi
      defaultRequest:        # applied as REQUESTS when not set
        cpu: 100m
        memory: 128Mi
      max:                   # max allowed LIMITS
        cpu: "4"
        memory: 8Gi
      min:                   # min allowed REQUESTS
        cpu: 50m
        memory: 64Mi
      maxLimitRequestRatio:  # limit/request ratio cap (burst cap)
        cpu: "4"

# a pod with no resources gets default/defaultRequest applied
# a pod with limit=4cpu, request=50m would breach maxLimitRequestRatio

Horizontal Pod Autoscaler

HPA масштабирует реплики по метрикам (CPU/память через metrics-server или свои и внешние через Prometheus Adapter). behavior (v2) настраивает агрессивность: stabilizationWindowSeconds предотвращает мигание, policies ограничивают скорость в минуту. Масштабирование вверх обычно быстрое и агрессивное, вниз — намеренно медленное.

kubernetes
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: web
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: web
  minReplicas: 3
  maxReplicas: 50
  metrics:
    - type: Resource
      resource:
        name: cpu
        target:
          type: Utilization          # avg across pods
          averageUtilization: 70
    - type: Resource
      resource:
        name: memory
        target:
          type: Utilization
          averageUtilization: 80
  behavior:                          # (v2) scale up/down tuning
    scaleDown:
      stabilizationWindowSeconds: 300
      policies:
        - type: Percent
          value: 50                  # max 50% down per minute
          periodSeconds: 60
    scaleUp:
      stabilizationWindowSeconds: 0
      policies:
        - type: Percent
          value: 100
          periodSeconds: 60

# requires metrics-server for CPU/memory
kubectl get hpa web -w

Pod Disruption Budget

PodDisruptionBudget ограничивает, сколько pod набора можно добровольно выселить одновременно, защищая доступность при drain узлов и действиях cluster-autoscaler. Используйте minAvailable или maxUnavailable (не оба). Он НЕ защищает от непроизвольных сбоев (отказ железа): только реплики.

kubernetes
apiVersion: policy/v1
kind: PodDisruptionBudget
metadata:
  name: web-pdb
  namespace: prod
spec:
  minAvailable: 2            # at least 2 pods always available
  # OR
  # maxUnavailable: 1        # at most 1 down at a time
  selector:
    matchLabels:
      app: web
# PDB protects against VOLUNTARY disruptions:
#   - kubectl drain (node maintenance)
#   - cluster autoscaler evictions
#   - kubectl delete pod (controller-managed)
# It does NOT prevent INVOLUNTARY disruptions (node failure, kernel panic).

# check PDB status
kubectl get pdb -n prod
kubectl describe pdb web-pdb -n prod

Taints, tolerations и affinity

Taints отталкивают pod; tolerations позволяют конкретным pod их игнорировать — используйте для выделения узлов (GPU, ingress, control-plane). nodeAffinity предпочитает или требует определённые узлы. podAntiAffinity разносит реплики по топологическим доменам (хосты, зоны) для отказоустойчивости. Taint снимается дефисом в конце при том же key+effect.

kubernetes
# taint a node
kubectl taint nodes node-1 dedicated=gpu:NoSchedule

# tolerate the taint so a pod can schedule there
spec:
  tolerations:
    - key: dedicated
      operator: Equal
      value: gpu
      effect: NoSchedule

# prefer specific nodes
spec:
  affinity:
    nodeAffinity:
      preferredDuringSchedulingIgnoredDuringExecution:
        - weight: 100
          preference:
            matchExpressions:
              - key: disktype
                operator: In
                values: [ssd]
    podAntiAffinity:               # spread replicas across nodes
      requiredDuringSchedulingIgnoredDuringExecution:
        - topologyKey: kubernetes.io/hostname
          labelSelector:
            matchLabels:
              app: web

# remove a taint
kubectl taint nodes node-1 dedicated=gpu:NoSchedule-

Продвинутый kubectl (patch/wait/top/debug)

patch поддерживает типы JSON, strategic-merge и merge. wait блокируется до выполнения условия — идеально для скриптов. top показывает живое потребление CPU и памяти (нужен metrics-server). kubectl debug добавляет эфемерный контейнер в работающий pod (отлично для distroless-образов) или открывает shell на узле.

kubernetes
# JSON patch (precise field ops)
kubectl patch deployment web --type json -p \
  '[{"op":"replace","path":"/spec/replicas","value":3}]'

# strategic merge patch (default for k8s objects)
kubectl patch svc web -p '{"spec":{"type":"NodePort"}}'

# wait for a condition
kubectl wait --for=condition=Ready pod/web --timeout=60s
kubectl wait --for=delete pod/web --timeout=30s

# resource usage (needs metrics-server)
kubectl top nodes
kubectl top pods -n prod
kubectl top pod web --containers

# ephemeral debug container (1.25+)
kubectl debug -it web --image=busybox --target=web
# debug a node
kubectl debug node/node-1 -it --image=ubuntu

# run a one-off pod
kubectl run tmp --rm -it --image=alpine -- sh

# explain a field
kubectl explain pod.spec.containers.resources

Was this helpful?

Learning path

Learn from scratch

Learn this language from the ground up with structured lessons.