Kubernetes: Clustere și diagrame Helm

Kubernetes: Clustere și diagrame Helm

1) Arhitectura clusterului - Vedere de sus

Planul de control: "kube-apiserver", "etcd'," kube-scheduler "," kube-controller-manager ", (partea este ascunsă în nori controlați).
Lucrător: 'kubelet', runtime CRI (containerd/CRI-O), plugin CNI, kube-proxy/ebpf-proxy.
Rețea intracluster: Pod-to-Pod, Service-VIP/ClusterIP, DNS CoreDNS.
Stocare: drivere CSI, aprovizionare dinamică din PVC → PV (StorageClass).
Limite de defecțiune: nod/AZ/regiune. Locul replici pe zone (TopologySpreadConstringeri/anti-afinitate).

Roluri tipice

Comanda platformei: creează/actualizează clustere, CNI/CSI/Ingress, politică și GitOps.
Echipele de produse: diagrame de depozit/versiuni, urmați politicile de securitate și resursele.

2) Ciclul de viață al clusterului

Creație: kOps, kubeadm, Rancher, EKS/AKS/GKE. Activați imediat autentificarea și auditarea OIDC.
Upgrade-uri: versiuni minore la rândul lor (control plan → noduri), controlate de maxIndisponibil, teste pe stadializare.
Suplimente (toate prin Helm/GitOps): CNI (Calico/Cilium), driver CSI, controler de intrare (NGINX/Gateway API/Contour/Traefik), Metrics-Server, Cluster-Autoscaler, Node - Local DNS, logare/metrics/trace.
Backup-uri: etcd instantaneu (dacă auto-gestionat), Velero pentru namespace/PVC.

3) Rețele, servicii și intrare

CNI: Calico (NetworkPolicy), Cilium (eBPF/servicemes- фичи).
Serviciu: 'ClusterIP', 'NodePort', 'LoadBalancer' (L4 cloud balancing), 'ExternalName'.
Intrare/Gateway API: rutare L7, TLS, rate-limit/WAF istoric la perimetru.
NetworkPolicy: deny-all + permite explicit prin namespace/etichetă în mod implicit.
Serviciul fără cap ('clusterIP: None') pentru StatefulSet și descoperirea serviciului.

4) Stocare (CSI) și stări

StorageClass: 'reclaimPolicy', 'volumeBindingMode' ('WaitForFirstConsumer' pentru o mai bună plasare).
StatefulSet: nume/volume stabile ('volumeClaimTemplates'), 'podManagementPolicy: Parallel' pentru scanări rapide.
ReadWriteMany: utilizați cu atenție fișierul distribuit (EFS/Filestore) - evaluați latența.
Instantanee: 'VolumeSnapshotClass' + copii de rezervă cron.

5) Multi-chirie și politică

Namespaces după produs/mediu.
RBAC: roluri minime, conturi de servicii separate, „Rol ”/„ RoleBinding” în loc de „ClusterRole” acolo unde este posibil.
PSA (Pod Security Admission): modurile „baseline ”/„ restricționate” (înlocuire PSP).
ResourceCote/LimitRange: потолки CPU/Memory/PVC/LoadBalancer.
OPA Gatekeeper/Kyverno: politica de admitere (ex. interdicție „: cele mai recente”, cerința „resurse”, „readOnlyRootFilesystem”).
ImagePolicy/webhooks: verificarea semnăturii imaginii (cosign/policy-controller).

6) Observabilitate și funcționare

Metrics: stiva Prometheus, kube-state-metrics, nod exportatori.
Jurnale: Fluent Bit/Vector → obiect/ES/OpenSearch, rotație pe noduri.
Trasee: OpenTelemetry Collector.
Tablouri de bord SLO: modelul RED privind serviciile de intrare și cheie.
Autoscale: HPA (după indicatorii aplicației), VPA pentru fundal, Cluster-Autoscaler pentru noduri.

7) Modele manifeste (foaie de ieftin)

yaml apiVersion: apps/v1 kind: Deployment metadata: { name: api, labels: { app: api } }
spec:
replicas: 3 strategy: { type: RollingUpdate, rollingUpdate: { maxUnavailable: 0, maxSurge: 1 } }
selector: { matchLabels: { app: api } }
template:
metadata:
labels: { app: api }
spec:
serviceAccountName: api-sa securityContext: { runAsNonRoot: true, fsGroup: 2000 }
containers:
- name: api image: registry. example. com/api:1. 2. 3 ports: [{ containerPort: 8080 }]
resources: { requests: { cpu: "200m", memory: "256Mi" }, limits: { cpu: "1", memory: "512Mi" } }
readinessProbe: { httpGet: { path: /healthz, port: 8080 }, periodSeconds: 5 }
livenessProbe: { httpGet: { path: /livez,  port: 8080 }, initialDelaySeconds: 20 }

yaml apiVersion: apps/v1 kind: StatefulSet metadata: { name: db }
spec:
serviceName: db replicas: 3 podManagementPolicy: Parallel selector: { matchLabels: { app: db } }
template:
metadata: { labels: { app: db } }
spec:
containers:
- name: db image: postgres:16-alpine volumeMounts: [{ name: data, mountPath: /var/lib/postgresql/data }]
volumeClaimTemplates:
- metadata: { name: data }
spec:
accessModes: ["ReadWriteOnce"]
resources: { requests: { storage: 100Gi } }
storageClassName: fast-ssd

yaml apiVersion: policy/v1 kind: PodDisruptionBudget metadata: { name: api-pdb }
spec:
minAvailable: 2 selector: { matchLabels: { app: api } }

yaml apiVersion: networking. k8s. io/v1 kind: Ingress metadata:
name: api annotations:
nginx. ingress. kubernetes. io/proxy-read-timeout: "30"
spec:
tls: [{ hosts: ["api. example. com"], secretName: api-tls }]
rules:
- host: api. example. com http:
paths:
- path: /
pathType: Prefix backend: { service: { name: api, port: { number: 80 } } }

8) Helm v3 - elemente de bază și structură

Diagramă = șabloane + valori + metadate.

mychart/
Chart. yaml     # name, version (semver), type (application/library), dependencies values. yaml # default values. schema. json # (recommended) validation values templates/# .yaml. gotmpl (Deployment, Service, Ingress, …)
templates/tests/  # helm tests (smoke)
charts/# local dependencies (or OCI dependencies)

yaml apiVersion: v2 name: api description: API service type: application version: 1. 4. 0 # chart version (semver)
appVersion: "1. 2. 3" # dependencies application version:
- name: redis version: 17. x.x repository: "oci://registry. example. com/charts"

9) Șabloane Helm - Practici

Utilizați ajutoare în '_ helpers. tpl "pentru nume/etichete/adnotări.
Specificați peste tot „resurse”, „context de securitate”, „disponibilitate/viață”.
Generați etichete în conformitate cu o schemă standardizată ('app kubernetes. io/').
Asigurați-caracteristici opționale prin „valori” (intrare/hpa/pdb/servicemonitor).
Includeţi valorile. schema. json '- oprire de la configurații incorecte.
Pentru date sensibile - Secretele de la operatorii externi (secrete externe, SOPS), și nu stoca în valori.

gotmpl
{{- define "api. fullname" -}}
{{- printf "%s-%s".Chart. Name. Release. Name      trunc 63      trimSuffix "-" -}}
{{- end -}}

gotmpl apiVersion: apps/v1 kind: Deployment metadata:
name: {{ include "api. fullname". }}
labels: {{- include "api. labels". nindent 4 }}
spec:
replicas: {{.Values. replicaCount }}
strategy:
rollingUpdate:
maxSurge: 1 maxUnavailable: 0 selector:
matchLabels: {{- include "api. selectorLabels". nindent 6 }}
template:
metadata:
labels: {{- include "api. selectorLabels". nindent 8 }}
spec:
serviceAccountName: {{ include "api. serviceAccountName". }}
securityContext: {{- toYaml. Values. podSecurityContext      nindent 8 }}
containers:
- name: {{.Chart. Name }}
image: "{{.Values. image. repository }}:{{.Values. image. tag }}"
imagePullPolicy: IfNotPresent ports: [{ containerPort: {{.Values. service. port }} }]
resources: {{- toYaml. Values. resources      nindent 10 }}
envFrom:
- secretRef: { name: {{.Values. secretsRef }} }

10) Dependențe, depozite și OCI

Helm v3 acceptă registrele OCI: 'oci ://registry/org/charts'.
Versiuni de dependență de blocare ('^ 1. 2. 0`, `~1. 2 ') și rulați „construirea dependenței de cârmă”.
Semnați diagrama (}), depozitați artefacte în depozitul de artefacte CI.
Diagrame bibliotecă: șabloane generale (intrare/servicemonitor) pentru reutilizare.

11) Cârlige, CRD și ordinea operațiunilor

Cârlige: „pre-instalare”, „post-instalare”, „pre-upgrade”, „post-upgrade”, „test”. Adăugați politici („înainte de a-cârlig-crearea”, „cârlig-a reușit”).
CRD: puneți în 'crds/' (setat la șabloane), evitați actualizările CRD pe zbor - migrați separat.
Migrarea bazei de date/inițializare - job-cârlig cu idempotență și timeout.

12) Diagramă și testare CI

"helm' + validarea schemei.
Helm unittest (unitate), diagramă-testare (ct) - asamblare/instalare în natură/minikube în CI.
Teste de instantaneu de șabloane („șablon de cârmă” → compara cu un șablon).
Teste de fum "test de cârmă" (ridica "Pod' cu verificări).

13) GitOps (Argo CD/Flux)

Sursa adevărului este depozitul. Diagrama este stocată ca HelmRelease/HelmChart (Flux) sau Application (Argo).
Politici de chiuvetă: auto-sincronizare cu prune/auto-vindecare, stări și controale de sănătate.
Versiuni de promovare: tag-bots/semver-range, PR-flow.
Împărțiți repo în aplicații (diagrame) și env (suprascrie/valori).
Managementul secret: SOPS (vârstă/KMS), Secrete externe.

14) Siguranță: minim necesar

PSA restricționat: fără privilegii, fără hostPath, capacități limitate, acoperișuri numai pentru citire.
ImagePolicy - numai imagini semnate/de încredere.
NetworkPolicy: „blocat în mod implicit”.
RBAC: cont de serviciu per-app, „Rol ”/„ RoleBinding” în namespace.
Controlul admiterii: Regulile Gatekeeper/Kyverno (resurse/limite, etichete, nu mai târziu).
Secrete: SOPS/Secrete externe; nu puneți secrete în valori/Git simplu.

15) Anti-modele

„: cele mai recente” în diagrame și imagini; absența valorilor. schema. Json '.
O diagramă imensă „pentru orice” în loc de modulară.
CRD-urile sunt actualizate cu șabloane în „șabloane/” → haos pe upgrade-uri.
Nume hard-codate/port/namespace în șabloane.
Lipsa resurselor/limitelor și eșantioanelor → derivă latență și instabilitate.
Nu PDB → zero downtime nu este posibil cu scurgere/upgrade-uri.
Secretele în Git fără criptare; manifestă fără politica de verificare.

16) Lista de verificare a implementării (0-45 zile)

0-10 zile

Creați un schelet grafic de bază cu '_ helpers. tpl', etichete, sonde, resurse, PDB/Ingress opțional.
Включить PSA restricționat, NetworkPolicy neagă toate, ResourceCenta/LimitRange.
Configurați GitOps (Argo/Flux), registru privat, semnătură imagine/diagramă.

11-25 zile

Împărțiți graficul în module/dependențe, adăugați 'valori. schema. json ', teste („scame de cârmă”, unitate, ct).
Conectați observabilitatea (ServiceMonitor/PodMonitor), agenți jurnal, OTel.
Introduceți procesul de upgrade: punerea în scenă → canar → prod, migrarea cârlig cu rollback.

26-45 zile

Automatizați actualizările de dependență (boți/intervale semver + PR).
Adăugați politicile Gatekeeper/Kyverno și rapoartele de politică la CI.
Documentul cluster upgrade runbook, proceduri DR (Velero/etcd instantaneu).

17) Valorile maturității

100% din aplicații sunt epuizate prin Helm/GitOps, fără 'kubectl apply' manual.
Toate diagramele au valori. schema. Json ', teste, semnătură şi versiuni de dependenţă angajate.
PSA restricționat/NetworkPolicy este activat în toate namespace.
PDB și HPA sunt prezente în toate serviciile critice.
SOPS/Secretele externe, nici o politică de ultimă oră, semnătura imaginii.
Cluster și grafic upgrade-uri sunt efectuate fără downtime (canar/albastru-verde), teste de restaurare sunt regulate.

18) Concluzie

Fundația Strong Kubernetes = arhitectură robustă de cluster + politici stricte + diagrame de Helm de calitate industrială gestionate de GitOps. Standardizați șabloanele, securizați mediul PSA/NetworkPolicy/RBAC, validați valorile și automatizați testele, semnătura și promovarea. Apoi upgrade-urile și versiunile vor deveni previzibile, iar platforma va deveni stabilă și convenabilă pentru echipele de produse.