Kubernetes (K8s) er en open-source platform, der automatiserer deployment, scaling og drift af containeriserede applikationer. I et selfhostet IT-miljø (f.eks. on-premises eller i en privat cloud) tilbyder Kubernetes en række nøglefunktionaliteter, der gør det muligt at håndtere komplekse applikationer effektivt og skalerbart. Her er en oversigt over de vigtigste funktioner og deres relevans i et selfhostet miljø:
1. Container Orchestration Formål: Automatiser styringen af container-livscyklusser (opstart, stop, genstart, skalering). Funktionaliteter:
Pods: Den mindste enhed i Kubernetes, der kører en eller flere containere (f.eks. Docker). Pods deler netværk og lagring, hvilket gør dem ideelle til tæt integrerede applikationer. Deployments: Styrer opdateringer af applikationer ved at rulle ændringer ud gradvist (rolling updates) og rulle tilbage, hvis noget går galt. StatefulSets: Understøtter stateful applikationer (f.eks. databaser) ved at bevare identiteten og lagringen for hver pod. DaemonSets: Sikrer, at en pod kører på alle (eller udvalgte) noder i clusteret – nyttigt til systemopgaver som log-indsamling (f.eks. Fluentd) eller overvågning (f.eks. Prometheus Node Exporter). Selfhostet fordel:
Gør det muligt at køre og skalere applikationer konsistent på eget hardware uden afhængighed af eksterne tjenester.
2. Skalering Formål: Tilpasse ressourceforbruget dynamisk baseret på belastning. Funktionaliteter:
Horizontal Pod Autoscaler (HPA): Skalerer antallet af pods automatisk baseret på CPU/memory-forbrug eller custom metrikker (f.eks. requests per sekund). Vertical Pod Autoscaler (VPA): Justerer ressourceanmodninger (CPU/memory) for pods dynamisk. Cluster Autoscaler: Tilføjer eller fjerner noder i clusteret automatisk, når ressourcerne er utilstrækkelige eller overflødige. Selfhostet fordel:
Optimerer udnyttelsen af eget hardware og reducerer manuel indgriben.
3. Netværk Formål: Sikre kommunikation mellem pods, tjenester og eksterne systemer. Funktionaliteter:
Services: Udstiller applikationer internt (ClusterIP) eller eksternt (NodePort, LoadBalancer, Ingress).
Ingress: Styrer ekstern trafik til tjenester via regler (f.eks. baseret på hostnavne eller stier).
Network Policies: Definerer, hvilke pods der må kommunikere med hinanden (firewall-lignende regler). Service Mesh (f.eks. Istio, Linkerd): Avanceret trafikstyring, load balancing, og observability (kræver ekstra opsætning). Selfhostet fordel:
Gør det muligt at oprette avancerede netværksarkitekturer uden afhængighed af cloud-providers netværkstjenester.
4. Lagring Formål: Persistent lagring til stateful applikationer. Funktionaliteter:
Persistent Volumes (PV): Lagringsressourcer i clusteret (f.eks. NFS, iSCSI, lokal disk). Persistent Volume Claims (PVC): Anmodninger om lagring fra applikationer, der binder til tilgængelige PV’er. StorageClasses: Definerer typer af lagring (f.eks. SSD, HDD) og provisionering (dynamisk eller statisk). CSI (Container Storage Interface): Standardiseret grænseflade til integration med eksterne lagringsløsninger (f.eks. Ceph, GlusterFS). Selfhostet fordel:
Understøtter integration med lokale lagringsløsninger (f.eks. NFS-servere eller SAN).
5. Konfiguration og Secrets Formål: Centraliseret håndtering af konfigurationer og følsomme data. Funktionaliteter:
ConfigMaps: Gemmer konfigurationsdata (f.eks. miljøvariabler, konfigurationsfiler) som key-value par. Secrets: Gemmer følsomme data (f.eks. adgangskoder, API-nøgler) krypteret (base64-kodet som standard, men kan integreres med eksterne vaults som HashiCorp Vault). Selfhostet fordel:
Sikrer, at konfigurationer og secrets er tilgængelige for applikationer uden at blive hardcoded.
6. Overvågning og Logging Formål: Indsamling af metrikker, logs og events for fejlfinding og performanceanalyse. Funktionaliteter:
Metrics Server: Indsamler ressourceforbrug (CPU, memory) for pods og noder. Prometheus + Grafana: Populær stack til overvågning og visualisering af metrikker. EFK Stack (Elasticsearch, Fluentd, Kibana): Centraliseret log-indsamling og analyse. Events: Kubernetes genererer events for vigtige hændelser (f.eks. pod-fejl, skalering). Selfhostet fordel:
Giver fuld kontrol over overvågningsdata og integration med eksisterende værktøjer.
7. Sikkerhed Formål: Beskytte clusteret og applikationer mod trusler. Funktionaliteter:
RBAC (Role-Based Access Control): Definerer roller og rettigheder for brugere og tjenester. Pod Security Policies (PSP) / OPA Gatekeeper: Håndhæver sikkerhedspolitikker for pods (f.eks. kørsel som non-root, read-only filesystems). Network Policies: Begrænser kommunikation mellem pods. TLS og mTLS: Kryptering af trafik mellem pods og tjenester (f.eks. via cert-manager til automatisk udstedelse af certifikater). Selfhostet fordel:
Gør det muligt at implementere strenge sikkerhedspolitikker i eget miljø.
8. Selvheling (Self-Healing) Formål: Automatisk genopretning af fejlende komponenter. Funktionaliteter:
Liveness Probes: Genstarter pods, hvis applikationen ikke responderer. Readiness Probes: Sikrer, at trafik kun sendes til pods, der er klar til at modtage requests. Restart Policies: Automatisk genstart af containere ved fejl. Selfhostet fordel:
Reducerer downtime og manuel indgriben.
9. Multi-Cluster og Federation Formål: Styring af flere Kubernetes-clustere som en enhed. Funktionaliteter:
Kubernetes Federation: Synkroniserer ressourcer (f.eks. Deployments, Services) på tværs af clustere. Cluster API: Standardiseret måde at oprette og styre clustere på (f.eks. via Kubeadm eller værktøjer som Rancher). Selfhostet fordel:
Gør det muligt at skalere infrastrukturen geografisk eller funktionelt (f.eks. udvikling vs. produktion).
10. Udvidelsesmuligheder (Extensibility) Formål: Tilpas Kubernetes til specifikke behov. Funktionaliteter:
Custom Resource Definitions (CRDs): Udvid Kubernetes API’et med egne ressourcer (f.eks. databaser, backup-jobs). Operators: Automatiserer drift af komplekse applikationer (f.eks. databaser som PostgreSQL eller MongoDB) ved at bruge CRDs og controllers. Admission Controllers: Tilføjer logik til validering eller modification af API-anmodninger (f.eks. for at håndhæve politikker). Selfhostet fordel:
Gør det muligt at integrere Kubernetes med eksisterende værktøjer og processer.
Typisk Arkitektur i et Selfhostet Miljø Her er et eksempel på, hvordan Kubernetes kan integreres i et selfhostet miljø:
Hardware:
Fysiske servere eller VM’er (f.eks. via Proxmox, VMware, eller KVM). Noder med Linux (f.eks. Ubuntu, RHEL, SUSE).
Kubernetes Cluster:
Control Plane: Kører på dedikerede noder (etcd, API Server, Scheduler, Controller Manager). Worker Nodes: Kører applikations-pods (kubelet, kube-proxy, container runtime som containerd eller CRI-O).
Netværk:
CNI-plugin (f.eks. Calico, Flannel, Cilium) til pod-netværk. Load balancer (f.eks. MetalLB) til ekstern trafik.
Lagring:
Lokal lagring (f.eks. hostPath) eller delt lagring (f.eks. NFS, Ceph).
Overvågning:
Prometheus + Grafana for metrikker. Loki + Promtail for logs.
Sikkerhed:
RBAC og Network Policies. Cert-manager for TLS-certifikater.
CI/CD:
Integration med værktøjer som ArgoCD, Jenkins, eller GitLab CI for automatiseret deployment.